[RELEASE] Release v1.0.0

Conflicts:
	README.md
	sources/tag

.gitignore

@@ -60,3 +60,5 @@ ewol_release
 ehthumbs.db
 Icon?
 Thumbs.db
+Sources/libewol/ewol/os/AndroidAbstraction.cpp
+org_ewol_EwolConstants.h

.travis.yml

@@ -0,0 +1,95 @@
+language: cpp
+
+sudo: required
+dist: trusty
+
+branches:
+  only:
+    - master
+    - dev
+
+addons:
+  apt:
+    sources:
+      - ubuntu-toolchain-r-test
+    packages:
+      - g++-4.9
+      - expect
+      - binutils-mingw-w64-x86-64 # 64bit MinGW
+      - gcc-mingw-w64-x86-64
+      - g++-mingw-w64-x86-64
+
+matrix:
+  include:
+    - os: linux
+      env: CONF=release BUILDER=gcc TARGET=Linux TAG=Linux COMPILATOR_OPTION="--compilator-version=4.9"
+      compiler: gcc
+    - os: linux
+      env: CONF=debug BUILDER=clang TARGET=Linux
+      compiler: clang
+    - os: linux
+      env: CONF=release BUILDER=gcc TARGET=Windows TAG=Mingw
+      compiler: x86_64-w64-mingw32-gcc
+    - os: linux
+      env: CONF=release BUILDER=gcc TARGET=Android TAG=Android DISABLE_PACKAGE=-p
+      compiler: gcc
+    - os: osx
+      env: CONF=release BUILDER=clang TARGET=MacOs TAG=MacOs
+      compiler: clang
+    - os: osx
+      env: CONF=release BUILDER=clang TARGET=IOs TAG=IOs
+      compiler: clang
+
+
+install:
+  - cd ..
+  - pip install --user lutin
+  - if [ "$TAG" == "Android" ]; then
+        git clone --depth 1 --branch master https://github.com/HeeroYui/android-download-tool;
+        ./android-download-tool/dl-android.sh;
+    fi
+  - git clone --depth 1 --branch master https://github.com/atria-soft/ci.git
+  - cd -
+
+before_script:
+  - cd ..
+  - mkdir bin
+  - curl https://storage.googleapis.com/git-repo-downloads/repo > bin/repo
+  - chmod a+x bin/repo
+  - git config --global user.email "travis@travis.com"
+  - git config --global user.name "Travis"
+  - git config --global color.ui "auto"
+  - git config --global core.editor "vi"
+  - mkdir WORKING_DIRECTORY
+  - cd WORKING_DIRECTORY
+  - ../bin/repo init -u https://github.com/atria-soft/manifest.git
+  - ../bin/repo sync -j4
+  - ../bin/repo forall -c git checkout master
+  - ../bin/repo forall -c git checkout $TRAVIS_BRANCH; STATUS=$?
+  - rm -rf atria-soft/ewol
+  - cd ..
+  - pwd
+  - ls -l
+  - if [ "$TRAVIS_OS_NAME" == "osx" ]; then
+        export PATH=$PATH:/Users/travis/Library/Python/2.7/bin/;
+    fi
+  - ./ci/build_send.py --tag=$TAG --status=START;
+
+script:
+  - lutin -w -j4 -C -P -t$TARGET -c $BUILDER $COMPILATOR_OPTION $BUS -m $CONF $GCOV $DISABLE_PACKAGE ewol-test ewol-sample-*; STATUS=$?
+  - ./ci/build_send.py --tag=$TAG --status="$STATUS";
+
+after_script:
+  - if [ "$GCOV" != "" ]; then
+        ./ci/warning_send.py --find-path ./out/Linux_x86_64/$CONF/build/$BUILDER/ewol/;
+    fi
+  - ./out/Linux_x86_64/$CONF/staging/$BUILDER/ewol-test/ewol-test.app/bin/ewol-test --elog-level=6 | tee out_test.txt
+  - if [ "$GCOV" != "" ]; then
+        ./ci/test_send.py --file=out_test.txt;
+        lutin -C -P -t $TARGET -c $BUILDER $COMPILATOR_OPTION $BUS -m $CONF -p ewol?gcov;
+        ./ci/coverage_send.py --json=out/Linux_x86_64/$CONF/build/$BUILDER/ewol/ewol_coverage.json;
+    fi
+
+notifications:
+  email:
+    - yui.heero@gmail.com

Build/Makefile.Android.mk

@@ -1,59 +0,0 @@
-
-
-include $(EWOL_FOLDER)/Build/Makefile.common.mk
-
-
-PROJECT_PACKAGE=$(PROJECT_NAME)package
-JAVA_FOLDER=src/com/$(PROJECT_VENDOR)/$(PROJECT_NAME)
-
-
-all:
-	@echo $(CADRE_HAUT_BAS)
-	@echo $(CADRE_COTERS)
-	@echo '
           DEBUT DE COMPILATION DU PROGRAMME :'$(CADRE_COTERS)
-	@echo '
             Project name    : $(F_BLUE)$(PROJECT_NAME)$(F_NORMALE)'$(CADRE_COTERS)
-	@echo '
             Project Vendor  : $(F_CYAN)$(PROJECT_VENDOR)$(F_NORMALE)'$(CADRE_COTERS)
-	@echo '
             Build date      : $(F_ROUGE)$(BUILD_TIME) $(F_NORMALE)'$(CADRE_COTERS)
-	@echo '
             Tag             : $(F_VIOLET)$(PROJECT_VERSION_TAG) $(F_NORMALE)'$(CADRE_COTERS)
-	@echo $(CADRE_COTERS)
-	@echo $(CADRE_HAUT_BAS)
-	
-	@echo $(F_ROUGE)"
          (sh) Clear previous sources "$(F_NORMALE)
-	@rm -rf src jni/ewolAndroidAbstraction.cpp
-	@echo $(F_ROUGE)"
          (sh) Create folder : $(JAVA_FOLDER)/ "$(F_NORMALE)
-	@mkdir -p $(JAVA_FOLDER)/
-	
-	@echo $(F_ROUGE)"
          (sh) copy the java File : "$(F_NORMALE)
-	@cp $(EWOL_FOLDER)/SourcesJava/PROJECT_NAME.java $(JAVA_FOLDER)/$(PROJECT_NAME).java
-	@echo $(F_ROUGE)"
          (sh) Replace __PROJECT_VENDOR__, __PROJECT_NAME__ and __PROJECT_PACKAGE__ with the correct intance "$(F_NORMALE)
-	@sed -i "s|__PROJECT_VENDOR__|$(PROJECT_VENDOR)|" $(JAVA_FOLDER)/$(PROJECT_NAME).java
-	@sed -i "s|__PROJECT_NAME__|$(PROJECT_NAME)|" $(JAVA_FOLDER)/$(PROJECT_NAME).java
-	@sed -i "s|__PROJECT_PACKAGE__|$(PROJECT_PACKAGE)|" $(JAVA_FOLDER)/$(PROJECT_NAME).java
-	
-	@echo $(F_ROUGE)"
          (sh) copy the cpp for jni File : $(EWOL_FOLDER)/SourcesJava/ewolAndroidAbstraction.cpp"$(F_NORMALE)
-	@cp $(EWOL_FOLDER)/SourcesJava/ewolAndroidAbstraction.cpp jni/
-	@echo $(F_ROUGE)"
          (sh) Replace __PROJECT_VENDOR__, __PROJECT_NAME__ and __PROJECT_PACKAGE__ with the correct intance "$(F_NORMALE)
-	@sed -i "s|__PROJECT_VENDOR__|$(PROJECT_VENDOR)|" jni/ewolAndroidAbstraction.cpp
-	@sed -i "s|__PROJECT_NAME__|$(PROJECT_NAME)|" jni/ewolAndroidAbstraction.cpp
-	@sed -i "s|__PROJECT_PACKAGE__|$(PROJECT_PACKAGE)|" jni/ewolAndroidAbstraction.cpp
-	
-	@echo $(F_ROUGE)"
          (ndk-build) build native code"$(F_NORMALE)
-	cd $(PROJECT_NDK) ; NDK_PROJECT_PATH=$(PROJECT_PATH) NDK_MODULE_PATH=$(PROJECT_MODULE) ./ndk-build
-	@echo $(F_ROUGE)"
          (ant) build java code"$(F_NORMALE)
-	PATH=$(PROJECT_SDK)/tools/:$(PROJECT_SDK)/platform-tools/:$(PATH) ant -Dsdk.dir=$(PROJECT_SDK) debug
-	@echo $(F_ROUGE)"
          (sh) Clear previous sources "$(F_NORMALE)
-	@rm -rf src jni/ewolAndroidAbstraction.cpp
-
-install: all
-	@echo $(CADRE_HAUT_BAS)
-	@echo '           INSTALL : $(F_VIOLET)./bin/$(PROJECT_NAME)-debug.apk$(F_NORMALE)'$(CADRE_COTERS)
-	@echo $(CADRE_HAUT_BAS)
-	@# $(PROJECT_SDK)/platform-tools/adb kill-server
-	@# install application
-	sudo $(PROJECT_SDK)/platform-tools/adb  install -r ./bin/$(PROJECT_NAME)-debug.apk
-
-clean:
-	@echo $(CADRE_HAUT_BAS)
-	@echo '           CLEANING : bin libs gen obj'$(CADRE_COTERS)
-	@echo $(CADRE_HAUT_BAS)
-	rm -rf bin libs gen obj

Build/Makefile.Linux.mk

@@ -1,194 +0,0 @@
-
-
-
-
-include $(EWOL_FOLDER)/Build/Makefile.common.mk
-
-#include $(EWOL_FOLDER)/Build/ewol.mk
-
-###############################################################################
-### Compilateur base system                                                 ###
-###############################################################################
-CXX=g++
-CC=gcc
-AR=ar
-
-
-
-X11FLAGS= -lGL -lGLU
-# some X11 mode availlable : 
-# install package : libxxf86vm-dev
-X11FLAGS+= -lX11 -DEWOL_X11_MODE__XF86V -lXxf86vm
-# install package : libxrender-dev 
-#X11FLAGS+= -lX11 -DEWOL_X11_MODE__XRENDER -lXrandr
-
-
-ifeq ($(shell if `pkg-config --exists freetype2` ; then echo "yes"; else echo "no"; fi), yes)
-    FREETYPE_CFLAGS=  `pkg-config --cflags freetype2` -DEWOL_USE_FREE_TYPE
-    FREETYPE_LDFLAGS= `pkg-config --libs freetype2` -DEWOL_USE_FREE_TYPE
-else
-    FREETYPE_CFLAGS=
-    FREETYPE_LDFLAGS=
-    $(Info  libFreeType-dev is not installed)
-endif
-
-
-
-OBJECT_DIR=Object_$(PLATFORM)
-
-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
-
-
-
-###############################################################################
-### Basic C flags                                                           ###
-###############################################################################
-
-# basic X11 librairy ==> show if we can une under lib ...
-CXXFLAGS=  $(X11FLAGS) $(FREETYPE_CFLAGS) -D__PLATFORM__$(PLATFORM) $(PROJECT_CXXFLAGS)
-
-ifeq ("$(DEBUG)", "0")
-	CXXFLAGS+= -O2
-else
-	# Enable debug (cgdb ***)
-	CXXFLAGS+= -g -O0
-endif
-# display all flags
-CXXFLAGS+= -Wall
-# ...
-CXXFLAGS+= -D_REENTRANT
-# internal defines
-CXXFLAGS+= $(DEFINE)
-# remove warning from the convertion char*
-CXXFLAGS+= -Wno-write-strings
-
-CXXFLAGS+= -DPROJECT_NAME="$(PROJECT_NAME)"
-
-CFLAGS=    $(CXXFLAGS) -std=c99
-
-# basic extern librairy
-LDFLAGS=  $(X11FLAGS) $(FREETYPE_LDFLAGS) $(PROJECT_LDFLAGS)
-
-# Dynamic connection of the CALLBACK of the GUI
-LDFLAGS+= -Wl,--export-dynamic
-
-# TODO : add the prefix ...
-CXXFILES = $(PROJECT_SOURCES)
-# create the list of module : 
-LISTE_MODULES = $(sort $(dir $(CXXFILES)))
-
-###############################################################################
-### Build Object Files List                                                 ###
-###############################################################################
-OBJ = $(addprefix $(OBJECT_DIRECTORY)/, $(CXXFILES:.cpp=.o))
-
-
-###############################################################################
-### Main Part of Makefile                                                   ###
-###############################################################################
-all: $(PROJECT_NAME)
-
--include $(OBJ:.o=.d)
-
-.ewol:
-	@cd $(EWOL_FOLDER) ; make -s PLATFORM=$(PLATFORM) DEBUG=$(DEBUG)
-	
-.ewol-clean:
-	@cd $(EWOL_FOLDER) ; make -s PLATFORM=$(PLATFORM) clean
-
-.encadrer:
-	@echo $(CADRE_HAUT_BAS)
-	@echo $(CADRE_COTERS)
-	@echo '
           DEBUT DE COMPILATION DU PROGRAMME :'$(CADRE_COTERS)
-	@echo '
             Repertoire Sources : $(PROJECT_FILE_DIRECTORY)/'$(CADRE_COTERS)
-	@echo '
             Repertoire object  : $(OBJECT_DIRECTORY)/'$(CADRE_COTERS)
-	@echo '
             Binaire de sortie  : $(F_VIOLET)$(PROJECT_NAME) $(F_NORMALE)'$(CADRE_COTERS)
-	@echo $(CADRE_COTERS)
-	@echo $(CADRE_HAUT_BAS)
-	@mkdir -p $(addprefix $(OBJECT_DIRECTORY)/, $(LISTE_MODULES))
-
-$(info PROJECT_FILE_DIRECTORY=$(PROJECT_FILE_DIRECTORY) ; OBJECT_DIRECTORY=$(OBJECT_DIRECTORY))
-
-# build C++
-$(OBJECT_DIRECTORY)/%.o: $(PROJECT_FILE_DIRECTORY)/%.cpp $(MAKE_DEPENDENCE)
-	@echo $(F_VERT)"
          (.o)  $<"$(F_NORMALE)
-	@$(CXX)  $< -c -o $@  $(INCLUDE_DIRECTORY) $(CXXFLAGS) -MMD
-
-# build binary Release Mode
-$(PROJECT_NAME): .ewol .encadrer $(PROJECT_LIB_DEPENDENCY) $(OBJ) $(MAKE_DEPENDENCE)
-	@echo $(F_ROUGE)"
          (bin) $(PROJECT_NAME) "$(F_NORMALE)
-	@$(CXX) $(OBJ) $(EWOL_FOLDER)/libewol.a $(LDFLAGS) -o $@
-
-
-
-clean: .ewol-clean 
-	@echo $(CADRE_HAUT_BAS)
-	@echo '           CLEANING : $(F_VIOLET)$(OUTPUT_NAME)$(F_NORMALE)'$(CADRE_COTERS)
-	@echo $(CADRE_HAUT_BAS)
-	@echo $(F_VERT)"
          (rm)  $(OBJECT_DIR)"$(F_NORMALE)
-	@rm -rf $(OBJECT_DIR) 
-	@echo $(F_VERT)"
          (rm)  $(PROJECT_NAME) $(OUTPUT_NAME_DEBUG) $(OUTPUT_NAME_RELEASE)"$(F_NORMALE)
-	@rm -f $(PROJECT_NAME) $(OUTPUT_NAME_DEBUG) $(OUTPUT_NAME_RELEASE)
-	@echo $(F_VERT)"
          (rm)  doxygen/*"$(F_NORMALE)
-	@rm -rf doxygen
-	@rm -f doxygen.log
-	@echo $(F_VERT)"
          (rm)  *.bck"$(F_NORMALE)
-	@rm -f `find . -name "*.bck"`
-
-
-count:
-	wc -l Makefile `find $(FILE_DIRECTORY)/ -name "*.cpp"` `find $(PROJECT_FILE_DIRECTORY)/ -name "*.h"` 
-
-
-install: .encadrer .versionFile $(PROJECT_NAME)
-	@echo '	INSTALL : $(OUTPUT_NAME_RELEASE)=>$(PROJECT_NAME)'
-	@echo "	(stripped) $(OUTPUT_NAME_RELEASE) => $(PROJECT_NAME) "
-	@cp $(OUTPUT_NAME_RELEASE) $(PROJECT_NAME)
-	@strip -s $(PROJECT_NAME)
-	@echo "	(copy) $(PROJECT_NAME) /usr/bin/ "
-	@cp -vf $(PROJECT_NAME) /usr/bin/
-	@echo "	(data) data/* ==> /usr/share/$(PROJECT_NAME)/ "
-	@mkdir -p /usr/share/$(PROJECT_NAME)/
-	@rm -rf /usr/share/$(PROJECT_NAME)/*
-	@cp -vf assets/* /usr/share/$(PROJECT_NAME)/
-
-
-# http://alp.developpez.com/tutoriels/debian/creer-paquet/
-package: .encadrer
-	@echo 'Create Folders ...'
-	@mkdir -p package/$(PROJECT_NAME)/DEBIAN/
-	@mkdir -p package/$(PROJECT_NAME)/usr/bin/
-	@mkdir -p package/$(PROJECT_NAME)/usr/share/doc/
-	@mkdir -p package/$(PROJECT_NAME)/usr/share/edn/
-	# Create the control file
-	@echo "Package: "$(PROJECT_NAME) > package/$(PROJECT_NAME)/DEBIAN/control
-	@echo "Version: "$(VERSION_TAG_SHORT) >> package/$(PROJECT_NAME)/DEBIAN/control
-	@echo "Section: Development,Editors" >> package/$(PROJECT_NAME)/DEBIAN/control
-	@echo "Priority: optional" >>package/$(PROJECT_NAME)/DEBIAN/control
-	@echo "Architecture: all" >> package/$(PROJECT_NAME)/DEBIAN/control
-	@echo "Depends: bash" >> package/$(PROJECT_NAME)/DEBIAN/control
-	@echo "Maintainer: Mr DUPIN Edouard <yui.heero@gmail.com>" >> package/$(PROJECT_NAME)/DEBIAN/control
-	@echo "Description: Text editor for sources code with ctags management" >> package/$(PROJECT_NAME)/DEBIAN/control
-	@echo "" >> package/$(PROJECT_NAME)/DEBIAN/control
-	# Create the PostRm
-	@echo "#!/bin/bash" > package/$(PROJECT_NAME)/DEBIAN/postrm
-	@echo "rm ~/."$(PROJECT_NAME) >> package/$(PROJECT_NAME)/DEBIAN/postrm
-	@echo "" >> package/$(PROJECT_NAME)/DEBIAN/postrm
-	# Enable Execution in script
-	@chmod 755 package/$(PROJECT_NAME)/DEBIAN/post*
-	@#chmod 755 package/$(PROJECT_NAME)/DEBIAN/pre*
-	# copy licence and information : 
-	@cp README package/$(PROJECT_NAME)/usr/share/doc/README
-	@cp licence.txt package/$(PROJECT_NAME)/usr/share/doc/copyright
-	@echo "First generation in progress" >> package/$(PROJECT_NAME)/usr/share/doc/changelog
-	@cp -vf $(PROJECT_NAME) package/$(PROJECT_NAME)/usr/bin/
-	@cp -vf data/*.xml package/$(PROJECT_NAME)/usr/share/edn/
-	@cd package; dpkg-deb --build $(PROJECT_NAME)
-
-

Build/Makefile.common.mk

@@ -1,56 +0,0 @@
-##################################################################################################################
-#                                                                                                                #
-#   Fichier     :   Makefile.common                                                                              #
-#                                                                                                                #
-#   Type        :   common part of the ewol Makefile                                                             #
-#                                                                                                                #
-#   Auteur      :   Heero Yui                                                                                    #
-#                                                                                                                #
-#   Evolutions  :   Date          Auteur        Raison                                                           #
-#                2011-12-15      Heero Yui      Mise en place du système de couleur et d'encart                  #
-#                                                                                                                #
-##################################################################################################################
-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)'
-
-###############################################################################
-### Platform specificity :                                                  ###
-###############################################################################
-SUPPORTED_PLATFORM=Linux IMac IPhone IPad Android AndroidTablet
-DEFAULT_PLATFORM=Linux
-
-# default platform can be overridden
-PLATFORM?=$(DEFAULT_PLATFORM)
-
-ifeq ($(PLATFORM), Linux)
-    CXXFILES += base/guiX11.cpp
-else ifeq ($(PLATFORM), IMac)
-    CXXFILES += base/guiIMac.cpp
-else ifeq ($(PLATFORM), IPhone)
-    CXXFILES += base/guiIPhone.cpp
-else ifeq ($(PLATFORM), IPad)
-    CXXFILES += base/guiIPad.cpp
-else ifeq ($(PLATFORM), Android)
-    CXXFILES += base/guiAndroid.cpp
-else ifeq ($(PLATFORM), AndroidTablet)
-    CXXFILES += base/guiAndroidTablet.cpp
-else
-    $(error you must specify a corect platform : make PLATFORM=$(SUPPORTED_PLATFORM))
-endif
-
-
-BUILD_TIME=$(shell date)
-
-

Build/ewol.mk

@@ -1,79 +0,0 @@
-
-
-EWOL_VERSION_TAG=$(shell cd $(EWOL_FOLDER); git describe --tags)
-#$(info $(VERSION_TAG))
-
-EWOL_VERSION_TAG_SHORT=$(shell cd $(EWOL_FOLDER); git describe --tags --abbrev=0)
-#$(info $(VERSION_TAG_SHORT))
-
-###############################################################################
-### Compilation Define                                                      ###
-###############################################################################
-ifeq ("$(DEBUG)", "0")
-    EWOL_CXXFLAGS = -DETK_DEBUG_LEVEL=1
-    EWOL_CXXFLAGS+= -DEWOL_DEBUG_LEVEL=1
-    EWOL_CXXFLAGS+= -DNDEBUG
-    EWOL_CXXFLAGS+= -DEWOL_VERSION_TAG_NAME="\"$(EWOL_VERSION_TAG)-release\""
-else
-    EWOL_CXXFLAGS = -DETK_DEBUG_LEVEL=3
-    EWOL_CXXFLAGS+= -DEWOL_DEBUG_LEVEL=3
-    EWOL_CXXFLAGS+= -DEWOL_VERSION_TAG_NAME="\"$(EWOL_VERSION_TAG)-debug\""
-endif
-EWOL_CXXFLAGS+= -DVERSION_BUILD_TIME="\"$(BUILD_TIME)\""
-
-
-
-# tiny XML (extern OPEN Sources) :
-EWOL_CXXFILES +=		tinyXML/tinyxml.cpp \
-						tinyXML/tinyxmlparser.cpp \
-						tinyXML/tinyxmlerror.cpp \
-						tinyXML/tinystr.cpp
-
-# Ewol Tool Kit :
-EWOL_CXXFILES +=		etk/Debug.cpp \
-						etk/DebugInternal.cpp \
-						etk/Memory.cpp \
-						etk/String.cpp \
-						etk/Stream.cpp \
-						etk/File.cpp \
-						etk/RegExp.cpp
-
-# Ewol Sources :
-EWOL_CXXFILES +=		ewol/ewol.cpp \
-						ewol/Debug.cpp \
-						ewol/OObject.cpp \
-						ewol/OObject/2DText.cpp \
-						ewol/OObject/2DColored.cpp \
-						ewol/OObject/2DTextured.cpp \
-						ewol/Texture.cpp
-ifeq ("$(FREETYPE_CFLAGS)", "")
-    EWOL_CXXFILES +=	ewol/FontBitmap.cpp
-else
-    EWOL_CXXFILES +=	ewol/FontFreeType.cpp
-endif
-EWOL_CXXFILES +=		ewol/Widget.cpp \
-						ewol/WidgetManager.cpp \
-						ewol/Windows.cpp
-# list of widgets :
-EWOL_CXXFILES +=		ewol/widget/Button.cpp \
-						ewol/widget/CheckBox.cpp \
-						ewol/widget/Entry.cpp \
-						ewol/widget/List.cpp \
-						ewol/widget/SizerHori.cpp \
-						ewol/widget/SizerVert.cpp
-# only to test  son internal element ...
-EWOL_CXXFILES +=		ewol/widget/Test.cpp
-# theme management :
-EWOL_CXXFILES +=		ewol/themeManager.cpp \
-						ewol/theme/Theme.cpp \
-						ewol/theme/EolElement.cpp \
-						ewol/theme/EolElementFrame.cpp \
-						ewol/theme/EolColor.cpp \
-						ewol/theme/EolBase.cpp \
-						ewol/theme/EolBaseCircle.cpp \
-						ewol/theme/EolBaseCirclePart.cpp \
-						ewol/theme/EolBaseLine.cpp \
-						ewol/theme/EolBasePolygone.cpp \
-						ewol/theme/EolBaseRect.cpp \
-						ewol/theme/EolBaseTriangle.cpp
-

LICENSE

@@ -0,0 +1,373 @@
+Mozilla Public License Version 2.0
+==================================
+
+1. Definitions
+--------------
+
+1.1. "Contributor"
+    means each individual or legal entity that creates, contributes to
+    the creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+    means the combination of the Contributions of others (if any) used
+    by a Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+    means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+    means Source Code Form to which the initial Contributor has attached
+    the notice in Exhibit A, the Executable Form of such Source Code
+    Form, and Modifications of such Source Code Form, in each case
+    including portions thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+    means
+
+    (a) that the initial Contributor has attached the notice described
+        in Exhibit B to the Covered Software; or
+
+    (b) that the Covered Software was made available under the terms of
+        version 1.1 or earlier of the License, but not also under the
+        terms of a Secondary License.
+
+1.6. "Executable Form"
+    means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+    means a work that combines Covered Software with other material, in
+    a separate file or files, that is not Covered Software.
+
+1.8. "License"
+    means this document.
+
+1.9. "Licensable"
+    means having the right to grant, to the maximum extent possible,
+    whether at the time of the initial grant or subsequently, any and
+    all of the rights conveyed by this License.
+
+1.10. "Modifications"
+    means any of the following:
+
+    (a) any file in Source Code Form that results from an addition to,
+        deletion from, or modification of the contents of Covered
+        Software; or
+
+    (b) any new file in Source Code Form that contains any Covered
+        Software.
+
+1.11. "Patent Claims" of a Contributor
+    means any patent claim(s), including without limitation, method,
+    process, and apparatus claims, in any patent Licensable by such
+    Contributor that would be infringed, but for the grant of the
+    License, by the making, using, selling, offering for sale, having
+    made, import, or transfer of either its Contributions or its
+    Contributor Version.
+
+1.12. "Secondary License"
+    means either the GNU General Public License, Version 2.0, the GNU
+    Lesser General Public License, Version 2.1, the GNU Affero General
+    Public License, Version 3.0, or any later versions of those
+    licenses.
+
+1.13. "Source Code Form"
+    means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+    means an individual or a legal entity exercising rights under this
+    License. For legal entities, "You" includes any entity that
+    controls, is controlled by, or is under common control with You. For
+    purposes of this definition, "control" means (a) the power, direct
+    or indirect, to cause the direction or management of such entity,
+    whether by contract or otherwise, or (b) ownership of more than
+    fifty percent (50%) of the outstanding shares or beneficial
+    ownership of such entity.
+
+2. License Grants and Conditions
+--------------------------------
+
+2.1. Grants
+
+Each Contributor hereby grants You a world-wide, royalty-free,
+non-exclusive license:
+
+(a) under intellectual property rights (other than patent or trademark)
+    Licensable by such Contributor to use, reproduce, make available,
+    modify, display, perform, distribute, and otherwise exploit its
+    Contributions, either on an unmodified basis, with Modifications, or
+    as part of a Larger Work; and
+
+(b) under Patent Claims of such Contributor to make, use, sell, offer
+    for sale, have made, import, and otherwise transfer either its
+    Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+The licenses granted in Section 2.1 with respect to any Contribution
+become effective for each Contribution on the date the Contributor first
+distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+The licenses granted in this Section 2 are the only rights granted under
+this License. No additional rights or licenses will be implied from the
+distribution or licensing of Covered Software under this License.
+Notwithstanding Section 2.1(b) above, no patent license is granted by a
+Contributor:
+
+(a) for any code that a Contributor has removed from Covered Software;
+    or
+
+(b) for infringements caused by: (i) Your and any other third party's
+    modifications of Covered Software, or (ii) the combination of its
+    Contributions with other software (except as part of its Contributor
+    Version); or
+
+(c) under Patent Claims infringed by Covered Software in the absence of
+    its Contributions.
+
+This License does not grant any rights in the trademarks, service marks,
+or logos of any Contributor (except as may be necessary to comply with
+the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+No Contributor makes additional grants as a result of Your choice to
+distribute the Covered Software under a subsequent version of this
+License (see Section 10.2) or under the terms of a Secondary License (if
+permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+Each Contributor represents that the Contributor believes its
+Contributions are its original creation(s) or it has sufficient rights
+to grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+This License is not intended to limit any rights You have under
+applicable copyright doctrines of fair use, fair dealing, or other
+equivalents.
+
+2.7. Conditions
+
+Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
+in Section 2.1.
+
+3. Responsibilities
+-------------------
+
+3.1. Distribution of Source Form
+
+All distribution of Covered Software in Source Code Form, including any
+Modifications that You create or to which You contribute, must be under
+the terms of this License. You must inform recipients that the Source
+Code Form of the Covered Software is governed by the terms of this
+License, and how they can obtain a copy of this License. You may not
+attempt to alter or restrict the recipients' rights in the Source Code
+Form.
+
+3.2. Distribution of Executable Form
+
+If You distribute Covered Software in Executable Form then:
+
+(a) such Covered Software must also be made available in Source Code
+    Form, as described in Section 3.1, and You must inform recipients of
+    the Executable Form how they can obtain a copy of such Source Code
+    Form by reasonable means in a timely manner, at a charge no more
+    than the cost of distribution to the recipient; and
+
+(b) You may distribute such Executable Form under the terms of this
+    License, or sublicense it under different terms, provided that the
+    license for the Executable Form does not attempt to limit or alter
+    the recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+You may create and distribute a Larger Work under terms of Your choice,
+provided that You also comply with the requirements of this License for
+the Covered Software. If the Larger Work is a combination of Covered
+Software with a work governed by one or more Secondary Licenses, and the
+Covered Software is not Incompatible With Secondary Licenses, this
+License permits You to additionally distribute such Covered Software
+under the terms of such Secondary License(s), so that the recipient of
+the Larger Work may, at their option, further distribute the Covered
+Software under the terms of either this License or such Secondary
+License(s).
+
+3.4. Notices
+
+You may not remove or alter the substance of any license notices
+(including copyright notices, patent notices, disclaimers of warranty,
+or limitations of liability) contained within the Source Code Form of
+the Covered Software, except that You may alter any license notices to
+the extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+You may choose to offer, and to charge a fee for, warranty, support,
+indemnity or liability obligations to one or more recipients of Covered
+Software. However, You may do so only on Your own behalf, and not on
+behalf of any Contributor. You must make it absolutely clear that any
+such warranty, support, indemnity, or liability obligation is offered by
+You alone, and You hereby agree to indemnify every Contributor for any
+liability incurred by such Contributor as a result of warranty, support,
+indemnity or liability terms You offer. You may include additional
+disclaimers of warranty and limitations of liability specific to any
+jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+---------------------------------------------------
+
+If it is impossible for You to comply with any of the terms of this
+License with respect to some or all of the Covered Software due to
+statute, judicial order, or regulation then You must: (a) comply with
+the terms of this License to the maximum extent possible; and (b)
+describe the limitations and the code they affect. Such description must
+be placed in a text file included with all distributions of the Covered
+Software under this License. Except to the extent prohibited by statute
+or regulation, such description must be sufficiently detailed for a
+recipient of ordinary skill to be able to understand it.
+
+5. Termination
+--------------
+
+5.1. The rights granted under this License will terminate automatically
+if You fail to comply with any of its terms. However, if You become
+compliant, then the rights granted under this License from a particular
+Contributor are reinstated (a) provisionally, unless and until such
+Contributor explicitly and finally terminates Your grants, and (b) on an
+ongoing basis, if such Contributor fails to notify You of the
+non-compliance by some reasonable means prior to 60 days after You have
+come back into compliance. Moreover, Your grants from a particular
+Contributor are reinstated on an ongoing basis if such Contributor
+notifies You of the non-compliance by some reasonable means, this is the
+first time You have received notice of non-compliance with this License
+from such Contributor, and You become compliant prior to 30 days after
+Your receipt of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+infringement claim (excluding declaratory judgment actions,
+counter-claims, and cross-claims) alleging that a Contributor Version
+directly or indirectly infringes any patent, then the rights granted to
+You by any and all Contributors for the Covered Software under Section
+2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all
+end user license agreements (excluding distributors and resellers) which
+have been validly granted by You or Your distributors under this License
+prior to termination shall survive termination.
+
+************************************************************************
+*                                                                      *
+*  6. Disclaimer of Warranty                                           *
+*  -------------------------                                           *
+*                                                                      *
+*  Covered Software is provided under this License on an "as is"       *
+*  basis, without warranty of any kind, either expressed, implied, or  *
+*  statutory, including, without limitation, warranties that the       *
+*  Covered Software is free of defects, merchantable, fit for a        *
+*  particular purpose or non-infringing. The entire risk as to the     *
+*  quality and performance of the Covered Software is with You.        *
+*  Should any Covered Software prove defective in any respect, You     *
+*  (not any Contributor) assume the cost of any necessary servicing,   *
+*  repair, or correction. This disclaimer of warranty constitutes an   *
+*  essential part of this License. No use of any Covered Software is   *
+*  authorized under this License except under this disclaimer.         *
+*                                                                      *
+************************************************************************
+
+************************************************************************
+*                                                                      *
+*  7. Limitation of Liability                                          *
+*  --------------------------                                          *
+*                                                                      *
+*  Under no circumstances and under no legal theory, whether tort      *
+*  (including negligence), contract, or otherwise, shall any           *
+*  Contributor, or anyone who distributes Covered Software as          *
+*  permitted above, be liable to You for any direct, indirect,         *
+*  special, incidental, or consequential damages of any character      *
+*  including, without limitation, damages for lost profits, loss of    *
+*  goodwill, work stoppage, computer failure or malfunction, or any    *
+*  and all other commercial damages or losses, even if such party      *
+*  shall have been informed of the possibility of such damages. This   *
+*  limitation of liability shall not apply to liability for death or   *
+*  personal injury resulting from such party's negligence to the       *
+*  extent applicable law prohibits such limitation. Some               *
+*  jurisdictions do not allow the exclusion or limitation of           *
+*  incidental or consequential damages, so this exclusion and          *
+*  limitation may not apply to You.                                    *
+*                                                                      *
+************************************************************************
+
+8. Litigation
+-------------
+
+Any litigation relating to this License may be brought only in the
+courts of a jurisdiction where the defendant maintains its principal
+place of business and such litigation shall be governed by laws of that
+jurisdiction, without reference to its conflict-of-law provisions.
+Nothing in this Section shall prevent a party's ability to bring
+cross-claims or counter-claims.
+
+9. Miscellaneous
+----------------
+
+This License represents the complete agreement concerning the subject
+matter hereof. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent
+necessary to make it enforceable. Any law or regulation which provides
+that the language of a contract shall be construed against the drafter
+shall not be used to construe this License against a Contributor.
+
+10. Versions of the License
+---------------------------
+
+10.1. New Versions
+
+Mozilla Foundation is the license steward. Except as provided in Section
+10.3, no one other than the license steward has the right to modify or
+publish new versions of this License. Each version will be given a
+distinguishing version number.
+
+10.2. Effect of New Versions
+
+You may distribute the Covered Software under the terms of the version
+of the License under which You originally received the Covered Software,
+or under the terms of any subsequent version published by the license
+steward.
+
+10.3. Modified Versions
+
+If you create software not governed by this License, and you want to
+create a new license for such software, you may create and use a
+modified version of this License if you rename the license and remove
+any references to the name of the license steward (except to note that
+such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+Licenses
+
+If You choose to distribute Source Code Form that is Incompatible With
+Secondary Licenses under the terms of this version of the License, the
+notice described in Exhibit B of this License must be attached.
+
+Exhibit A - Source Code Form License Notice
+-------------------------------------------
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular
+file, then You may include the notice in a location (such as a LICENSE
+file in a relevant directory) where a recipient would be likely to look
+for such a notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - "Incompatible With Secondary Licenses" Notice
+---------------------------------------------------------
+
+  This Source Code Form is "Incompatible With Secondary Licenses", as
+  defined by the Mozilla Public License, v. 2.0.

Makefile

@@ -1,289 +0,0 @@
-##################################################################################################################
-#                                                                                                                #
-#   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 ewol                                                                                      #
-#                                                                                                                #
-##################################################################################################################
-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))
-
-PLATFORM?=Linux
-CXXFILES += base/guiX11.cpp
-
-###############################################################################
-### Compilateur base system                                                 ###
-###############################################################################
-CXX=g++
-CC=gcc
-AR=ar
-
-DEBUG:=1
-
-###############################################################################
-### Compilation Define                                                      ###
-###############################################################################
-ifeq ("$(DEBUG)", "0")
-    DEFINE = -DETK_DEBUG_LEVEL=1
-    DEFINE+= -DEWOL_DEBUG_LEVEL=1
-    DEFINE+= -DNDEBUG
-    DEFINE+= -DEWOL_VERSION_TAG_NAME="\"$(VERSION_TAG)-release\""
-else
-    DEFINE = -DETK_DEBUG_LEVEL=3
-    DEFINE+= -DEWOL_DEBUG_LEVEL=3
-    DEFINE+= -DEWOL_VERSION_TAG_NAME="\"$(VERSION_TAG)-debug\""
-endif
-DEFINE+= -DVERSION_BUILD_TIME="\"$(VERSION_BUILD_TIME)\""
-
-X11FLAGS= -lGL -lGLU
-# some X11 mode availlable : 
-# install package : libxxf86vm-dev
-X11FLAGS+= -lX11 -DEWOL_X11_MODE__XF86V -lXxf86vm
-# install package : libxrender-dev 
-#X11FLAGS+= -lX11 -DEWOL_X11_MODE__XRENDER -lXrandr
-
-
-ifeq ($(shell if `pkg-config --exists freetype2` ; then echo "yes"; else echo "no"; fi), yes)
-    FREETYPE_CFLAGS=  `pkg-config --cflags freetype2` -DEWOL_USE_FREE_TYPE
-    FREETYPE_LDFLAGS= `pkg-config --libs freetype2` -DEWOL_USE_FREE_TYPE
-else
-    FREETYPE_CFLAGS=
-    FREETYPE_LDFLAGS=
-    $(Info  libFreeType-dev is not installed)
-endif
-
-
-###############################################################################
-### Android Area                                                            ###
-###############################################################################
-ifeq ($(PLATFORM), Android)
-    PROJECT_NDK=$(realpath ../android/ndk-r7/)
-    PROJECT_SDK=$(realpath ../android/sdk-r15/)
-endif
-
-
-###############################################################################
-### Basic C flags                                                           ###
-###############################################################################
-
-# basic X11 librairy ==> show if we can une under lib ...
-CXXFLAGS=  $(X11FLAGS) $(FREETYPE_CFLAGS) -D__PLATFORM__$(PLATFORM)
-
-ifeq ("$(DEBUG)", "0")
-	CXXFLAGS+= -O2
-else
-	# Enable debug (cgdb ***)
-	CXXFLAGS+= -g -O0
-endif
-# display all flags
-CXXFLAGS+= -Wall
-# ...
-CXXFLAGS+= -D_REENTRANT
-# internal defines
-CXXFLAGS+= $(DEFINE)
-# remove warning from the convertion char*
-CXXFLAGS+= -Wno-write-strings
-
-CFLAGS=    $(CXXFLAGS) -std=c99
-
-# basic extern librairy
-LDFLAGS=  $(X11FLAGS) $(FREETYPE_LDFLAGS)
-
-# Dynamic connection of the CALLBACK of the GUI
-LDFLAGS+= -Wl,--export-dynamic
-
-###############################################################################
-### Project Name                                                            ###
-###############################################################################
-PROG_NAME=ewol
-
-###############################################################################
-### Basic Project description Files                                         ###
-###############################################################################
-FILE_DIRECTORY=Sources
-OUTPUT_NAME_RELEASE=$(PROG_NAME)_release
-OUTPUT_NAME_DEBUG=$(PROG_NAME)_debug
-OBJECT_DIR=Object_$(PLATFORM)
-
-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                                                            ###
-###############################################################################
-
-#data File of the program :
-ifeq ($(DATA_MODE), MEMORY)
-CXXFILES +=		GeneratedData.cpp
-endif
-
-
-# tiny XML (extern OPEN Sources) :
-CXXFILES +=		tinyXML/tinyxml.cpp \
-				tinyXML/tinyxmlparser.cpp \
-				tinyXML/tinyxmlerror.cpp \
-				tinyXML/tinystr.cpp
-
-# Ewol Tool Kit :
-CXXFILES +=		etk/Debug.cpp \
-				etk/DebugInternal.cpp \
-				etk/Memory.cpp \
-				etk/String.cpp \
-				etk/Stream.cpp \
-				etk/File.cpp \
-				etk/RegExp.cpp
-
-# Ewol Sources :
-CXXFILES +=		ewol/ewol.cpp \
-				ewol/Debug.cpp \
-				ewol/OObject.cpp \
-				ewol/OObject/2DText.cpp \
-				ewol/OObject/2DColored.cpp \
-				ewol/OObject/2DTextured.cpp \
-				ewol/Texture.cpp
-ifeq ("$(FREETYPE_CFLAGS)", "")
-    CXXFILES +=	ewol/FontBitmap.cpp
-else
-    CXXFILES +=	ewol/FontFreeType.cpp
-endif
-CXXFILES +=		ewol/Widget.cpp \
-				ewol/WidgetManager.cpp \
-				ewol/Windows.cpp
-# list of widgets :
-CXXFILES +=		ewol/widget/Button.cpp \
-				ewol/widget/CheckBox.cpp \
-				ewol/widget/Entry.cpp \
-				ewol/widget/List.cpp \
-				ewol/widget/SizerHori.cpp \
-				ewol/widget/SizerVert.cpp
-# only to test  son internal element ...
-CXXFILES +=		ewol/widget/Test.cpp
-# theme management :
-CXXFILES +=		ewol/themeManager.cpp \
-				ewol/theme/Theme.cpp \
-				ewol/theme/EolElement.cpp \
-				ewol/theme/EolElementFrame.cpp \
-				ewol/theme/EolColor.cpp \
-				ewol/theme/EolBase.cpp \
-				ewol/theme/EolBaseCircle.cpp \
-				ewol/theme/EolBaseCirclePart.cpp \
-				ewol/theme/EolBaseLine.cpp \
-				ewol/theme/EolBasePolygone.cpp \
-				ewol/theme/EolBaseRect.cpp \
-				ewol/theme/EolBaseTriangle.cpp
-
-
-
-# get all data file in the specific folder
-DATA_FOLDER=dataTest
-DATA_FILE=$(shell find $(DATA_FOLDER)/*)
-
-###############################################################################
-### Liste of folder where .h can be                                         ###
-###############################################################################
-LISTE_MODULES = $(sort $(dir $(CXXFILES)))
-#$(info listeModule=$(LISTE_MODULES))
-INCLUDE_DIRECTORY = $(addprefix -I$(FILE_DIRECTORY)/, $(LISTE_MODULES)) 
-# overwrite if needed the directory folder : 
-INCLUDE_DIRECTORY = -I$(FILE_DIRECTORY)/
-
-###############################################################################
-### Build Object Files List                                                 ###
-###############################################################################
-OBJ =	$(addprefix $(OBJECT_DIRECTORY)/, $(CXXFILES:.cpp=.o))
-
-
-
-###############################################################################
-### Main Part of Makefile                                                   ###
-###############################################################################
-all: build
-
--include $(OBJ:.o=.d)
-
-build : .encadrer .versionFile $(OBJ) $(MAKE_DEPENDENCE)
-	@echo $(F_ROUGE)"
          (.a) lib$(PROG_NAME).a "$(F_NORMALE)
-	@ar rcs lib$(PROG_NAME).a $(OBJ)
-
-
-.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))
-
-.versionFile:
-	@rm -f $(OBJECT_DIRECTORY)/ewol/ewol.o
-
-# build C++
-$(OBJECT_DIRECTORY)/%.o: $(FILE_DIRECTORY)/%.cpp $(MAKE_DEPENDENCE)
-	@echo $(F_VERT)"
          (.o)  $<"$(F_NORMALE)
-	@$(CXX)  $< -c -o $@  $(INCLUDE_DIRECTORY) $(CXXFLAGS) -MMD
-
-
-clean:
-	@echo $(CADRE_HAUT_BAS)
-	@echo '           CLEANING : $(F_VIOLET)$(OUTPUT_NAME)$(F_NORMALE)'$(CADRE_COTERS)
-	@echo $(CADRE_HAUT_BAS)
-	@echo $(F_VERT)"
          (rm)  $(OBJECT_DIR)"$(F_NORMALE)
-	@rm -rf $(OBJECT_DIR) 
-	@echo $(F_VERT)"
          (rm)  $(PROJECT_NAME) $(OUTPUT_NAME_DEBUG) $(OUTPUT_NAME_RELEASE)"$(F_NORMALE)
-	@rm -f $(PROG_NAME) $(OUTPUT_NAME_DEBUG) $(OUTPUT_NAME_RELEASE)
-	@echo $(F_VERT)"
          (rm)  doxygen/*"$(F_NORMALE)
-	@rm -rf doxygen
-	@rm -f doxygen.log
-	@echo $(F_VERT)"
          (rm)  *.bck"$(F_NORMALE)
-	@rm -f `find . -name "*.bck"`
-
-
-count:
-	wc -l Makefile `find $(FILE_DIRECTORY)/ -name "*.cpp"` `find $(FILE_DIRECTORY)/ -name "*.h"` 

README.md

@@ -1,41 +1,128 @@
-Edn
+Ewol
 ====
 
 `Ewol` (Edn Widget OpenGl Layer) is a FREE software.
 
-This software is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY.
+Release (master)
+----------------
+
+[![Build Status](https://travis-ci.org/atria-soft/ewol.svg?branch=master)](https://travis-ci.org/atria-soft/ewol)
+[![Coverage Status](http://atria-soft.com/ci/coverage/atria-soft/ewol.svg?branch=master)](http://atria-soft.com/ci/atria-soft/ewol)
+[![Test Status](http://atria-soft.com/ci/test/atria-soft/ewol.svg?branch=master)](http://atria-soft.com/ci/atria-soft/ewol)
+[![Warning Status](http://atria-soft.com/ci/warning/atria-soft/ewol.svg?branch=master)](http://atria-soft.com/ci/atria-soft/ewol)
+
+[![Build Status](http://atria-soft.com/ci/build/atria-soft/ewol.svg?branch=master&tag=Linux)](http://atria-soft.com/ci/atria-soft/ewol)
+[![Build Status](http://atria-soft.com/ci/build/atria-soft/ewol.svg?branch=master&tag=MacOs)](http://atria-soft.com/ci/atria-soft/ewol)
+[![Build Status](http://atria-soft.com/ci/build/atria-soft/ewol.svg?branch=master&tag=Mingw)](http://atria-soft.com/ci/atria-soft/ewol)
+
+[![Build Status](http://atria-soft.com/ci/build/atria-soft/ewol.svg?branch=master&tag=Android)](http://atria-soft.com/ci/atria-soft/ewol)
+[![Build Status](http://atria-soft.com/ci/build/atria-soft/ewol.svg?branch=master&tag=IOs)](http://atria-soft.com/ci/atria-soft/ewol)
+
+Developement (dev)
+------------------
+
+[![Build Status](https://travis-ci.org/atria-soft/ewol.svg?branch=dev)](https://travis-ci.org/atria-soft/ewol)
+[![Coverage Status](http://atria-soft.com/ci/coverage/atria-soft/ewol.svg?branch=dev)](http://atria-soft.com/ci/atria-soft/ewol)
+[![Test Status](http://atria-soft.com/ci/test/atria-soft/ewol.svg?branch=dev)](http://atria-soft.com/ci/atria-soft/ewol)
+[![Warning Status](http://atria-soft.com/ci/warning/atria-soft/ewol.svg?branch=dev)](http://atria-soft.com/ci/atria-soft/ewol)
+
+[![Build Status](http://atria-soft.com/ci/build/atria-soft/ewol.svg?branch=dev&tag=Linux)](http://atria-soft.com/ci/atria-soft/ewol)
+[![Build Status](http://atria-soft.com/ci/build/atria-soft/ewol.svg?branch=dev&tag=MacOs)](http://atria-soft.com/ci/atria-soft/ewol)
+[![Build Status](http://atria-soft.com/ci/build/atria-soft/ewol.svg?branch=dev&tag=Mingw)](http://atria-soft.com/ci/atria-soft/ewol)
+
+[![Build Status](http://atria-soft.com/ci/build/atria-soft/ewol.svg?branch=dev&tag=Android)](http://atria-soft.com/ci/atria-soft/ewol)
+[![Build Status](http://atria-soft.com/ci/build/atria-soft/ewol.svg?branch=dev&tag=IOs)](http://atria-soft.com/ci/atria-soft/ewol)
 
 Instructions
 ============
 
-download the software :
+download Build system:
+----------------------
 
-	git clone git://github.com/HeeroYui/ewol.git
-	cd edn
+	sudo pip install lutin
+	sudo pip install pillow
 
-Compile software and install :
+need google repo:
+-----------------
 
-	sudo make DEBUG=0 install
+see: http://source.android.com/source/downloading.html#installing-repo
 
-Run Software :
+	mkdir ~/.bin
+	PATH=~/.bin:$PATH
+	curl https://storage.googleapis.com/git-repo-downloads/repo > ~/.bin/repo
+	chmod a+x ~/.bin/repo
 
-	???
 
-License
-=======
+download the software:
+----------------------
 
-	You can:
-		- Redistribute the sources code and binaries.
-		- Modify the Sources code.
-		- Use a part of the sources (less than 50%) in an other software, just write somewhere "Edn is great" visible by the user (on your product or on your website with a link to my page).
-		- Redistribute the modification only if you want.
-		- Send me the bug-fix (it could be great).
-		- Pay me a beer or some other things.
-		- Print the source code on WC paper ...
-	You can NOT:
-		- Earn money with this Software (But I can).
-		- Add malware in the Sources.
-		- Do something bad with the sources.
-		- Use it to travel in the space with a toaster.
+	mkdir WORKING_DIRECTORY
+	cd WORKING_DIRECTORY
+	repo init -u git://github.com/atria-soft/manifest.git
+	repo sync -j8
+
+
+Compile software and test:
+--------------------------
+
+	lutin ewol-*
+
+Dependency packages
+===================
+
+Ubuntu Or Debian:
+
+	sudo apt-get install g++ libgl1-mesa-dev zlib1g-dev libasound2-dev
+	# Compile with Clang:
+	sudo apt-get install clang
+	# For andoid compilation (jdk 7 does not work...):
+	sudo apt-get install javacc openjdk-6-jdk
+	# Cross compile for windows:
+	sudo add-apt-repository ppa:ubuntu-toolchain-r/test
+	sudo apt-get update
+	sudo apt-get install gcc-mingw-w64
+	# On 64 bits processor for compatibility:
+	sudo apt-get install ia32-libs
+	sudo apt-get install g++-multilib libc6-dev-i386
+
+Arch-linux:
+
+	# Cross compile for windows:
+	pacman -S mingw-w64-gcc
+	
+	# Cross compile for Android:
+	in /etc/pacman.conf file uncomment:
+		[multilib]
+		Include = /etc/pacman.d/mirrorlist
+	# update the system:
+	Pacman -Syu
+	# install lib C:
+	pacman -S lib32-glibc lib32-zlib lib32-gcc-libs
+	# install open-jdk 7.0
+	pacman -S jdk7-openjdk
+	# connect adb: (and you can do a "android/sdk/platform-tools/adb shell" to enable computer key on device)
+	pacman -S android-udev
+
+
+Simple framework overview
+=========================
+
+![overview](overview.svg)
+
+License (MPL v2.0)
+==================
+
+Copyright ewol Edouard DUPIN
+
+Licensed under the Mozilla Public License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	https://www.mozilla.org/MPL/2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
 
-	I reserve the right to change this licence. If it change the version of the copy you have keep its own license

Sources/base/gui.h

@@ -1,55 +0,0 @@
-/**
- *******************************************************************************
- * @file gui.h
- * @brief Gui abstraction layer (header)
- * @author Edouard DUPIN
- * @date 20/10/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-#ifndef __GUI_ABSTRACTION_H__
-#define __GUI_ABSTRACTION_H__
-
-#include <etk/Types.h>
-#include <ewol/Windows.h>
-
-namespace guiAbstraction
-{
-	void Init(int32_t argc, char *argv[]);
-	void Run(void);
-	void Stop(void);
-	void UnInit(void);
-	void SetDisplayOnWindows(ewol::Windows * newOne);
-	void ChangeSize(int32_t w, int32_t h);
-	void ChangePos(int32_t x, int32_t y);
-	void GetAbsPos(int32_t & x, int32_t & y);
-	void StartResizeSystem(void);
-	void StartMoveSystem(void);
-	bool IsPressedInput(int32_t inputID);
-	void ForceRedrawAll(void);
-};
-
-//!< must be define in CPP by the application ...
-void APP_Init(int argc, char *argv[]);
-void APP_UnInit(void);
-
-#define NB_MAX_INPUT                  (20)
-#define SEPARATED_CLICK_TIME          (30)
-
-#endif

Sources/base/guiAndroid.cpp

@@ -1,593 +0,0 @@
-/**
- *******************************************************************************
- * @file guiAndroid.cpp
- * @brief Gui abstraction layer (Sources)
- * @author Edouard DUPIN
- * @date 20/10/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-
-#include <jni.h>
-#include <sys/time.h>
-#include <time.h>
-#include <android/log.h>
-#include <stdint.h>
-
-#include <ewol/Debug.h>
-#include <etk/String.h>
-#include <ewol/WidgetManager.h>
-#include <base/gui.h>
-#include <ewol/ewol.h>
-
-#include <importgl.h>
-#include <ewol/Texture.h>
-
-#undef __class__
-#define __class__ "AndroidJNI"
-
-
-int   gAppAlive   = 1;
-
-static int  sDemoStopped  = 0;
-static long sTimeOffset   = 0;
-static int  sTimeOffsetInit = 0;
-static long sTimeStopped  = 0;
-
-static etkFloat_t m_width = 320;
-static etkFloat_t m_height = 480;
-
-ewol::Windows* m_uniqueWindows = NULL;
-
-static int32_t times(char* tmpVar)
-{
-    struct timeval  now;
-    gettimeofday(&now, NULL);
-    return (long)(now.tv_sec*1000 + now.tv_usec/1000);
-}
-
-
-void Draw(void);
-#define OFFSET_MOVE_CLICKED             (20)
-#define OFFSET_MOVE_CLICKED_DOUBLE      (40)
-
-bool    inputIsPressed[NB_MAX_INPUT];// = {false, false, false};
-int32_t m_previousBouttonId = -1;
-int32_t m_previousDown_x = -1;
-int32_t m_previousDown_y = -1;
-int32_t m_previous_x = -1;
-int32_t m_previous_y = -1;
-int64_t m_previousTime = 0;
-bool    m_previousDouble = false;
-
-
-/* Call to initialize the graphics state */
-void EWOL_NativeInit(void)
-{
-	EWOL_INFO("Init : Start All Application");
-	gAppAlive    = 1;
-	sDemoStopped = 0;
-	sTimeOffsetInit = 0;
-	ewol::TextureOGLContext(true);
-}
-
-
-void EWOL_NativeResize(int w, int h )
-{
-	m_width = w;
-	m_height = h;
-	EWOL_INFO("Resize w=" << w << " h=" << h);
-	ewol::TextureOGLContext(false);
-	ewol::TextureOGLContext(true);
-	if (NULL != m_uniqueWindows) {
-		m_uniqueWindows->CalculateSize((etkFloat_t)m_width, (etkFloat_t)m_height);
-		m_uniqueWindows->SetOrigin(0.0, 0.0);
-	}
-}
-
-/* Call to finalize the graphics state */
-void EWOL_NativeDone(void)
-{
-	EWOL_INFO("Renderer : Close All Application");
-	ewol::TextureOGLContext(false);
-}
-
-void EWOL_NativeEventInputMotion(int pointerID, float x, float y )
-{
-	//EWOL_INFO("Event : Input Motion ID=" << pointerID << " x=" << x << " y=" << y);
-	if(0<=pointerID && pointerID < NB_MAX_INPUT ) {
-		if (true == inputIsPressed[pointerID]) {
-			if(NULL != m_uniqueWindows) {
-				//EWOL_DEBUG("ANDROID event: bt=" << pointerID+1 << " ** = \"MotionNotify\" (" << (etkFloat_t)x << "," << (etkFloat_t)y << ")");
-				m_uniqueWindows->GenEventInput(pointerID+1, ewol::EVENT_INPUT_TYPE_MOVE, (etkFloat_t)x, (etkFloat_t)y);
-			}
-		}
-	}
-}
-
-void EWOL_NativeEventInputState(int pointerID, bool isUp, float x, float y )
-{
-	if (isUp) {
-		//EWOL_INFO("Event : Input ID=" << pointerID << " [DOWN] x=" << x << " y=" << y);
-		if(0<=pointerID && pointerID < NB_MAX_INPUT ) {
-			// Send Down message
-			if (NULL != m_uniqueWindows) {
-				//EWOL_DEBUG("ANDROID bt=" << pointerID+1 << " event : **=\"ButtonPress\"        (" << (etkFloat_t)x << "," << (etkFloat_t)y << ")");
-				m_uniqueWindows->GenEventInput(pointerID+1, ewol::EVENT_INPUT_TYPE_DOWN, (etkFloat_t)x, (etkFloat_t)y);
-			}
-			// Check double or triple click event ...
-			m_previousDown_x = x;
-			m_previousDown_y = y;
-			if (m_previousBouttonId != pointerID+1) {
-				m_previousBouttonId = pointerID+1;
-				m_previous_x = -1;
-				m_previous_y = -1;
-				m_previousTime = 0;
-				m_previousDouble = false;
-			} else {
-				if(    abs(m_previous_x - x) < OFFSET_MOVE_CLICKED
-				    && abs(m_previous_y - y) < OFFSET_MOVE_CLICKED )
-				{
-					// nothink to do ... wait up ...
-				} else {
-					m_previous_x = -1;
-					m_previous_y = -1;
-					m_previousTime = 0;
-					m_previousDouble = false;
-				}
-			}
-		}
-	} else {
-		//EWOL_INFO("Event : Input ID=" << pointerID << " [UP]   x=" << x << " y=" << y);
-		if(0<=pointerID && pointerID < NB_MAX_INPUT ) {
-			// Send Down message
-			if (NULL != m_uniqueWindows) {
-				//EWOL_DEBUG("ANDROID bt=" << pointerID+1 << " event : **=\"ButtonRelease\"      (" << (etkFloat_t)x << "," << (etkFloat_t)y << ")");
-				m_uniqueWindows->GenEventInput(pointerID+1, ewol::EVENT_INPUT_TYPE_UP, (etkFloat_t)x, (etkFloat_t)y);
-			}
-			if (m_previousBouttonId != pointerID+1) {
-				m_previousDown_x = -1;
-				m_previousDown_y = -1;
-				m_previousBouttonId = 0;
-				m_previous_x = -1;
-				m_previous_y = -1;
-				m_previousTime = 0;
-				m_previousDouble = false;
-			} else {
-				int64_t currentTime = times(NULL); // return the tic in 10ms
-				//EWOL_DEBUG("time is : " << currentTime << "    "<< currentTime/100 <<"s " << (currentTime%100)*10 << "ms");
-				if (currentTime - m_previousTime >= SEPARATED_CLICK_TIME) {
-					//check if the same area click : 
-					if(    abs(m_previousDown_x - x) < OFFSET_MOVE_CLICKED
-					    && abs(m_previousDown_y - y) < OFFSET_MOVE_CLICKED )
-					{
-						// might generate an sigle event :
-						//EWOL_DEBUG("ANDROID event : ** = \"ButtonClickedSingle\" (" << (etkFloat_t)x << "," << (etkFloat_t)y << ")");
-						m_uniqueWindows->GenEventInput(pointerID+1, ewol::EVENT_INPUT_TYPE_SINGLE, (etkFloat_t)x, (etkFloat_t)y);
-						m_previous_x = m_previousDown_x;
-						m_previous_y = m_previousDown_y;
-						m_previousTime = currentTime;
-					} else {
-						// reset values ...
-						m_previousDown_x = -1;
-						m_previousDown_y = -1;
-						m_previousBouttonId = 0;
-						m_previous_x = -1;
-						m_previous_y = -1;
-						m_previousTime = 0;
-					}
-					m_previousDouble = false;
-				} else {
-					// TODO : the double ckick does not work, I need to check this later ... if needed
-					//check if the same area click : 
-					if(    abs(m_previous_x - x) < OFFSET_MOVE_CLICKED_DOUBLE
-					    && abs(m_previous_y - y) < OFFSET_MOVE_CLICKED_DOUBLE )
-					{
-						// might generate an sigle event :
-						if (false == m_previousDouble) {
-							//EWOL_DEBUG("ANDROID event : ** = \"ButtonClickedDouble\" (" << (etkFloat_t)x << "," << (etkFloat_t)y << ")");
-							m_uniqueWindows->GenEventInput(pointerID+1, ewol::EVENT_INPUT_TYPE_DOUBLE, (etkFloat_t)x, (etkFloat_t)y);
-							m_previousTime = currentTime;
-							m_previousDouble = true;
-						} else {
-							//EWOL_DEBUG("ANDROID event : ** = \"ButtonClickedTriple\" (" << (etkFloat_t)x << "," << (etkFloat_t)y << ")");
-							m_uniqueWindows->GenEventInput(pointerID+1, ewol::EVENT_INPUT_TYPE_TRIPLE, (etkFloat_t)x, (etkFloat_t)y);
-							// reset values ...
-							m_previousDown_x = -1;
-							m_previousDown_y = -1;
-							m_previousBouttonId = 0;
-							m_previous_x = -1;
-							m_previous_y = -1;
-							m_previousTime = 0;
-							m_previousDouble = false;
-						}
-					} else {
-						// reset values ...
-						m_previousDown_x = -1;
-						m_previousDown_y = -1;
-						m_previousBouttonId = 0;
-						m_previous_x = -1;
-						m_previous_y = -1;
-						m_previousTime = 0;
-						m_previousDouble = false;
-					}
-				}
-			}
-		}
-	}
-}
-
-void EWOL_NativeEventUnknow(int eventID)
-{
-	EWOL_WARNING("Event : Unknow ID=" << eventID);
-}
-
-
-void EWOL_NativeParamSetArchiveDir(int mode, const char* str)
-{
-	switch(mode)
-	{
-		case 0:
-			EWOL_WARNING("Directory APK : path=" << str);
-			etk::SetBaseFolderData(str);
-			break;
-		case 1:
-			EWOL_WARNING("Directory mode=FILE path=" << str);
-			etk::SetBaseFolderDataUser(str);
-			break;
-		case 2:
-			EWOL_WARNING("Directory mode=CACHE path=" << str);
-			etk::SetBaseFolderCache(str);
-			break;
-		case 3:
-			EWOL_WARNING("Directory mode=EXTERNAL_CACHE path=" << str);
-			break;
-		default:
-			EWOL_WARNING("Directory mode=???? path=" << str);
-			break;
-	}
-}
-
-
-static bool isAlreadyInit = false;
-
-void EWOL_NativeApplicationInit(void)
-{
-	EWOL_WARNING("Event : Init Application");
-	if (false == isAlreadyInit) {
-		ewol::Init(0, NULL);
-		APP_Init(0, NULL);
-		isAlreadyInit = true;
-	}
-}
-
-void EWOL_NativeApplicationUnInit(void)
-{
-	EWOL_WARNING("Event : UnInit application");
-	// unset all windows
-	ewol::DisplayWindows(NULL);
-	// call application to uninit
-	APP_UnInit();
-	// uninit Ewol
-	ewol::UnInit();
-}
-
-/* Call to render the next GL frame */
-void EWOL_NativeRender(void)
-{
-	long   curTime;
-
-	/* NOTE: if sDemoStopped is TRUE, then we re-render the same frame
-	 *       on each iteration.
-	 */
-	if (sDemoStopped) {
-		curTime = sTimeStopped + sTimeOffset;
-	} else {
-		curTime =times(NULL) + sTimeOffset;
-		if (sTimeOffsetInit == 0) {
-			sTimeOffsetInit = 1;
-			sTimeOffset     = -curTime;
-			curTime         = 0;
-		}
-	}
-	
-	Draw();
-}
-
-
-
-
-
-static void Setwindow(ewol::Windows* newWindows)
-{
-	m_uniqueWindows = newWindows;
-	if (NULL != m_uniqueWindows) {
-		m_uniqueWindows->CalculateSize((etkFloat_t)m_width, (etkFloat_t)m_height);
-	}
-}
-
-
-
-static etkFloat_t gTriangleVertices[] = { 0.0f, 0.0f, 200.0f, 0.0f, 0.0f, 200.0f };
-static etkFloat_t gTriangleVertices5[] = { 200.0f, 200.0f, 100.0f, 200.0f, 200.0f, 100.0f,
-                                           200.0f, 200.0f, 300.0f, 200.0f, 200.0f, 300.0f };
-
-void Draw(void)
-{
-	//EWOL_DEBUG("redraw (" << m_width << "," << m_height << ")");
-	if(NULL == m_uniqueWindows) {
-		// set the size of the open GL system
-		glViewport(0,0,m_width,m_height);
-		
-		// Clear the screen with transparency ...
-		glClearColor(0.0,0.0,0.0, 1.0);
-		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-		
-		glMatrixMode(GL_PROJECTION);
-		glLoadIdentity();
-		//glOrtho(0., width, 0., -height, 1., 20.);
-		glOrtho(-m_width/2, m_width/2, m_height/2, -m_height/2, -1, 1);
-		glMatrixMode(GL_MODELVIEW);
-		glLoadIdentity();
-		
-		//glTranslatef(0, -height/2, -5);
-		glTranslatef(-m_width/2, -m_height/2, -1.0);
-		
-		glEnable(GL_BLEND);
-		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-		//glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_DST_ALPHA);
-		//glBlendFunc(GL_SRC_ALPHA, GL_SRC_COLOR);
-		
-		glEnableClientState( GL_VERTEX_ARRAY );
-		
-		//LOGI("engine_draw_frame (%d,%d)",width,height);
-		
-		glColor4f(0.0, 1.0, 1.0, 1.0);
-		glVertexPointer(2, oglTypeFloat_t, 0, gTriangleVertices5 );
-		glDrawArrays( GL_TRIANGLES, 0, 6);
-		static int vallllll = 0;
-		static float transparency = 0.0;
-		if (vallllll <= 1) {
-			transparency +=0.025;
-			if (transparency >= 1.0) {
-				vallllll++;
-				transparency = 0.0;
-				glColor4f(1.0, 0.0, 0.0, 1.0);
-			} else {
-				glColor4f(1.0, 0.0, 0.0, transparency);
-			}
-		} else if (vallllll <= 2) {
-			transparency +=0.025;
-			if (transparency >= 1.0) {
-				vallllll++;
-				transparency = 0.0;
-				glColor4f(1.0, 1.0, 0.0, 1.0);
-			} else {
-				glColor4f(1.0, 1.0, 0.0, transparency);
-			}
-		} else if (vallllll <= 3) {
-			transparency +=0.025;
-			if (transparency >= 1.0) {
-				vallllll++;
-				transparency = 0.0;
-				glColor4f(0.0, 1.0, 0.0, 1.0);
-			} else {
-				glColor4f(0.0, 1.0, 0.0, transparency);
-			}
-		} else if (vallllll <= 4) {
-			transparency +=0.025;
-			if (transparency >= 1.0) {
-				vallllll++;
-				transparency = 0.0;
-				glColor4f(0.0, 1.0, 1.0, 1.0);
-			} else {
-				glColor4f(0.0, 1.0, 1.0, transparency);
-			}
-		} else if (vallllll <= 5) {
-			transparency +=0.025;
-			if (transparency >= 1.0) {
-				vallllll++;
-				transparency = 0.0;
-				glColor4f(0.0, 0.0, 1.0, 1.0);
-			} else {
-				glColor4f(0.0, 0.0, 1.0, transparency);
-			}
-		} else {
-			transparency +=0.025;
-			if (transparency >= 1.0) {
-				vallllll = 0;
-				transparency = 0.0;
-				glColor4f(1.0, 0.0, 1.0, 1.0);
-			} else {
-				glColor4f(1.0, 0.0, 1.0, transparency);
-			}
-		}
-		glVertexPointer(2, oglTypeFloat_t, 0, gTriangleVertices );
-		glDrawArrays( GL_TRIANGLES, 0, 3);
-		
-		glDisableClientState( GL_VERTEX_ARRAY );
-	
-		glDisable(GL_BLEND);
-	} else {
-		m_uniqueWindows->SysDraw();
-	}
-	glFlush();
-}
-
-
-
-
-#undef __class__
-#define __class__ "guiAbstraction"
-
-static bool guiAbstractionIsInit = false;
-//static guiAbstraction::X11systemInterface * myX11Access = NULL;
-
-
-void guiAbstraction::Init(int32_t argc, char *argv[])
-{
-	if (false == guiAbstractionIsInit) {
-		// set the gui is init :
-		guiAbstractionIsInit = true;
-		EWOL_INFO("INIT for X11 environement");
-		//myX11Access = new guiAbstraction::X11systemInterface();
-	} else {
-		EWOL_CRITICAL("Can not INIT X11 ==> already init before");
-	}
-}
-
-
-void guiAbstraction::Run(void)
-{
-	EWOL_INFO("Noting to run in android mode ...");
-}
-
-void guiAbstraction::Stop(void)
-{
-	if (true == guiAbstractionIsInit) {
-		//myX11Access->Stop();
-	} else {
-		EWOL_CRITICAL("Can not Stop X11 ==> not init ... ");
-	}
-}
-
-void guiAbstraction::SetDisplayOnWindows(ewol::Windows * newOne)
-{
-	if (true == guiAbstractionIsInit) {
-		Setwindow(newOne);
-	} else {
-		EWOL_CRITICAL("Can not set Windows X11 ==> not init ... ");
-	}
-}
-
-void guiAbstraction::UnInit(void)
-{
-	if (true == guiAbstractionIsInit) {
-		EWOL_INFO("UN-INIT for X11 environement");
-		//if (NULL != myX11Access) {
-		//	delete(myX11Access);
-		//}
-		guiAbstractionIsInit = false;
-	} else {
-		EWOL_CRITICAL("Can not Un-Init X11 ==> not init ... ");
-	}
-}
-
-
-void guiAbstraction::ChangeSize(int32_t w, int32_t h)
-{
-	if (true == guiAbstractionIsInit) {
-		//myX11Access->ChangeSize(w, h);
-	} else {
-		EWOL_CRITICAL("X11 ==> not init ... ");
-	}
-}
-
-void guiAbstraction::ChangePos(int32_t x, int32_t y)
-{
-	if (true == guiAbstractionIsInit) {
-		//myX11Access->ChangePos(x, y);
-	} else {
-		EWOL_CRITICAL("X11 ==> not init ... ");
-	}
-}
-
-void guiAbstraction::GetAbsPos(int32_t & x, int32_t & y)
-{
-	if (true == guiAbstractionIsInit) {
-		//myX11Access->GetAbsPos(x, y);
-	} else {
-		EWOL_CRITICAL("X11 ==> not init ... ");
-	}
-}
-
-void guiAbstraction::StartResizeSystem(void)
-{
-	if (true == guiAbstractionIsInit) {
-		//myX11Access->StartResizeSystem();
-	} else {
-		EWOL_CRITICAL("X11 ==> not init ... ");
-	}
-}
-
-void guiAbstraction::StartMoveSystem(void)
-{
-	if (true == guiAbstractionIsInit) {
-		//myX11Access->StartMoveSystem();
-	} else {
-		EWOL_CRITICAL("X11 ==> not init ... ");
-	}
-}
-
-bool guiAbstraction::IsPressedInput(int32_t inputID)
-{
-	//if (true == guiAbstractionIsInit) {
-	//	return myX11Access->IsPressedInput(inputID);
-	//} else {
-	//	EWOL_CRITICAL("X11 ==> not init ... ");
-		return false;
-	//}
-}
-
-void guiAbstraction::ForceRedrawAll(void)
-{
-	if (NULL != m_uniqueWindows) {
-		m_uniqueWindows->CalculateSize((etkFloat_t)m_width, (etkFloat_t)m_height);
-	}
-}
-
-// never had main in android ...
-/*
-int main(int argc, char *argv[])
-{
-	return -1;
-}
-*/
-
-void glOrtho(GLfloat left,
-             GLfloat right,
-             GLfloat bottom,
-             GLfloat top,
-             GLfloat nearVal,
-             GLfloat farVal)
-{
-	GLfloat myMatrix[4*4];
-	int iii;
-	for(iii=0; iii<4*4 ; iii++) {
-		myMatrix[iii] = 0;
-	}
-	myMatrix[0] = 2.0 / (right - left);
-	myMatrix[5] = 2.0 / (top - bottom);
-	myMatrix[10] = -2.0 / (farVal - nearVal);
-#if 1
-	myMatrix[3]  = -1*(right + left) / (right - left);
-	myMatrix[7]  = -1*(top + bottom) / (top - bottom);
-	myMatrix[11] = -1*(farVal + nearVal) / (farVal - nearVal);
-#else
-	// test if matrix is not corectly instanciate ...
-	myMatrix[12]  = -1*(right + left) / (right - left);
-	myMatrix[13]  = -1*(top + bottom) / (top - bottom);
-	myMatrix[14] = -1*(farVal + nearVal) / (farVal - nearVal);
-#endif
-	myMatrix[15] = 1;
-
-	glLoadMatrixf(myMatrix);
-
-
-}

Sources/base/guiDoubleBuffer.cpp

@@ -1,46 +0,0 @@
-/**
- *******************************************************************************
- * @file guiDoubleBuffer.cpp
- * @brief Gui abstraction layer (Sources)
- * @author Edouard DUPIN
- * @date 20/10/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-#include <ewol/Debug.h>
-#include <base/guiDoubleBuffer.h>
-
-#undef __class__
-#define __class__ "guiAbstraction"
-
-void guiAbstraction::Init(int32_t argc, char *argv[])
-{
-	EWOL_INFO("INIT for DoubleBuffer environement");
-}
-
-void guiAbstraction::Run(void)
-{
-	EWOL_INFO("Start Running");
-	EWOL_INFO("Stop Running");
-}
-
-void guiAbstraction::UnInit(void)
-{
-	EWOL_INFO("UN-INIT for DoubleBuffer environement");
-}

Sources/base/guiIPhone.cpp

@@ -1,46 +0,0 @@
-/**
- *******************************************************************************
- * @file guiIPhone.cpp
- * @brief Gui abstraction layer (Sources)
- * @author Edouard DUPIN
- * @date 20/10/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-#include <ewol/Debug.h>
-#include <base/guiIPhone.h>
-
-#undef __class__
-#define __class__ "guiAbstraction"
-
-void guiAbstraction::Init(int32_t argc, char *argv[])
-{
-	EWOL_INFO("INIT for IPhone environement");
-}
-
-void guiAbstraction::Run(void)
-{
-	EWOL_INFO("Start Running");
-	EWOL_INFO("Stop Running");
-}
-
-void guiAbstraction::UnInit(void)
-{
-	EWOL_INFO("UN-INIT for IPhone environement");
-}

Sources/base/guiX11.cpp

@@ -1,932 +0,0 @@
-/**
- *******************************************************************************
- * @file guiX11.cpp
- * @brief Gui abstraction layer (Sources)
- * @author Edouard DUPIN
- * @date 20/10/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-#include <ewol/Debug.h>
-#include <etk/String.h>
-#include <ewol/WidgetManager.h>
-#include <base/gui.h>
-
-#include <ewol/Texture.h>
-
-#include <unistd.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <GL/gl.h>
-#include <GL/glu.h>
-#include <GL/glut.h>
-#include <GL/glx.h>
-#include <X11/Xatom.h>
-#if defined(EWOL_X11_MODE__XF86V)
-#	include <X11/extensions/xf86vmode.h>
-#elif defined(EWOL_X11_MODE__XRENDER)
-#	include <X11/extensions/Xrender.h>
-#else
-#	error you might define an EWOL_X11_MODE in EWOL_X11_XF86V / EWOL_X11_XRENDER
-#endif
-
-#include <sys/times.h>
-
-
-#undef __class__
-#define __class__	"guiAbstraction"
-
-#if defined(EWOL_X11_MODE__XF86V)
-// attributes for a single buffered visual in RGBA format with at least 4 bits per color and a 16 bit depth buffer
-static int attrListSgl[] = {
-	GLX_RGBA,
-	GLX_RED_SIZE, 4,
-	GLX_GREEN_SIZE, 4,
-	GLX_BLUE_SIZE, 4,
-	GLX_DEPTH_SIZE, 16,
-	None
-};
-
-// attributes for a double buffered visual in RGBA format with at least 4 bits per color and a 16 bit depth buffer
-static int attrListDbl[] = {
-	GLX_RGBA,
-	GLX_DOUBLEBUFFER,
-	GLX_RED_SIZE, 4,
-	GLX_GREEN_SIZE, 4,
-	GLX_BLUE_SIZE, 4,
-	GLX_DEPTH_SIZE, 16,
-	None
-};
-#elif defined(EWOL_X11_MODE__XRENDER)
-static int VisualData[] = {
-	GLX_RENDER_TYPE, GLX_RGBA_BIT,
-	GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
-	GLX_DOUBLEBUFFER, True,
-	GLX_RED_SIZE, 1,
-	GLX_GREEN_SIZE, 1,
-	GLX_BLUE_SIZE, 1,
-	GLX_ALPHA_SIZE, 1,
-	GLX_DEPTH_SIZE, 1,
-	None
-};
-#endif
-
-
-namespace guiAbstraction {
-	extern "C" {
-		typedef struct Hints
-		{
-			unsigned long   flags;
-			unsigned long   functions;
-			unsigned long   decorations;
-			long            inputMode;
-			unsigned long   status;
-		} Hints;
-	}
-	class X11systemInterface
-	{
-		private:
-			// for double and triple click selection, we need to save the previous click up and down position , and the previous time ...
-			int32_t m_previousBouttonId;
-			int32_t m_previousDown_x;
-			int32_t m_previousDown_y;
-			int32_t m_previous_x;
-			int32_t m_previous_y;
-			int64_t m_previousTime;
-			bool    m_previousDouble;
-		private:
-			Atom           m_delAtom;
-			Display *      m_display;
-			Window         WindowHandle;
-			#if defined(EWOL_X11_MODE__XRENDER)
-			GLXFBConfig    m_fbConfig;
-			Window         m_GLXWindowHandle;
-			#endif
-			int32_t        m_width;
-			int32_t        m_height;
-			int32_t        m_originX;
-			int32_t        m_originY;
-			int32_t        m_cursorEventX;
-			int32_t        m_cursorEventY;
-			XVisualInfo *  m_visual;
-			bool           m_doubleBuffered;
-			bool           m_run;
-			ewol::Windows* m_uniqueWindows;
-			
-			bool CreateX11Context(void)
-			{
-				int x,y, attr_mask;
-				XSizeHints hints;
-				XWMHints *StartupState;
-				XTextProperty textprop;
-				XSetWindowAttributes attr;
-				static char *title = (char*)"APPLICATION Title ... (todo)";
-				
-				#if defined(EWOL_X11_MODE__XF86V)
-					EWOL_INFO("X11 Mode XF86 Video");
-				#elif defined(EWOL_X11_MODE__XRENDER)
-					EWOL_INFO("X11 Mode XRendrer Video");
-				#endif
-				
-				// Connect to the X server
-				m_display = XOpenDisplay(NULL);
-				if(NULL == m_display) {
-					EWOL_CRITICAL("Could not open display X.");
-					exit(-1);
-				} else {
-					EWOL_INFO("Display opened.");
-				}
-				int Xscreen = DefaultScreen(m_display);
-				#if defined(EWOL_X11_MODE__XF86V)
-					{
-						int32_t vmMajor, vmMinor;
-						XF86VidModeQueryVersion(m_display, &vmMajor, &vmMinor);
-						EWOL_INFO("XF86 VideoMode extension version " << vmMajor << "." << vmMinor);
-					}
-					// get an appropriate visual
-					m_visual = glXChooseVisual(m_display, Xscreen, attrListDbl);
-					if (NULL == m_visual) {
-						m_visual = glXChooseVisual(m_display, Xscreen, attrListSgl);
-						m_doubleBuffered = false;
-						EWOL_INFO("XF86 singlebuffered rendering will be used, no doublebuffering available");
-					} else {
-						m_doubleBuffered = true;
-						EWOL_INFO("XF86 doublebuffered rendering available");
-					}
-				#elif defined(EWOL_X11_MODE__XRENDER)
-					int numfbconfigs;
-					m_doubleBuffered = true;
-					GLXFBConfig *fbconfigs = glXChooseFBConfig(m_display, Xscreen, VisualData, &numfbconfigs);
-					EWOL_DEBUG("get glx format config =" << numfbconfigs);
-					for(int i = 0; i<numfbconfigs; i++) {
-						m_visual = glXGetVisualFromFBConfig(m_display, fbconfigs[i]);
-						if(!m_visual) {
-							continue;
-						}
-						XRenderPictFormat * pictFormat = XRenderFindVisualFormat(m_display, m_visual->visual);
-						if(!pictFormat) {
-							continue;
-						}
-						if(pictFormat->direct.alphaMask > 0) {
-							m_fbConfig = fbconfigs[i];
-							EWOL_DEBUG("SELECT fbconfig id=" << i);
-							break;
-						}
-					}
-				#endif
-				{
-					int32_t glxMajor, glxMinor;
-					glXQueryVersion(m_display, &glxMajor, &glxMinor);
-					EWOL_INFO("GLX-Version " << glxMajor << "." << glxMinor);
-				}
-				// Create a colormap - only needed on some X clients, eg. IRIX
-				Window Xroot = RootWindow(m_display, Xscreen);
-				attr.colormap = XCreateColormap(m_display, Xroot, m_visual->visual, AllocNone);
-				
-				attr.border_pixel = 0;
-				attr.event_mask =   StructureNotifyMask
-				                  | SubstructureNotifyMask
-				                  | EnterWindowMask
-				                  | LeaveWindowMask
-				                  | ExposureMask
-				                  | ButtonPressMask
-				                  | ButtonReleaseMask
-				                  | OwnerGrabButtonMask
-				                  | KeyPressMask
-				                  | KeyReleaseMask
-				                  | PointerMotionMask
-				                  | FocusChangeMask
-				                  | SubstructureRedirectMask;
-				
-				// set no background at the gui
-				attr.background_pixmap = None;
-				
-				// select internal attribute
-				attr_mask = CWBackPixmap | CWColormap | CWBorderPixel | CWEventMask;
-				// Create the window
-				m_width = DisplayWidth(m_display, DefaultScreen(m_display))/2;
-				m_height = DisplayHeight(m_display, DefaultScreen(m_display))/2;
-				x=m_width/2;
-				y=m_height/4;
-				
-				// Real create of the window
-				WindowHandle = XCreateWindow(m_display,
-				                             Xroot,
-				                             x, y, m_width, m_height,
-				                             1,
-				                             m_visual->depth,
-				                             InputOutput,
-				                             m_visual->visual,
-				                             attr_mask, &attr);
-				
-				if( !WindowHandle ) {
-					EWOL_CRITICAL("Couldn't create the window");
-					exit(-1);
-				}
-				
-				/* Configure it...  (ok, ok, this next bit isn't "minimal") */
-				textprop.value = (unsigned char*)title;
-				textprop.encoding = XA_STRING;
-				textprop.format = 8;
-				textprop.nitems = strlen(title);
-				
-				hints.x = x;
-				hints.y = y;
-				hints.width = m_width;
-				hints.height = m_height;
-				hints.flags = USPosition|USSize;
-				
-				StartupState = XAllocWMHints();
-				StartupState->initial_state = NormalState;
-				StartupState->flags = StateHint;
-				
-				XSetWMProperties(m_display, WindowHandle,&textprop, &textprop,/* Window title/icon title*/
-					NULL, 0,/* Argv[], argc for program*/
-					&hints, /* Start position/size*/
-					StartupState,/* Iconised/not flag   */
-					NULL);
-				
-				XFree(StartupState);
-				
-				/* Open it, wait for it to appear */
-				XMapWindow(m_display, WindowHandle);
-				//XIfEvent(m_display, &event, WaitForMapNotify, (char*)&WindowHandle);
-				
-				// Set the kill atom so we get a message when the user tries to close the window
-				if ((m_delAtom = XInternAtom(m_display, "WM_DELETE_WINDOW", 0)) != None) {
-					XSetWMProtocols(m_display, WindowHandle, &m_delAtom, 1);
-				}
-				
-				ChangeSize(400, 300);
-				
-				return true;
-			}
-			
-			void RemoveDecoration(void)
-			{
-				Hints hints;
-				Atom property;
-				hints.flags = 2;// Specify that we're changing the window decorations.
-				hints.decorations = 0;// 0 (false) means that window decorations should go bye-bye
-				property = XInternAtom(m_display, "_MOTIF_WM_HINTS", true);
-				if (0 != property) {
-					XChangeProperty(m_display,WindowHandle,property,property,32,PropModeReplace,(unsigned char *)&hints,5);
-					XMapWindow(m_display, WindowHandle);
-				} else {
-					EWOL_ERROR("Can not get the property for the rmoving decoration of the X11 system ....");
-				}
-			}
-			
-			void AddDecoration(void)
-			{
-				Hints hints;
-				Atom property;
-				hints.flags = 2;// Specify that we're changing the window decorations.
-				hints.decorations = 1;// 1 (true) means that window decorations should enable
-				property = XInternAtom(m_display, "_MOTIF_WM_HINTS", true);
-				if (0 != property) {
-					XChangeProperty(m_display,WindowHandle,property,property,32,PropModeReplace,(unsigned char *)&hints,5);
-					XMapWindow(m_display, WindowHandle);
-				} else {
-					EWOL_ERROR("Can not get the property for the rmoving decoration of the X11 system ....");
-				}
-			}
-			
-			bool CreateOGlContext(void)
-			{
-				#if defined(EWOL_X11_MODE__XRENDER)
-					/* See if we can do OpenGL on this visual */
-					int dummy;
-					if (!glXQueryExtension(m_display, &dummy, &dummy)) {
-						EWOL_CRITICAL("OpenGL not supported by X server");
-						exit(-1);
-					}
-					
-					/* Create the OpenGL rendering context */
-					GLXContext RenderContext = glXCreateNewContext(m_display, m_fbConfig, GLX_RGBA_TYPE, 0, GL_TRUE);
-					if (!RenderContext) {
-						EWOL_CRITICAL("Failed to create a GL context");
-						exit(-1);
-					}
-					m_GLXWindowHandle = glXCreateWindow(m_display, m_fbConfig, WindowHandle, NULL);
-					/* Make it current */
-					if (!glXMakeContextCurrent(m_display, m_GLXWindowHandle, m_GLXWindowHandle, RenderContext)) {
-						EWOL_CRITICAL("glXMakeCurrent failed for window");
-						exit(-1);
-					}
-				#elif defined(EWOL_X11_MODE__XF86V)
-					/* create a GLX context */
-					GLXContext RenderContext = glXCreateContext(m_display, m_visual, 0, GL_TRUE);
-					/* connect the glx-context to the window */
-					glXMakeCurrent(m_display, WindowHandle, RenderContext);
-					if (glXIsDirect(m_display, RenderContext)) {
-						EWOL_INFO("XF86 DRI enabled\n");
-					} else {
-						EWOL_INFO("XF86 DRI NOT available\n");
-					}
-				#endif
-				//ewol::TextureOGLContext(true);
-				return true;
-			}
-			
-			void Draw(void)
-			{
-				// TODO : set this otherwise
-				ewol::TextureOGLContext(true);
-				//EWOL_DEBUG("redraw (" << m_width << "," << m_height << ")");
-				if(NULL == m_uniqueWindows) {
-					//EWOL_DEBUG("Has No Windows set...");
-					
-					// set the size of the open GL system
-					glViewport(0,0,m_width,m_height);
-					
-					// Clear the screen with transparency ...
-					glClearColor(0.750, 0.750, 0.750, 0.5);
-					glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-					
-					glMatrixMode(GL_PROJECTION);
-					glLoadIdentity();
-					glOrtho(0., (etkFloat_t)m_width, 0., (etkFloat_t)m_height, 1., 20.);
-					
-					glMatrixMode(GL_MODELVIEW);
-					glLoadIdentity();
-					glTranslatef(0, 0, -5);
-					
-					glBegin(GL_QUADS);
-						glColor3f(1., 0., 0.); glVertex3f( .25*(etkFloat_t)m_width, .25*(etkFloat_t)m_height, 0.);
-						glColor3f(0., 1., 0.); glVertex3f( .75*(etkFloat_t)m_width, .25*(etkFloat_t)m_height, 0.);
-						glColor3f(0., 0., 1.); glVertex3f( .75*(etkFloat_t)m_width, .75*(etkFloat_t)m_height, 0.);
-						glColor3f(1., 1., 0.); glVertex3f( .25*(etkFloat_t)m_width, .75*(etkFloat_t)m_height, 0.);
-					glEnd();
-				} else {
-					m_uniqueWindows->SysDraw();
-				}
-				// swap the buffers if we have doublebuffered
-				#if defined(EWOL_X11_MODE__XRENDER)
-					glXSwapBuffers(m_display, m_GLXWindowHandle);
-				#elif defined(EWOL_X11_MODE__XF86V)
-					glFlush();
-					if (m_doubleBuffered) {
-						glXSwapBuffers(m_display, WindowHandle);
-					}
-				#endif
-			}
-		
-		public:
-			X11systemInterface(void)
-			{
-				m_visual = NULL;
-				m_previousBouttonId = 0;
-				m_previousDown_x = -1;
-				m_previousDown_y = -1;
-				m_previous_x = -1;
-				m_previous_y = -1;
-				m_previousTime = 0;
-				m_previousDouble = false;
-				m_resizeMode=false;
-				m_moveMode=false;
-				m_originX = 0;
-				m_originY = 0;
-				m_cursorEventX = 0;
-				m_cursorEventY = 0;
-				for (int32_t iii=0; iii<NB_MAX_INPUT; iii++) {
-					inputIsPressed[iii] = false;
-				}
-				CreateX11Context();
-				CreateOGlContext();
-				m_run = true;
-			}
-			
-			~X11systemInterface(void)
-			{
-				Stop();
-			}
-			
-			void Setwindow(ewol::Windows* newWindows)
-			{
-				m_uniqueWindows = newWindows;
-				if (NULL != m_uniqueWindows) {
-					m_uniqueWindows->CalculateSize((etkFloat_t)m_width, (etkFloat_t)m_height);
-				}
-			}
-			
-			void Run(void)
-			{
-				// main cycle
-				while(true == m_run) {
-					XEvent event;
-					// main X boucle :
-					while (XPending(m_display)) {
-						XNextEvent(m_display, &event);
-						
-						switch (event.type)
-						{
-							case ClientMessage:
-								{
-									Atom atom = XInternAtom(m_display, "WM_DELETE_WINDOW", false);
-									if((int64_t)atom == (int64_t)event.xclient.data.l[0]) {
-										if (NULL != m_uniqueWindows) {
-											m_uniqueWindows->SysOnKill();
-										}
-										Stop();
-									}
-								}
-								break;
-							case ConfigureNotify:
-								m_width  = event.xconfigure.width;
-								m_height = event.xconfigure.height;
-								m_originX = event.xconfigure.x;
-								m_originY = event.xconfigure.y;
-								break;
-							case ButtonPress:
-								m_cursorEventX = event.xbutton.x;
-								m_cursorEventY = event.xbutton.y;
-								if (event.xbutton.button < NB_MAX_INPUT) {
-									inputIsPressed[event.xbutton.button] = true;
-								}
-								break;
-							case ButtonRelease:
-								m_cursorEventX = event.xbutton.x;
-								m_cursorEventY = event.xbutton.y;
-								if (event.xbutton.button < NB_MAX_INPUT) {
-									inputIsPressed[event.xbutton.button] = false;
-								}
-								break;
-							case EnterNotify:
-							case LeaveNotify:
-								m_cursorEventX = event.xcrossing.x;
-								m_cursorEventY = event.xcrossing.y;
-								break;
-							case MotionNotify:
-								m_cursorEventX = event.xmotion.x;
-								m_cursorEventY = event.xmotion.y;
-								break;
-						}
-						// parse event
-						if(NULL == m_uniqueWindows) {
-							EWOL_DEBUG("Has No Windows set...");
-						} else {
-							switch (event.type)
-							{
-								case ConfigureNotify:
-									EWOL_VERBOSE("X11 event : " << event.type << " = \"ConfigureNotify\" Origin(" << event.xconfigure.x << "," << event.xconfigure.y << ") Size(" << event.xconfigure.width << "," << event.xconfigure.height << ")");
-									m_uniqueWindows->CalculateSize((etkFloat_t)event.xconfigure.width, (etkFloat_t)event.xconfigure.height);
-									m_uniqueWindows->SetOrigin(event.xconfigure.x, event.xconfigure.y);
-									break;
-								case Expose:
-									EWOL_VERBOSE("X11 event : " << event.type << " = \"Expose\"");
-									m_uniqueWindows->SysOnExpose();
-									break;
-								case ButtonPress:
-									{
-										m_moveMode = false;
-										m_resizeMode = false;
-										int32_t btId = event.xbutton.button;
-										EWOL_VERBOSE("X11 bt=" << btId << " event : " << event.type << "=\"ButtonPress\" (" << (etkFloat_t)event.xbutton.x << "," << (etkFloat_t)event.xbutton.y << ")");
-										// Send Down message
-										m_uniqueWindows->GenEventInput(btId, ewol::EVENT_INPUT_TYPE_DOWN, (etkFloat_t)event.xbutton.x, (etkFloat_t)event.xbutton.y);
-										// Check double or triple click event ...
-										m_previousDown_x = event.xbutton.x;
-										m_previousDown_y = event.xbutton.y;
-										if (m_previousBouttonId != btId) {
-											m_previousBouttonId = btId;
-											m_previous_x = -1;
-											m_previous_y = -1;
-											m_previousTime = 0;
-											m_previousDouble = false;
-										} else {
-											if(    abs(m_previous_x - event.xbutton.x) < 5
-											    && abs(m_previous_y - event.xbutton.y) < 5 )
-											{
-												// nothink to do ... wait up ...
-											} else {
-												m_previous_x = -1;
-												m_previous_y = -1;
-												m_previousTime = 0;
-												m_previousDouble = false;
-											}
-										}
-									}
-									break;
-								case ButtonRelease:
-									{
-										m_moveMode = false;
-										m_resizeMode = false;
-										int32_t btId = event.xbutton.button;
-										EWOL_VERBOSE("X11 bt=" << btId << " event : " << event.type << "=\"ButtonRelease\" (" << (etkFloat_t)event.xbutton.x << "," << (etkFloat_t)event.xbutton.y << ")");
-										// send Up event ...
-										m_uniqueWindows->GenEventInput(btId, ewol::EVENT_INPUT_TYPE_UP, (etkFloat_t)event.xbutton.x, (etkFloat_t)event.xbutton.y);
-										
-										if (m_previousBouttonId != btId) {
-											m_previousDown_x = -1;
-											m_previousDown_y = -1;
-											m_previousBouttonId = 0;
-											m_previous_x = -1;
-											m_previous_y = -1;
-											m_previousTime = 0;
-											m_previousDouble = false;
-										} else {
-											int64_t currentTime = times(NULL); // return the tic in 10ms
-											//EWOL_DEBUG("time is : " << currentTime << "    "<< currentTime/100 <<"s " << (currentTime%100)*10 << "ms");
-											if (currentTime - m_previousTime >= SEPARATED_CLICK_TIME) {
-												//check if the same area click : 
-												if(    abs(m_previousDown_x - event.xbutton.x) < 5
-												    && abs(m_previousDown_y - event.xbutton.y) < 5 )
-												{
-													// might generate an sigle event :
-													//EWOL_DEBUG("X11 event : " << event.type << " = \"ButtonClickedSingle\" (" << (etkFloat_t)event.xbutton.x << "," << (etkFloat_t)event.xbutton.y << ")");
-													m_uniqueWindows->GenEventInput(btId, ewol::EVENT_INPUT_TYPE_SINGLE, (etkFloat_t)event.xbutton.x, (etkFloat_t)event.xbutton.y);
-													m_previous_x = m_previousDown_x;
-													m_previous_y = m_previousDown_y;
-													m_previousTime = currentTime;
-												} else {
-													// reset values ...
-													m_previousDown_x = -1;
-													m_previousDown_y = -1;
-													m_previousBouttonId = 0;
-													m_previous_x = -1;
-													m_previous_y = -1;
-													m_previousTime = 0;
-												}
-												m_previousDouble = false;
-											} else {
-												//check if the same area click : 
-												if(    abs(m_previous_x - event.xbutton.x) < 5
-												    && abs(m_previous_y - event.xbutton.y) < 5 )
-												{
-													// might generate an sigle event :
-													if (false == m_previousDouble) {
-														//EWOL_DEBUG("X11 event : " << event.type << " = \"ButtonClickedDouble\" (" << (etkFloat_t)event.xbutton.x << "," << (etkFloat_t)event.xbutton.y << ")");
-														m_uniqueWindows->GenEventInput(btId, ewol::EVENT_INPUT_TYPE_DOUBLE, (etkFloat_t)event.xbutton.x, (etkFloat_t)event.xbutton.y);
-														m_previousTime = currentTime;
-														m_previousDouble = true;
-													} else {
-														//EWOL_DEBUG("X11 event : " << event.type << " = \"ButtonClickedTriple\" (" << (etkFloat_t)event.xbutton.x << "," << (etkFloat_t)event.xbutton.y << ")");
-														m_uniqueWindows->GenEventInput(btId, ewol::EVENT_INPUT_TYPE_TRIPLE, (etkFloat_t)event.xbutton.x, (etkFloat_t)event.xbutton.y);
-														// reset values ...
-														m_previousDown_x = -1;
-														m_previousDown_y = -1;
-														m_previousBouttonId = 0;
-														m_previous_x = -1;
-														m_previous_y = -1;
-														m_previousTime = 0;
-														m_previousDouble = false;
-													}
-												} else {
-													// reset values ...
-													m_previousDown_x = -1;
-													m_previousDown_y = -1;
-													m_previousBouttonId = 0;
-													m_previous_x = -1;
-													m_previous_y = -1;
-													m_previousTime = 0;
-													m_previousDouble = false;
-												}
-											}
-											
-											//int64_t currentTime = 
-										}
-									}
-									break;
-								case EnterNotify:
-									m_resizeMode = false;
-									m_moveMode = false;
-									//EWOL_DEBUG("X11 event : " << event.type << " = \"EnterNotify\" (" << (etkFloat_t)event.xcrossing.x << "," << (etkFloat_t)event.xcrossing.y << ")");
-									m_uniqueWindows->GenEventInput(0, ewol::EVENT_INPUT_TYPE_ENTER, (etkFloat_t)event.xcrossing.x, (etkFloat_t)event.xcrossing.y);
-									break;
-								case MotionNotify:
-									if (true == m_resizeMode) {
-										if (m_cursorEventX >=50 && m_cursorEventY >=50) {
-											ChangeSize(m_cursorEventX, m_cursorEventY);
-										}
-									} else if (true == m_moveMode) {
-										int32_t tmpX, tmpY;
-										this->GetAbsPos(tmpX, tmpY);
-										//EWOL_DEBUG("Current absolute position : " << tmpX << "x" << tmpY);
-										int32_t newPosX = (m_startX - m_screenOffsetX) - (m_startX - tmpX);
-										int32_t newPosY = (m_startY - m_screenOffsetY) - (m_startY - tmpY);
-										//EWOL_DEBUG("Change POS : (" << (m_startY - m_screenOffsetX) << "," << (m_startY - m_screenOffsetY) << ") ==> (" << newPosX << "," << newPosY << ")");
-										this->ChangePos(newPosX, newPosY);
-									} else {
-										// For compatibility of the Android system : 
-										bool findOne = false;
-										for (int32_t iii=0; iii<NB_MAX_INPUT ; iii++) {
-											if (true == inputIsPressed[iii]) {
-												EWOL_VERBOSE("X11 event: bt=" << iii+1 << " " << event.type << " = \"MotionNotify\" (" << (etkFloat_t)event.xmotion.x << "," << (etkFloat_t)event.xmotion.y << ")");
-												m_uniqueWindows->GenEventInput(iii+1, ewol::EVENT_INPUT_TYPE_MOVE, (etkFloat_t)event.xmotion.x, (etkFloat_t)event.xmotion.y);
-												findOne = true;
-											}
-										}
-										if (false == findOne) {
-											EWOL_VERBOSE("X11 event: bt=" << 0 << " " << event.type << " = \"MotionNotify\" (" << (etkFloat_t)event.xmotion.x << "," << (etkFloat_t)event.xmotion.y << ")");
-											m_uniqueWindows->GenEventInput(0, ewol::EVENT_INPUT_TYPE_MOVE, (etkFloat_t)event.xmotion.x, (etkFloat_t)event.xmotion.y);
-										}
-									}
-									break;
-								case LeaveNotify:
-									m_resizeMode = false;
-									m_moveMode = false;
-									//EWOL_DEBUG("X11 event : " << event.type << " = \"LeaveNotify\" (" << (etkFloat_t)event.xcrossing.x << "," << (etkFloat_t)event.xcrossing.y << ")");
-									m_uniqueWindows->GenEventInput(0, ewol::EVENT_INPUT_TYPE_LEAVE, (etkFloat_t)event.xcrossing.x, (etkFloat_t)event.xcrossing.y);
-									break;
-								case FocusIn:
-									m_resizeMode = false;
-									m_moveMode = false;
-									EWOL_VERBOSE("X11 event : " << event.type << " = \"FocusIn\"");
-									m_uniqueWindows->SetFocus();
-									break;
-								case FocusOut:
-									m_resizeMode = false;
-									m_moveMode = false;
-									EWOL_VERBOSE("X11 event : " << event.type << " = \"FocusOut\"");
-									m_uniqueWindows->RmFocus();
-									break;
-								case KeyPress:
-								case KeyRelease:
-									//EWOL_DEBUG("X11 event : " << event.type << " = \"KeyPress/KeyRelease\" ");
-									{
-										char buf[11];
-										KeySym keysym;
-										XComposeStatus status;
-										int count = XLookupString(&event.xkey, buf, 10, &keysym, &status);
-										buf[count] = '\0';
-										// Get the current Focused Widget :
-										ewol::Widget * tmpWidget = ewol::widgetManager::FocusGet();
-										if (NULL != tmpWidget) {
-											if(event.type == KeyPress) {
-												// TODO : set the char here...
-												EWOL_DEBUG("X11 PRESSED : \"" << buf << "\" size=" << count);
-												tmpWidget->OnEventKb(ewol::EVENT_KB_TYPE_DOWN, buf);
-											} else {
-												// TODO : set the char here...
-												EWOL_DEBUG("X11 Release : \"" << buf << "\" size=" << count);
-												tmpWidget->OnEventKb(ewol::EVENT_KB_TYPE_UP, buf);
-											}
-										}
-										break;
-									}
-								//case DestroyNotify:
-								//	break;
-								case MapNotify:
-									EWOL_VERBOSE("X11 event : " << event.type << " = \"MapNotify\"");
-									m_uniqueWindows->SysOnShow();
-									break;
-								case UnmapNotify:
-									EWOL_VERBOSE("X11 event : " << event.type << " = \"UnmapNotify\"");
-									m_uniqueWindows->SysOnHide();
-									break;
-								default:
-									EWOL_DEBUG("X11 event : " << event.type << " = \"???\"");
-							}
-						}
-					}
-					Draw();
-					usleep( 100000 );
-				}
-			};
-			
-			void Stop(void)
-			{
-				m_run = false;
-			};
-			
-			void ChangeSize(int32_t w, int32_t h)
-			{
-				XResizeWindow(m_display, WindowHandle, w, h);
-			};
-			
-			void ChangePos(int32_t x, int32_t y)
-			{
-				XMoveWindow(m_display, WindowHandle, x, y);
-			};
-			
-			void GetAbsPos(int32_t & x, int32_t & y)
-			{
-				int tmp;
-				unsigned int tmp2;
-				Window fromroot, tmpwin;
-				XQueryPointer(m_display, WindowHandle, &fromroot, &tmpwin, &x, &y, &tmp, &tmp, &tmp2);
-			};
-			
-			void ForceRedrawAll(void)
-			{
-				if (NULL != m_uniqueWindows) {
-					m_uniqueWindows->CalculateSize((etkFloat_t)m_width, (etkFloat_t)m_height);
-				}
-			};
-		
-		private:
-			bool m_resizeMode;
-			bool m_moveMode;
-			int32_t m_startX;
-			int32_t m_startY;
-			int32_t m_screenOffsetX;
-			int32_t m_screenOffsetY;
-			
-		public:
-			void StartResizeSystem(void)
-			{
-				EWOL_INFO("Start Resizing the windows");
-				m_resizeMode = true;
-				this->GetAbsPos(m_startX, m_startY);
-				m_screenOffsetX = m_cursorEventX;
-				m_screenOffsetY = m_cursorEventY;
-			};
-		public:
-			// TODO : need to Check all of this... to write a better code... if needed...
-			void StartMoveSystem(void)
-			{
-				EWOL_INFO("Start Moving the windows");
-				m_moveMode=true;
-				this->GetAbsPos(m_startX, m_startY);
-				EWOL_DEBUG("ref pos : (" << m_startX << "," << m_startY << ") (" << m_cursorEventX << "," << m_cursorEventY << ")");
-				m_screenOffsetX = m_cursorEventX;
-				m_screenOffsetY = m_cursorEventY;
-			};
-		private:
-			bool inputIsPressed[20];
-		public:
-			bool IsPressedInput(int32_t inputID)
-			{
-				if(    NB_MAX_INPUT > inputID
-				    && 0 <= inputID)
-				{
-					return inputIsPressed[inputID];
-				} else {
-					EWOL_WARNING("Wrong input ID : " << inputID);
-					return false;
-				}
-			}
-	};
-};
-
-
-
-#undef __class__
-#define __class__ "guiAbstraction"
-
-static bool guiAbstractionIsInit = false;
-static guiAbstraction::X11systemInterface * myX11Access = NULL;
-
-
-void guiAbstraction::Init(int32_t argc, char *argv[])
-{
-	if (false == guiAbstractionIsInit) {
-		// set the gui is init :
-		guiAbstractionIsInit = true;
-		EWOL_INFO("INIT for X11 environement");
-		myX11Access = new guiAbstraction::X11systemInterface();
-	} else {
-		EWOL_CRITICAL("Can not INIT X11 ==> already init before");
-	}
-}
-
-
-void guiAbstraction::Run(void)
-{
-	if (true == guiAbstractionIsInit) {
-		EWOL_INFO("Start Running");
-		myX11Access->Run();
-		EWOL_INFO("Stop Running");
-	} else {
-		EWOL_CRITICAL("Can not Run X11 ==> not init ... ");
-	}
-}
-
-void guiAbstraction::Stop(void)
-{
-	if (true == guiAbstractionIsInit) {
-		myX11Access->Stop();
-	} else {
-		EWOL_CRITICAL("Can not Stop X11 ==> not init ... ");
-	}
-}
-
-void guiAbstraction::SetDisplayOnWindows(ewol::Windows * newOne)
-{
-	if (true == guiAbstractionIsInit) {
-		myX11Access->Setwindow(newOne);
-	} else {
-		EWOL_CRITICAL("Can not set Windows X11 ==> not init ... ");
-	}
-}
-
-void guiAbstraction::UnInit(void)
-{
-	if (true == guiAbstractionIsInit) {
-		EWOL_INFO("UN-INIT for X11 environement");
-		if (NULL != myX11Access) {
-			delete(myX11Access);
-		}
-		guiAbstractionIsInit = false;
-	} else {
-		EWOL_CRITICAL("Can not Un-Init X11 ==> not init ... ");
-	}
-}
-
-
-void guiAbstraction::ChangeSize(int32_t w, int32_t h)
-{
-	if (true == guiAbstractionIsInit) {
-		myX11Access->ChangeSize(w, h);
-	} else {
-		EWOL_CRITICAL("X11 ==> not init ... ");
-	}
-}
-
-void guiAbstraction::ChangePos(int32_t x, int32_t y)
-{
-	if (true == guiAbstractionIsInit) {
-		myX11Access->ChangePos(x, y);
-	} else {
-		EWOL_CRITICAL("X11 ==> not init ... ");
-	}
-}
-
-void guiAbstraction::GetAbsPos(int32_t & x, int32_t & y)
-{
-	if (true == guiAbstractionIsInit) {
-		myX11Access->GetAbsPos(x, y);
-	} else {
-		EWOL_CRITICAL("X11 ==> not init ... ");
-	}
-}
-
-void guiAbstraction::StartResizeSystem(void)
-{
-	if (true == guiAbstractionIsInit) {
-		myX11Access->StartResizeSystem();
-	} else {
-		EWOL_CRITICAL("X11 ==> not init ... ");
-	}
-}
-
-void guiAbstraction::StartMoveSystem(void)
-{
-	if (true == guiAbstractionIsInit) {
-		myX11Access->StartMoveSystem();
-	} else {
-		EWOL_CRITICAL("X11 ==> not init ... ");
-	}
-}
-
-bool guiAbstraction::IsPressedInput(int32_t inputID)
-{
-	if (true == guiAbstractionIsInit) {
-		return myX11Access->IsPressedInput(inputID);
-	} else {
-		EWOL_CRITICAL("X11 ==> not init ... ");
-		return false;
-	}
-}
-
-void guiAbstraction::ForceRedrawAll(void)
-{
-	if (true == guiAbstractionIsInit) {
-		myX11Access->ForceRedrawAll();
-	} else {
-		EWOL_CRITICAL("X11 ==> not init ... ");
-	}
-}
-
-#include <ewol/ewol.h>
-
-
-
-
-
-int main(int argc, char *argv[])
-{
-	// init Ewol
-	ewol::Init(argc, argv);
-	// Init Application ...
-	APP_Init(argc, argv);
-	// Start Ewol diwplay while
-	ewol::Run();
-	// unset all windows
-	ewol::DisplayWindows(NULL);
-	// call application to uninit
-	APP_UnInit();
-	// uninit Ewol
-	ewol::UnInit();
-	
-	return 0;
-}
-

Sources/etk/Debug.cpp

@@ -1,71 +0,0 @@
-/**
- *******************************************************************************
- * @file etk/Debug.h
- * @brief Ewol Tool Kit : log implementation
- * @author Edouard DUPIN
- * @date 08/06/2010
- * @par Project
- * Ewol TK
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#include <etk/Debug.h>
-#include <time.h>
-
-// Max string size : (wide screan console nb caractere)
-#define EDN_LOG_MAX_LENGTH 250
-
-
-#define FUNCTION_NAME_SIZE	(70)
-
-void TOOLS_DisplayFuncName(int32_t ligne, const char* className, const char* funcName, const char* libName)
-{
-	char tmpName[FUNCTION_NAME_SIZE] = "";
-	
-	if (NULL == className) {
-		if (NULL == libName) {
-			snprintf(tmpName, FUNCTION_NAME_SIZE, "???????? | (l=%5d) %s                                             ",ligne, funcName);
-		} else {
-			snprintf(tmpName, FUNCTION_NAME_SIZE, "%s | (l=%5d) %s                                             ",libName, ligne, funcName);
-		}
-	} else {
-		if (NULL == libName) {
-			snprintf(tmpName, FUNCTION_NAME_SIZE, "???????? | (l=%5d) %s::%s                                             ",ligne, className, funcName);
-		} else {
-			snprintf(tmpName, FUNCTION_NAME_SIZE, "%s | (l=%5d) %s::%s                                             ", libName, ligne, className, funcName);
-		}
-		
-	}
-	tmpName[FUNCTION_NAME_SIZE-4] = ' ';
-	tmpName[FUNCTION_NAME_SIZE-3] = '|';
-	tmpName[FUNCTION_NAME_SIZE-2] = ' ';
-	tmpName[FUNCTION_NAME_SIZE-1] = '\0';
-	etk::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);
-	etk::cout << tmpdata ;
-}
-

Sources/etk/Debug.h

@@ -1,97 +0,0 @@
-/**
- *******************************************************************************
- * @file etk/Debug.h
- * @brief Ewol Tool Kit : log implementation
- * @author Edouard DUPIN
- * @date 08/06/2010
- * @par Project
- * Ewol TK
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#ifndef __ETK_DEBUG_H__
-#define __ETK_DEBUG_H__
-
-#include <etk/Stream.h>
-#include <etk/Types.h>
-
-// Log Message System For EDN
-void TOOLS_DisplayFuncName(int32_t ligne, const char* className, const char* funcName, const char* libName);
-void TOOLS_DisplayTime(void);
-
-//regular colors
-#define ETK_BASH_COLOR_BLACK				"\e[0;30m"
-#define ETK_BASH_COLOR_RED				"\e[0;31m"
-#define ETK_BASH_COLOR_GREEN				"\e[0;32m"
-#define ETK_BASH_COLOR_YELLOW			"\e[0;33m"
-#define ETK_BASH_COLOR_BLUE				"\e[0;34m"
-#define ETK_BASH_COLOR_MAGENTA			"\e[0;35m"
-#define ETK_BASH_COLOR_CYAN				"\e[0;36m"
-#define ETK_BASH_COLOR_WHITE				"\e[0;37m"
-//emphasized (bolded) colors
-#define ETK_BASH_COLOR_BOLD_BLACK		"\e[1;30m"
-#define ETK_BASH_COLOR_BOLD_RED			"\e[1;31m"
-#define ETK_BASH_COLOR_BOLD_GREEN		"\e[1;32m"
-#define ETK_BASH_COLOR_BOLD_YELLOW		"\e[1;33m"
-#define ETK_BASH_COLOR_BOLD_BLUE			"\e[1;34m"
-#define ETK_BASH_COLOR_BOLD_MAGENTA		"\e[1;35m"
-#define ETK_BASH_COLOR_BOLD_CYAN			"\e[1;36m"
-#define ETK_BASH_COLOR_BOLD_WHITE		"\e[1;37m"
-//background colors
-#define ETK_BASH_COLOR_BG_BLACK			"\e[40m"
-#define ETK_BASH_COLOR_BG_RED			"\e[41m"
-#define ETK_BASH_COLOR_BG_GREEN			"\e[42m"
-#define ETK_BASH_COLOR_BG_YELLOW			"\e[43m"
-#define ETK_BASH_COLOR_BG_BLUE			"\e[44m"
-#define ETK_BASH_COLOR_BG_MAGENTA		"\e[45m"
-#define ETK_BASH_COLOR_BG_CYAN			"\e[46m"
-#define ETK_BASH_COLOR_BG_WHITE			"\e[47m"
-// Return to the normal color setings
-#define ETK_BASH_COLOR_NORMAL			"\e[0m"
-//go to the Top of bash
-#define ETK_BASH_GO_TOP					"\e[0;0f"
-
-#undef  __class__
-#define __class__				(NULL)
-
-#define ETK_DBG_COMMON(libName, color, info, data)	do { \
-														etk::cout << color; \
-														TOOLS_DisplayTime(); \
-														TOOLS_DisplayFuncName(__LINE__, __class__, __func__, libName); \
-														etk::cout << "[" << info << "] " << data; \
-														etk::cout << ETK_BASH_COLOR_NORMAL <<etk::endl; \
-													}while(0)
-#define ETK_CRITICAL(libName, data)					ETK_DBG_COMMON(libName, ETK_BASH_COLOR_BOLD_RED, 'C', data)
-#define ETK_WARNING(libName, data)					ETK_DBG_COMMON(libName, ETK_BASH_COLOR_MAGENTA,  'W', data)
-#define ETK_ERROR(libName, data)					ETK_DBG_COMMON(libName, ETK_BASH_COLOR_BOLD_RED, 'E', data)
-#define ETK_INFO(libName, data)						ETK_DBG_COMMON(libName, ETK_BASH_COLOR_CYAN,     'I', data)
-#define ETK_DEBUG(libName, data)					ETK_DBG_COMMON(libName, ETK_BASH_COLOR_YELLOW,   'D', data)
-#define ETK_VERBOSE(libName, data)					ETK_DBG_COMMON(libName, ETK_BASH_COLOR_WHITE,    'V', data)
-#define ETK_ASSERT(libName, cond, data)				do { \
-														if (!(cond)) { \
-															ETK_CRITICAL(libName, data); \
-															assert(!#cond); \
-														} \
-													} while (0)
-#define ETK_CHECK_INOUT_ASSERT(libName, cond)		ETK_ASSERT(libName, (cond), "Internal input error : "#cond)
-#define ETK_CHECK_INOUT_WARNING(libName, cond)		do { \
-														if (!(cond)) { \
-															ETK_CRITICAL(libName, "Internal input error : "#cond); \
-														} \
-													} while (0)
-#define ETK_CHECK_MAGIC(libName, cond)				ETK_ASSERT(libName, (cond), "MAGIC check error : "#cond)
-
-#endif

Sources/etk/DebugInternal.cpp

@@ -1,25 +0,0 @@
-/**
- *******************************************************************************
- * @file etk/DebugInternal.cpp
- * @brief Ewol Tool Kit : log wrapper (sources)
- * @author Edouard DUPIN
- * @date 19/10/2011
- * @par Project
- * Ewol TK
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-const char * etkLibName = "Etk     ";

Sources/etk/DebugInternal.h

@@ -1,71 +0,0 @@
-/**
- *******************************************************************************
- * @file etk/DebugInternal.h
- * @brief Ewol Tool Kit : log wrapper (header)
- * @author Edouard DUPIN
- * @date 19/10/2011
- * @par Project
- * Ewol TK
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#ifndef __ETK_DEBUG_INTERNAL_H__
-#define __ETK_DEBUG_INTERNAL_H__
-
-#include "etk/Debug.h"
-
-extern const char * etkLibName;
-
-#define TK_CRITICAL(data)			ETK_CRITICAL(etkLibName, data)
-// General 
-#if ETK_DEBUG_LEVEL > 0
-#	define TK_WARNING(data)			ETK_WARNING(etkLibName, data)
-#	define TK_ERROR(data)			ETK_ERROR(etkLibName, data)
-#else
-#	define TK_WARNING(data)			do {}while(0)
-#	define TK_ERROR(data)			do {}while(0)
-#endif
-
-#if ETK_DEBUG_LEVEL > 1
-#	define TK_INFO(data)			ETK_INFO(etkLibName, data)
-#else
-#	define TK_INFO(data)			do {}while(0)
-#endif
-
-#if ETK_DEBUG_LEVEL > 2
-#	define TK_DEBUG(data)			ETK_DEBUG(etkLibName, data)
-#else
-#	define TK_DEBUG(data)			do {}while(0)
-#endif
-
-#if ETK_DEBUG_LEVEL > 3
-#	define TK_VERBOSE(data)			ETK_VERBOSE(etkLibName, data)
-#else
-#	define TK_VERBOSE(data)			do {}while(0)
-#endif
-
-#define TK_ASSERT(cond, data)		ETK_ASSERT(etkLibName, cond, data)
-
-#if ETK_DEBUG_LEVEL > 1
-#   define TK_CHECK_INOUT(cond)		ETK_CHECK_INOUT_ASSERT(etkLibName, cond)
-#elif ETK_DEBUG_LEVEL > 0
-#   define TK_CHECK_INOUT(cond)		ETK_CHECK_INOUT_WARNING(etkLibName, cond)
-#else
-#   define TK_CHECK_INOUT(cond)		do { } while (0)
-#endif
-
-#endif
-

Sources/etk/File.cpp

@@ -1,819 +0,0 @@
-/**
- *******************************************************************************
- * @file etk/File.cpp
- * @brief Ewol Tool Kit : File folder and name abstraction (Sources)
- * @author Edouard DUPIN
- * @date 16/07/2011
- * @par Project
- * Ewol TK
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-#include <etk/Types.h>
-#include <etk/DebugInternal.h>
-#include <etk/File.h>
-#include <unistd.h>
-
-#ifdef DATA_INTERNAL_BINARY
-#	include <GeneratedData.h>
-#elif defined(DATA_IN_APK)
-#	include <stdio.h>
-#	include <zip.h>
-#endif
-
-
-
-#undef __class__
-#define __class__	"etk::File"
-
-
-etk::CCout& etk::operator <<(etk::CCout &os, const etk::File &obj)
-{
-	os << obj.m_folder;
-	os << "/";
-	os << obj.m_shortFilename;
-	return os;
-}
-
-etk::File::File(etk::String &filename, etk::FileType_te type, int32_t LineNumber)
-{
-	m_lineNumberOpen = LineNumber;
-	m_PointerFile = NULL;
-	SetCompleateName(filename, type);
-}
-
-
-etk::File::File(const char  *filename, etk::FileType_te type, int32_t LineNumber)
-{
-	etk::String tmpString = filename;
-	m_lineNumberOpen = LineNumber;
-	m_PointerFile = NULL;
-	SetCompleateName(tmpString, type);
-}
-
-
-etk::File::File(etk::String &filename, etk::String &folder, etk::FileType_te type, int32_t lineNumber)
-{
-	etk::String tmpString = folder;
-	tmpString += '/';
-	tmpString += filename;
-	m_PointerFile = NULL;
-	SetCompleateName(tmpString, type);
-	m_lineNumberOpen = lineNumber;
-}
-
-etk::File::~File(void)
-{
-	// nothing to do ...
-	if (NULL != m_PointerFile) {
-		TK_ERROR("Missing close the file : \"" << GetCompleateName() << "\"");
-		fClose();
-	}
-}
-
-
-etk::String etk::File::GetFolder(void) const
-{
-	return m_folder;
-}
-
-etk::String etk::File::GetShortFilename(void) const
-{
-	return m_shortFilename;
-}
-
-etk::String etk::File::GetCompleateName(void) const
-{
-	etk::String out;
-	out  = m_folder;
-	out += '/';
-	out += m_shortFilename;
-	return out;
-}
-
-const etk::File& etk::File::operator= (const etk::File &etkF )
-{
-	if( this != &etkF ) // avoid copy to itself
-	{
-		m_folder = etkF.m_folder;
-		m_shortFilename = etkF.m_shortFilename;
-		m_lineNumberOpen = etkF.m_lineNumberOpen;
-		m_type = etkF.m_type;
-		if (NULL != m_PointerFile) {
-			TK_ERROR("Missing close the file : \"" << GetCompleateName() << "\"");
-			fClose();
-		}
-		#ifdef DATA_INTERNAL_BINARY
-			m_idInternal = etkF.m_idInternal;
-			m_readingOffset = 0;
-		#elif defined(DATA_IN_APK)
-			m_idZipFile = etkF.m_idZipFile;
-			m_zipData = NULL;
-			m_zipDataSize = 0;
-			m_zipReadingOffset = 0;
-			//m_zipPointerFile = NULL;
-		#endif
-	}
-	return *this;
-}
-
-
-/**
- * @brief 
- *
- * @param[in,out] 
- *
- * @return 
- *
- */
-bool etk::File::operator== (const etk::File &etkF) const
-{
-	if( this != &etkF ) {
-		if (etkF.GetCompleateName() == GetCompleateName() ) {
-			return true;
-		} else {
-			return false;
-		}
-		return true;
-	}
-	return true;
-}
-
-/**
- * @brief 
- *
- * @param[in,out] 
- *
- * @return 
- *
- */
-bool etk::File::operator!= (const etk::File &etkF) const
-{
-	return !(*this == etkF);
-}
-
-
-etk::String baseFolderData = "assets/";
-#ifdef DATA_IN_APK
-static etk::String s_fileAPK = "";
-
-static struct zip * s_APKArchive = NULL;
-static int32_t      s_APKnbFiles = 0;
-
-
-static void loadAPK (const char* apkPath)
-{
-	TK_DEBUG("Loading APK \"" << apkPath << "\"");
-	s_APKArchive = zip_open(apkPath, 0, NULL);
-	TK_ASSERT(s_APKArchive != NULL, "Error loading APK ...  \"" << apkPath << "\"");
-	//Just for debug, print APK contents
-	s_APKnbFiles = zip_get_num_files(s_APKArchive);
-	TK_INFO("List all files in the APK : " << s_APKnbFiles << " files");
-	for (int iii=0; iii<s_APKnbFiles; iii++) {
-		const char* name = zip_get_name(s_APKArchive, iii, 0);
-		if (name == NULL) {
-			TK_ERROR("Error reading zip file name at index " << iii << " : \"" << zip_strerror(s_APKArchive) << "\"");
-			return;
-		}
-		TK_INFO("    File " << iii << " : \"" << name << "\"");
-	}
-}
-#endif
-etk::String baseFolderDataUser = "~/.tmp/userData/";
-etk::String baseFolderCache = "~/.tmp/cache/";
-// for specific device contraint : 
-void etk::SetBaseFolderData(const char * folder)
-{
-	#ifdef DATA_INTERNAL_BINARY
-		for(int32_t iii=0; iii<internalDataFilesSize; iii++) {
-			TK_DEBUG("Internal date : \"" << internalDataFiles[iii].filename << "\" size=" << internalDataFiles[iii].fileLenght);
-		}
-	#elif defined(DATA_IN_APK)
-		baseFolderData = "assets/";
-		s_fileAPK = folder;
-		loadAPK(s_fileAPK.c_str());
-	#else
-		baseFolderData = folder;
-	#endif
-}
-void etk::SetBaseFolderDataUser(const char * folder)
-{
-	baseFolderDataUser = folder;
-}
-void etk::SetBaseFolderCache(const char * folder)
-{
-	baseFolderCache = folder;
-}
-
-
-void etk::File::SetCompleateName(etk::String &newFilename, etk::FileType_te type)
-{
-	char buf[MAX_FILE_NAME];
-	memset(buf, 0, MAX_FILE_NAME);
-	char * ok;
-	#ifdef DATA_INTERNAL_BINARY
-	m_idInternal = -1;
-	#elif defined(DATA_IN_APK)
-	m_idZipFile = -1;
-	m_zipData = NULL;
-	m_zipDataSize = 0;
-	m_zipReadingOffset = 0;
-	//m_zipPointerFile = NULL;
-	#endif
-	// Reset ALL DATA : 
-	m_folder = "";
-	m_shortFilename = "";
-	m_lineNumberOpen = 0;
-	TK_VERBOSE("1 :Set Name : " << newFilename );
-	etk::String destFilename;
-	if (newFilename.Size() == 0) {
-		destFilename = "no-name";
-	} else {
-		destFilename = newFilename;
-	}
-	TK_VERBOSE("2 : Get file Name : " << destFilename );
-	if ('/' == *destFilename.c_str()) {
-		m_type = etk::FILE_TYPE_DIRECT;
-		if (type != etk::FILE_TYPE_DIRECT) {
-			TK_WARNING("Incompatible type with a file=\"" << newFilename << "\" ==> force it in direct mode ...");
-		}
-	} else {
-		if (type == etk::FILE_TYPE_DIRECT) {
-			TK_WARNING("Incompatible type with a file=\"" << newFilename << "\" ==> force it in FILE_TYPE_DATA mode ...");
-			m_type = etk::FILE_TYPE_DATA;
-		} else {
-			m_type = type;
-		}
-	}
-	bool needUnpack = false;
-	#if ETK_DEBUG_LEVEL > 2
-	char *mode = NULL;
-	#endif
-	switch (m_type)
-	{
-		case etk::FILE_TYPE_DATA:
-			{
-				#if ETK_DEBUG_LEVEL > 2
-				mode = "FILE_TYPE_DATA";
-				#endif
-				#ifdef DATA_INTERNAL_BINARY
-					for(int32_t iii=0; iii<internalDataFilesSize; iii++) {
-						if (destFilename == internalDataFiles[iii].filename) {
-							m_idInternal = iii;
-							break;
-						}
-					}
-					if (-1 == m_idInternal) {
-						TK_ERROR("File Does not existed ... in memory : \"" << destFilename << "\"");
-					}
-				#elif defined(DATA_IN_APK)
-					etk::String tmpFilename = baseFolderData + destFilename;
-					for (int iii=0; iii<s_APKnbFiles; iii++) {
-						const char* name = zip_get_name(s_APKArchive, iii, 0);
-						if (name == NULL) {
-							return;
-						}
-						if (tmpFilename == name) {
-							m_idZipFile = iii;
-							break;
-						}
-					}
-					if (-1 == m_idZipFile) {
-						TK_ERROR("File Does not existed ... in APK : \"" << tmpFilename << "\"");
-					}
-				#else
-					etk::String tmpFilename = destFilename;
-					destFilename = baseFolderData;
-					destFilename += tmpFilename;
-				#endif
-			}
-			break;
-		case etk::FILE_TYPE_USER_DATA:
-			{
-				#if ETK_DEBUG_LEVEL > 2
-				mode = "FILE_TYPE_USER_DATA";
-				#endif
-				etk::String tmpFilename = destFilename;
-				destFilename = baseFolderDataUser;
-				destFilename += tmpFilename;
-			}
-			needUnpack = true;
-			break;
-		case etk::FILE_TYPE_CACHE:
-			{
-				#if ETK_DEBUG_LEVEL > 2
-				mode = "FILE_TYPE_CACHE";
-				#endif
-				etk::String tmpFilename = destFilename;
-				destFilename = baseFolderCache;
-				destFilename += tmpFilename;
-			}
-			needUnpack = true;
-			break;
-		default:
-			// nothing to do ...
-			#if ETK_DEBUG_LEVEL > 2
-			mode = "FILE_TYPE_DIRECT";
-			#endif
-			needUnpack = true;
-			break;
-	}
-	TK_VERBOSE("3 : Get file Name : " << destFilename );
-	if (true == needUnpack) {
-		// 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
-				etk::String tmpFilename = destFilename.Extract(lastPos+1);
-				destFilename.Remove(lastPos, destFilename.Size() - lastPos);
-				TK_VERBOSE("try to find :\"" << destFilename << "\" / \"" << tmpFilename << "\" ");
-				ok = realpath(destFilename.c_str(), buf);
-				if (!ok) {
-					TK_VERBOSE("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 {
-				TK_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 ...
-				TK_WARNING("file : \"" << destFilename << "\" ==> No data???");
-				m_shortFilename = destFilename;
-			}
-		}
-	} else {
-		int32_t lastPos = destFilename.FindBack('/');
-		if (-1 != lastPos) {
-			m_shortFilename = destFilename.Extract(lastPos+1);
-			m_folder        = destFilename.Extract(0, lastPos);
-		} else {
-			// Basic ERROR ...
-			TK_WARNING("file : \"" << destFilename << "\" ==> No data???");
-			m_shortFilename = destFilename;
-		}
-	}
-	TK_DEBUG("Set FileName :\"" << m_folder << "\" / \"" << m_shortFilename << "\" mode=" << mode);
-}
-
-int32_t etk::File::GetLineNumber(void)
-{
-	return m_lineNumberOpen;
-}
-
-void etk::File::SetLineNumber(int32_t newline)
-{
-	m_lineNumberOpen = newline;
-}
-
-bool etk::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;
-	}
-}
-
-
-etk::String etk::File::GetExtention(void)
-{
-	etk::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;
-}
-
-#ifdef DATA_IN_APK
-bool etk::File::LoadDataZip(void)
-{
-	if (NULL != m_zipData) {
-		return true;
-	} else {
-		struct zip_file * m_zipPointerFile= zip_fopen_index(s_APKArchive, m_idZipFile, 0);
-		if (NULL == m_zipPointerFile) {
-			TK_ERROR("Can not find the file name=\"" << GetCompleateName() << "\"");
-			return false;
-		}
-		// get the fileSize .... end read all the data from the zip files
-		struct zip_stat zipFileProperty;
-		zip_stat_init(&zipFileProperty);
-		zip_stat_index(s_APKArchive, m_idZipFile, 0, &zipFileProperty);
-		TK_DEBUG("LOAD data from the files : \"" << GetCompleateName() << "\"");
-		TK_DEBUG("         name=" << zipFileProperty.name);
-		TK_DEBUG("         index=" << zipFileProperty.index);
-		TK_DEBUG("         crc=" << zipFileProperty.crc);
-		TK_DEBUG("         mtime=" << zipFileProperty.mtime);
-		TK_DEBUG("         size=" << zipFileProperty.size);
-		TK_DEBUG("         comp_size=" << zipFileProperty.comp_size);
-		TK_DEBUG("         comp_method=" << zipFileProperty.comp_method);
-		TK_DEBUG("         encryption_method=" << zipFileProperty.encryption_method);
-		m_zipDataSize = zipFileProperty.size;
-		m_zipData = new char[m_zipDataSize +10];
-		if (NULL == m_zipData) {
-			TK_ERROR("File allocation ERROR : \"" << GetCompleateName() << "\"");
-			zip_fclose(m_zipPointerFile);
-			return false;
-		}
-		memset(m_zipData, 0, m_zipDataSize +10);
-		int32_t sizeTmp = zip_fread(m_zipPointerFile, m_zipData, m_zipDataSize);
-		if (sizeTmp != m_zipDataSize) {
-			TK_ERROR("File load data ERROR : \"" << GetCompleateName() << "\"");
-			zip_fclose(m_zipPointerFile);
-			delete[] m_zipData;
-			return false;
-		}
-		zip_fclose(m_zipPointerFile);
-		m_zipPointerFile = NULL;
-		return true;
-	}
-}
-#endif
-
-int32_t etk::File::Size(void)
-{
-	#ifdef DATA_INTERNAL_BINARY
-	if (etk::FILE_TYPE_DATA == m_type) {
-		if (m_idInternal >= -1  && m_idInternal < internalDataFilesSize) {
-			return internalDataFiles[m_idInternal].fileLenght;
-		}
-		return 0;
-	}
-	#elif defined(DATA_IN_APK)
-	if (etk::FILE_TYPE_DATA == m_type) {
-		if (true == LoadDataZip()) {
-			return m_zipDataSize;
-		}
-		return 0;
-	}
-	#endif
-	FILE *myFile=NULL;
-	etk::String myCompleateName = GetCompleateName();
-	myFile=fopen(myCompleateName.c_str(),"rb");
-	if(NULL == myFile) {
-		//EWOL_ERROR("Can not find the file name=\"" << m_folder << "\" / \"" << m_shortFilename << "\"");
-		return -1;
-	}
-	int32_t size = 0;
-	fseek(myFile, 0, SEEK_END);
-	size = ftell(myFile);
-	fseek(myFile, 0, SEEK_SET);
-	fclose(myFile);
-	return size;
-}
-
-
-bool etk::File::Exist(void)
-{
-	#ifdef DATA_INTERNAL_BINARY
-	if (etk::FILE_TYPE_DATA == m_type) {
-		if (m_idInternal >= -1  && m_idInternal < internalDataFilesSize) {
-			return true;
-		}
-		return false;
-	}
-	#elif defined(DATA_IN_APK)
-	if (etk::FILE_TYPE_DATA == m_type) {
-		if (m_idZipFile >= -1  && m_idZipFile < s_APKnbFiles) {
-			return true;
-		}
-		return false;
-	}
-	#endif
-	FILE *myFile=NULL;
-	etk::String myCompleateName = GetCompleateName();
-	myFile=fopen(myCompleateName.c_str(),"rb");
-	if(NULL == myFile) {
-		return false;
-	}
-	fclose(myFile);
-	return true;
-}
-
-
-
-bool etk::File::fOpenRead(void)
-{
-	#ifdef DATA_INTERNAL_BINARY
-	if (etk::FILE_TYPE_DATA == m_type) {
-		m_readingOffset = 0;
-		if (m_idInternal >= -1  && m_idInternal < internalDataFilesSize) {
-			TK_DEBUG("Open file : " << GetCompleateName() << " with size=" << internalDataFiles[m_idInternal].fileLenght << " Octets");
-			return true;
-		}
-		return false;
-	}
-	#elif defined(DATA_IN_APK)
-	if (etk::FILE_TYPE_DATA == m_type) {
-		return LoadDataZip();
-	}
-	#endif
-	if (NULL != m_PointerFile) {
-		TK_CRITICAL("File Already open : \"" << GetCompleateName() << "\"");
-		return true;
-	}
-	m_PointerFile=fopen(GetCompleateName().c_str(),"rb");
-	if(NULL == m_PointerFile) {
-		TK_ERROR("Can not find the file name=\"" << GetCompleateName() << "\"");
-		return false;
-	}
-	return true;
-}
-
-bool etk::File::fOpenWrite(void)
-{
-	#ifdef DATA_INTERNAL_BINARY
-	if (etk::FILE_TYPE_DATA == m_type) {
-		m_readingOffset = 0;
-		return false;
-	}
-	#elif defined(DATA_IN_APK)
-	if (etk::FILE_TYPE_DATA == m_type) {
-		return false;
-	}
-	#endif
-	if (NULL != m_PointerFile) {
-		TK_CRITICAL("File Already open : \"" << GetCompleateName() << "\"");
-		return true;
-	}
-	m_PointerFile=fopen(GetCompleateName().c_str(),"wb");
-	if(NULL == m_PointerFile) {
-		TK_ERROR("Can not find the file name=\"" << GetCompleateName() << "\"");
-		return false;
-	}
-	return true;
-}
-
-bool etk::File::fClose(void)
-{
-	#ifdef DATA_INTERNAL_BINARY
-	if (etk::FILE_TYPE_DATA == m_type) {
-		m_readingOffset = 0;
-		if (m_idInternal >= -1  && m_idInternal < internalDataFilesSize) {
-			return true;
-		}
-		return false;
-	}
-	#elif defined(DATA_IN_APK)
-	if (etk::FILE_TYPE_DATA == m_type) {
-		if (NULL == m_zipData) {
-			TK_CRITICAL("File Already closed : \"" << GetCompleateName() << "\"");
-			return false;
-		}
-		delete[] m_zipData;
-		m_zipData = NULL;
-		m_zipDataSize = 0;
-		m_zipReadingOffset = 0;
-		return true;
-	}
-	#endif
-	if (NULL == m_PointerFile) {
-		TK_CRITICAL("File Already closed : \"" << GetCompleateName() << "\"");
-		return false;
-	}
-	fclose(m_PointerFile);
-	m_PointerFile = NULL;
-	return true;
-}
-
-char * etk::File::fGets(char * elementLine, int32_t maxData)
-{
-	memset(elementLine, 0, maxData);
-	#ifdef DATA_INTERNAL_BINARY
-	char * element = elementLine;
-	if (etk::FILE_TYPE_DATA == m_type) {
-		if (m_idInternal >= -1  && m_idInternal < internalDataFilesSize) {
-			//char * tmpData = internalDataFiles[iii].data + m_readingOffset;
-			if (m_readingOffset>internalDataFiles[m_idInternal].fileLenght) {
-				element[0] = '\0';
-				return NULL;
-			}
-			while (internalDataFiles[m_idInternal].data[m_readingOffset] != '\0') {
-				if(    internalDataFiles[m_idInternal].data[m_readingOffset] == '\n'
-				    || internalDataFiles[m_idInternal].data[m_readingOffset] == '\r')
-				{
-					*element = internalDataFiles[m_idInternal].data[m_readingOffset];
-					element++;
-					m_readingOffset++;
-					*element = '\0';
-					return elementLine;
-				}
-				*element = internalDataFiles[m_idInternal].data[m_readingOffset];
-				element++;
-				m_readingOffset++;
-				if (m_readingOffset>internalDataFiles[m_idInternal].fileLenght) {
-					*element = '\0';
-					return elementLine;
-				}
-			}
-		}
-		elementLine[0] = '\0';
-		return NULL;
-	}
-	#elif defined(DATA_IN_APK)
-	char * element = elementLine;
-	if (etk::FILE_TYPE_DATA == m_type) {//char * tmpData = internalDataFiles[iii].data + m_readingOffset;
-		if (NULL == m_zipData) {
-			element[0] = '\0';
-			return NULL;
-		}
-		if (m_zipReadingOffset>m_zipDataSize) {
-			element[0] = '\0';
-			return NULL;
-		}
-		while (m_zipData[m_zipReadingOffset] != '\0') {
-			if(    m_zipData[m_zipReadingOffset] == '\n'
-			    || m_zipData[m_zipReadingOffset] == '\r')
-			{
-				*element = m_zipData[m_zipReadingOffset];
-				element++;
-				m_zipReadingOffset++;
-				*element = '\0';
-				return elementLine;
-			}
-			*element = m_zipData[m_zipReadingOffset];
-			element++;
-			m_zipReadingOffset++;
-			if (m_zipReadingOffset>m_zipDataSize) {
-				*element = '\0';
-				return elementLine;
-			}
-		}
-		return NULL;
-	}
-	#endif
-	return fgets(elementLine, maxData, m_PointerFile);
-}
-
-int32_t etk::File::fRead(void * data, int32_t blockSize, int32_t nbBlock)
-{
-	#ifdef DATA_INTERNAL_BINARY
-	if (etk::FILE_TYPE_DATA == m_type) {
-		if (m_idInternal >= -1  && m_idInternal < internalDataFilesSize) {
-			int32_t dataToRead = blockSize * nbBlock;
-			if (dataToRead + m_readingOffset > internalDataFiles[m_idInternal].fileLenght) {
-				nbBlock = ((internalDataFiles[m_idInternal].fileLenght - m_readingOffset) / blockSize);
-				dataToRead = blockSize * nbBlock;
-			}
-			memcpy(data, &internalDataFiles[m_idInternal].data[m_readingOffset], dataToRead);
-			m_readingOffset +=dataToRead;
-			return nbBlock;
-		}
-		return 0;
-	}
-	#elif defined(DATA_IN_APK)
-	if (etk::FILE_TYPE_DATA == m_type) {
-		if (NULL == m_zipData) {
-			((char*)data)[0] = '\0';
-			return 0;
-		}
-		int32_t dataToRead = blockSize * nbBlock;
-		if (dataToRead + m_zipReadingOffset > m_zipDataSize) {
-			nbBlock = ((m_zipDataSize - m_zipReadingOffset) / blockSize);
-			dataToRead = blockSize * nbBlock;
-		}
-		memcpy(data, &m_zipData[m_zipReadingOffset], dataToRead);
-		m_zipReadingOffset += dataToRead;
-		return nbBlock;
-	}
-	#endif
-	return fread(data, blockSize, nbBlock, m_PointerFile);
-}
-
-int32_t etk::File::fWrite(void * data, int32_t blockSize, int32_t nbBlock)
-{
-	#ifdef DATA_INTERNAL_BINARY
-	if (etk::FILE_TYPE_DATA == m_type) {
-		TK_CRITICAL("Can not write on data inside memory : \"" << GetCompleateName() << "\"");
-		return 0;
-	}
-	#elif defined(DATA_IN_APK)
-	if (etk::FILE_TYPE_DATA == m_type) {
-		TK_CRITICAL("Can not write on data inside APK : \"" << GetCompleateName() << "\"");
-		return 0;
-	}
-	#endif
-	return fwrite(data, blockSize, nbBlock, m_PointerFile);
-}
-
-
-bool etk::File::fSeek(long int offset, int origin)
-{
-	#ifdef DATA_INTERNAL_BINARY
-	if (etk::FILE_TYPE_DATA == m_type) {
-		if (m_idInternal >= -1  && m_idInternal < internalDataFilesSize) {
-			int32_t positionEnd = 0;
-			switch(origin) {
-				case SEEK_END:
-					positionEnd = internalDataFiles[m_idInternal].fileLenght;
-					break;
-				case SEEK_CUR:
-					positionEnd = m_readingOffset;
-					break;
-				default:
-					positionEnd = 0;
-					break;
-			}
-			positionEnd += offset;
-			if (positionEnd < 0) {
-				positionEnd = 0;
-			} else if (positionEnd > internalDataFiles[m_idInternal].fileLenght) {
-				positionEnd = internalDataFiles[m_idInternal].fileLenght;
-			}
-			m_readingOffset = positionEnd;
-			return true;
-		}
-		return false;
-	}
-	#elif defined(DATA_IN_APK)
-	if (etk::FILE_TYPE_DATA == m_type) {
-		if (NULL == m_zipData) {
-			return false;
-		}
-		int32_t positionEnd = 0;
-		switch(origin) {
-			case SEEK_END:
-				positionEnd = m_zipDataSize;
-				break;
-			case SEEK_CUR:
-				positionEnd = m_zipReadingOffset;
-				break;
-			default:
-				positionEnd = 0;
-				break;
-		}
-		positionEnd += offset;
-		if (positionEnd < 0) {
-			positionEnd = 0;
-		} else if (positionEnd > m_zipDataSize) {
-			positionEnd = m_zipDataSize;
-		}
-		m_zipReadingOffset = positionEnd;
-		return true;
-	}
-	#endif
-	fseek(m_PointerFile, offset, origin);
-	if(ferror(m_PointerFile)) {
-		return false;
-	} else {
-		return true;
-	}
-}
-
-
-char * etk::File::GetDirectPointer(void)
-{
-	#ifdef DATA_INTERNAL_BINARY
-	if (etk::FILE_TYPE_DATA == m_type) {
-		if (m_idInternal >= -1  && m_idInternal < internalDataFilesSize) {
-			return (char*)internalDataFiles[m_idInternal].data;
-		}
-	}
-	#elif defined(DATA_IN_APK)
-	if (etk::FILE_TYPE_DATA == m_type) {
-		if (NULL == m_zipData) {
-			return NULL;
-		}
-		return m_zipData;
-	}
-	#endif
-	return NULL;
-}

Sources/etk/File.h

@@ -1,121 +0,0 @@
-/**
- *******************************************************************************
- * @file etk/File.h
- * @brief Ewol Tool Kit : File folder and name abstraction (header)
- * @author Edouard DUPIN
- * @date 16/07/2011
- * @par Project
- * Ewol TK
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#ifndef __ETK_FILE_H__
-#define __ETK_FILE_H__
-
-#include <etk/String.h>
-
-#define MAX_FILE_NAME      (10240)
-
-//http://developer.android.com/guide/topics/data/data-storage.html
-
-namespace etk
-{
-	typedef enum {
-		// user might done abstraction ==> acces of the sdcard when possible ...
-		FILE_TYPE_DIRECT,
-		
-		// depend of the case
-		//     - PC      : /usr/shared/programName/
-		//     - Android : Internal at the executable file (pointer on static area)
-		//     - Apple   : Internal at the executable file
-		FILE_TYPE_DATA,
-		
-		// depend on case
-		//     - PC      : ~/.programName/
-		//     - Android : /data/data/programName/files/
-		//     - Apple   : ????
-		FILE_TYPE_USER_DATA,
-		
-		// depend on case
-		//     - PC      : ~/.programName/cache/
-		//     - Android : /data/data/programName/cache/
-		//     - Apple   : ????
-		FILE_TYPE_CACHE,
-	} FileType_te;
-	
-	class File
-	{
-		public:
-			            File(void) { m_lineNumberOpen=0; m_type = etk::FILE_TYPE_DIRECT; m_PointerFile = NULL;}
-			            File(etk::String &filename, etk::FileType_te type = etk::FILE_TYPE_DIRECT, int32_t LineNumber = 0);
-			            File(const char  *filename, etk::FileType_te type = etk::FILE_TYPE_DIRECT, int32_t LineNumber = 0);
-			            File(etk::String &filename, etk::String &folder, etk::FileType_te type = etk::FILE_TYPE_DIRECT, int32_t lineNumber = 0);
-			            ~File(void);
-			etk::String GetFolder(void) const;
-			etk::String GetShortFilename(void) const;
-			etk::String GetCompleateName(void) const;
-			bool        HasExtention(void);
-			etk::String GetExtention(void);
-			int32_t     Size(void);
-			bool        Exist(void);
-			int32_t     GetLineNumber(void);
-			void        SetLineNumber(int32_t newline);
-			void        SetCompleateName(etk::String &newFilename, etk::FileType_te type);
-			
-			const etk::File& operator=  (const etk::File &etkF );
-			bool             operator== (const etk::File &etkF ) const;
-			bool             operator!= (const etk::File &etkF ) const;
-			friend etk::CCout& operator <<( etk::CCout &os,const etk::File &obj);
-			
-			FileType_te GetTypeAccess(void) { return m_type; };
-			char *      GetDirectPointer(void);
-			
-			// TODO : IO access of the file :
-			bool        fOpenRead(void);
-			bool        fOpenWrite(void);
-			bool        fClose(void);
-			char *      fGets(char * elementLine, int32_t maxData);
-			int32_t     fRead(void * data, int32_t blockSize, int32_t nbBlock);
-			int32_t     fWrite(void * data, int32_t blockSize, int32_t nbBlock);
-			bool        fSeek(long int offset, int origin);
-		private :
-			etk::FileType_te m_type;
-			FILE *           m_PointerFile;
-			#ifdef DATA_INTERNAL_BINARY
-			int32_t          m_idInternal;
-			int32_t          m_readingOffset;
-			#elif defined(DATA_IN_APK)
-			bool             LoadDataZip(void);
-			int32_t          m_idZipFile;
-			char *           m_zipData;
-			int32_t          m_zipDataSize;
-			int32_t          m_zipReadingOffset;
-			#endif
-			etk::String      m_folder;
-			etk::String      m_shortFilename;
-			int32_t          m_lineNumberOpen;
-	};
-	
-	etk::CCout& operator <<(etk::CCout &os, const etk::File &obj);
-	
-	void SetBaseFolderData(const char * folder);
-	void SetBaseFolderDataUser(const char * folder);
-	void SetBaseFolderCache(const char * folder);
-
-}
-
-#endif
-

Sources/etk/Memory.cpp

@@ -1,51 +0,0 @@
-/**
- *******************************************************************************
- * @file etk/Memory.cpp
- * @brief Ewol Tool Kit : Memory implementation (Sources)
- * @author Edouard DUPIN
- * @date 19/10/2011
- * @par Project
- * Ewol TK
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#include <etk/Types.h>
-#include <etk/Memory.h>
-
-// General 
-#if ETK_MEMORY_CHECKER > 0
-
-void etk::MemFree( void * pointerData, const char * variableName, const char * functionName, int32_t line, const char * fileName )
-{
-	TK_CRITICAL(" MEM FREE is not written ==> TODO...");
-	if (NULL != pointerData) {
-		free(pointerData);
-	}
-}
-
-void * etk::MemMalloc( size_t num, size_t size, uint8_t init, const char * variableName, const char * functionName, int32_t line, const char * fileName )
-{
-	TK_CRITICAL(" MEM ALLOCATOR is not written ==> TODO...");
-	return calloc(num, size);
-}
-
-void etk::MemShowLogs( void )
-{
-	TK_CRITICAL(" MEM DISPLAY is not written ==> TODO...");
-}
-
-#endif
-

Sources/etk/Memory.h

@@ -1,94 +0,0 @@
-/**
- *******************************************************************************
- * @file etk/Memory.h
- * @brief Ewol Tool Kit : Memory implementation (headers)
- * @author Edouard DUPIN
- * @date 12/01/2011
- * @par Project
- * Ewol TK
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
- 
-#ifndef __TOOLS_MEMORY_H__
-#define __TOOLS_MEMORY_H__
-
-
-
-// General 
-#if ETK_MEMORY_CHECKER > 0
-namespace etk {
-    void MemFree( void * pointerData, const char * variableName, const char * functionName, int32_t line, const char * fileName );
-    void * MemMalloc( size_t num, size_t size, uint8_t init, const char * variableName, const char * functionName, int32_t line, const char * fileName );
-    void MemShowLogs( void );
-};
-#   define ETK_MALLOC(pointerData, nbElements, dataType)              do {                                                                                                                                \
-                                                                            pointerData = (dataType *)etk::MemMalloc( (nbElements), sizeof(dataType), 0, #pointerData, __func__, __LINE__, __FILE__);    \
-                                                                        }while(0)
-#   define ETK_MALLOC_CAST(pointerData, nbElements, dataType, cast)   do {                                                                                                                                \
-                                                                            pointerData = (cast)etk::MemMalloc( (nbElements), sizeof(dataType), 0, #pointerData, __func__, __LINE__, __FILE__);            \
-                                                                        }while(0)
-#   define ETK_CALLOC(pointerData, nbElements, dataType)              do {                                                                                                                                \
-                                                                            pointerData = (dataType *)etk::MemMalloc( (nbElements), sizeof(dataType), 1, #pointerData, __func__, __LINE__, __FILE__);    \
-                                                                        }while(0)
-#   define ETK_CALLOC_CAST(pointerData, nbElements, dataType, cast)   do {                                                                                                                                \
-                                                                            pointerData = (cast)etk::MemMalloc( (nbElements), sizeof(dataType), 1, #pointerData, __func__, __LINE__, __FILE__);            \
-                                                                        }while(0)
-#   define ETK_FREE(pointerData)                                      do { \
-                                                                            etk::MemFree( (pointerData) , #pointerData, __func__, __LINE__, __FILE__); \
-                                                                            (pointerData) = NULL; \
-                                                                        }while(0)
-#   define ETK_MEM_SHOW_LOG()                                         do { \
-                                                                            etk::MemShowLogs(); \
-                                                                        }while(0)
-#else
-
-#	define ETK_MALLOC(pointerData, nbElements, dataType)					do { \
-																				(pointerData) = (dataType *)malloc( (nbElements) * sizeof(dataType) ); \
-																			}while(0)
-
-#	define ETK_MALLOC_CAST(pointerData, nbElements, dataType, cast)		do { \
-																				(pointerData) = (cast)malloc( (nbElements) * sizeof(dataType) ); \
-																			}while(0)
-
-#	define ETK_CALLOC(pointerData, nbElements, dataType)					do { \
-																				(pointerData) = (dataType *)calloc( (nbElements), sizeof(dataType) ); \
-																			}while(0)
-
-#	define ETK_CALLOC_CAST(pointerData, nbElements, dataType, cast)		do { \
-																				(pointerData) = (cast)calloc( (nbElements), sizeof(dataType) ); \
-																			}while(0)
-
-#	define ETK_REALLOC(pointerData, nbElements, dataType)					do { \
-																				(pointerData) = (dataType *)realloc( (pointerData), (nbElements)* sizeof(dataType) ); \
-																			}while(0)
-
-#	define ETK_REALLOC_CAST(pointerData, nbElements, dataType, cast)		do { \
-																				(pointerData) = (cast)realloc( (pointerData), (nbElements) * sizeof(dataType) ); \
-																			}while(0)
-
-#	define ETK_FREE(pointerData)	do { \
-										free( pointerData ); \
-										(pointerData) = NULL; \
-									}while(0)
-
-#	define ETK_MEM_SHOW_LOG()		do { \
-										TK_DEBUG("No Memory check availlable"); \
-									}while(0)
-#endif
-
-
-#endif
-

Sources/etk/RegExp.cpp

@@ -1,484 +0,0 @@
-/**
- *******************************************************************************
- * @file etk/RegExp.cpp
- * @brief Ewol Tool Kit : Regular expression annalyser (sources)
- * @author Edouard DUPIN
- * @date 04/04/2011
- * @par Project
- * Ewol TK
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#include <etk/RegExp.h>
-
-
-
-const etk::convertionTable_ts etk::constConvertionTable[] = {
-	// haveBackSlash, inputValue, newValue
-	{ false			, '('		, REGEXP_OPCODE_PTHESE_IN},
-	{ true			, '('		, (int16_t)'('},
-	{ false			, ')'		, REGEXP_OPCODE_PTHESE_OUT},
-	{ true			, ')'		, (int16_t)')'},
-	{ false			, '['		, REGEXP_OPCODE_BRACKET_IN},
-	{ true			, '['		, (int16_t)'['},
-	{ false			, ']'		, REGEXP_OPCODE_BRACKET_OUT},
-	{ true			, ']'		, (int16_t)']'},
-	{ false			, '{'		, REGEXP_OPCODE_BRACE_IN},
-	{ true			, '{'		, (int16_t)'{'},
-	{ false			, '}'		, REGEXP_OPCODE_BRACE_OUT},
-	{ true			, '}'		, (int16_t)'}'},
-	{ false			, '-'		, REGEXP_OPCODE_TO},
-	{ true			, '-'		, (int16_t)'-'},
-	{ false			, '*'		, REGEXP_OPCODE_STAR},
-	{ true			, '*'		, (int16_t)'*'},
-	{ false			, '.'		, REGEXP_OPCODE_DOT},
-	{ true			, '.'		, (int16_t)'.'},
-	{ false			, '?'		, REGEXP_OPCODE_QUESTION},
-	{ true			, '?'		, (int16_t)'?'},
-	{ false			, '+'		, REGEXP_OPCODE_PLUS},
-	{ true			, '+'		, (int16_t)'+'},
-	{ false			, '|'		, REGEXP_OPCODE_PIPE},
-	{ true			, '|'		, (int16_t)'|'},
-	{ false			, '^'		, REGEXP_OPCODE_START_OF_LINE},
-	{ true			, '^'		, (int16_t)'^'},
-	{ false			, '$'		, REGEXP_OPCODE_END_OF_LINE},
-	{ true			, '$'		, (int16_t)'$'},
-	{ true			, 'd'		, REGEXP_OPCODE_DIGIT},
-	{ true			, 'D'		, REGEXP_OPCODE_DIGIT_NOT},
-	{ true			, 'l'		, REGEXP_OPCODE_LETTER},
-	{ true			, 'L'		, REGEXP_OPCODE_LETTER_NOT},
-	{ true			, 's'		, REGEXP_OPCODE_SPACE},
-	{ true			, 'S'		, REGEXP_OPCODE_SPACE_NOT},
-	{ true			, 'w'		, REGEXP_OPCODE_WORD},
-	{ true			, 'W'		, REGEXP_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			, '@'		, REGEXP_OPCODE_NO_CHAR},
-};
-const int32_t etk::constConvertionTableSize = sizeof(etk::constConvertionTable) / sizeof(etk::convertionTable_ts) ;
-
-
-/**
- * @brief Display the internal data of a node
- *
- * @param[in] data	element do display in the console
- *
- * @return ---
- *
- */
-void etk::DisplayData(etk::VectorType<char> &data)
-{
-	int32_t i;
-	for (i=0; i<(int32_t)data.Size() ; i++) {
-		etk::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 etk::DisplayElem(etk::VectorType<int16_t> &data, int32_t start, int32_t stop)
-{
-	int32_t i;
-	etk::cout<< ETK_BASH_COLOR_NORMAL;
-	for (i=start; i<(int32_t)data.Size() && i<stop ; i++) {
-		switch(data[i])
-		{
-			case REGEXP_OPCODE_PTHESE_IN:		etk::cout<<ETK_BASH_COLOR_RED		<< (char*)"(" << ETK_BASH_COLOR_NORMAL;		break;
-			case REGEXP_OPCODE_PTHESE_OUT:		etk::cout<<ETK_BASH_COLOR_RED		<< (char*)")" << ETK_BASH_COLOR_NORMAL;		break;
-			case REGEXP_OPCODE_BRACKET_IN:		etk::cout<<ETK_BASH_COLOR_YELLOW	<< (char*)"[" << ETK_BASH_COLOR_NORMAL;		break;
-			case REGEXP_OPCODE_BRACKET_OUT:		etk::cout<<ETK_BASH_COLOR_YELLOW	<< (char*)"]" << ETK_BASH_COLOR_NORMAL;		break;
-			case REGEXP_OPCODE_TO:				etk::cout<<ETK_BASH_COLOR_YELLOW	<< (char*)"-" << ETK_BASH_COLOR_NORMAL;		break;
-			case REGEXP_OPCODE_BRACE_IN:		etk::cout<<ETK_BASH_COLOR_GREEN		<< (char*)"{" << ETK_BASH_COLOR_NORMAL;		break;
-			case REGEXP_OPCODE_BRACE_OUT:		etk::cout<<ETK_BASH_COLOR_GREEN		<< (char*)"}" << ETK_BASH_COLOR_NORMAL;		break;
-			case REGEXP_OPCODE_STAR:			etk::cout<<ETK_BASH_COLOR_BLUE		<< (char*)"*" << ETK_BASH_COLOR_NORMAL;		break;
-			case REGEXP_OPCODE_DOT:				etk::cout<<ETK_BASH_COLOR_BLUE		<< (char*)"." << ETK_BASH_COLOR_NORMAL;		break;
-			case REGEXP_OPCODE_QUESTION:		etk::cout<<ETK_BASH_COLOR_BLUE		<< (char*)"?" << ETK_BASH_COLOR_NORMAL;		break;
-			case REGEXP_OPCODE_PLUS:			etk::cout<<ETK_BASH_COLOR_BLUE		<< (char*)"+" << ETK_BASH_COLOR_NORMAL;		break;
-			case REGEXP_OPCODE_PIPE:			etk::cout<<ETK_BASH_COLOR_BLUE		<< (char*)"|" << ETK_BASH_COLOR_NORMAL;		break;
-			case REGEXP_OPCODE_NO_CHAR:			etk::cout<<ETK_BASH_COLOR_MAGENTA	<< (char*)"@" << ETK_BASH_COLOR_NORMAL;		break;
-			case REGEXP_OPCODE_START_OF_LINE:	etk::cout<<ETK_BASH_COLOR_MAGENTA	<< (char*)"^" << ETK_BASH_COLOR_NORMAL;		break;
-			case REGEXP_OPCODE_END_OF_LINE:		etk::cout<<ETK_BASH_COLOR_MAGENTA	<< (char*)"$" << ETK_BASH_COLOR_NORMAL;		break;
-			case REGEXP_OPCODE_DIGIT:			etk::cout<<ETK_BASH_COLOR_MAGENTA	<< (char*)"\\d" << ETK_BASH_COLOR_NORMAL;	break;
-			case REGEXP_OPCODE_DIGIT_NOT:		etk::cout<<ETK_BASH_COLOR_MAGENTA	<< (char*)"\\D" << ETK_BASH_COLOR_NORMAL;	break;
-			case REGEXP_OPCODE_LETTER:			etk::cout<<ETK_BASH_COLOR_MAGENTA	<< (char*)"\\l" << ETK_BASH_COLOR_NORMAL;	break;
-			case REGEXP_OPCODE_LETTER_NOT:		etk::cout<<ETK_BASH_COLOR_MAGENTA	<< (char*)"\\L" << ETK_BASH_COLOR_NORMAL;	break;
-			case REGEXP_OPCODE_SPACE:			etk::cout<<ETK_BASH_COLOR_MAGENTA	<< (char*)"\\s" << ETK_BASH_COLOR_NORMAL;	break;
-			case REGEXP_OPCODE_SPACE_NOT:		etk::cout<<ETK_BASH_COLOR_MAGENTA	<< (char*)"\\S" << ETK_BASH_COLOR_NORMAL;	break;
-			case REGEXP_OPCODE_WORD:			etk::cout<<ETK_BASH_COLOR_MAGENTA	<< (char*)"\\w" << ETK_BASH_COLOR_NORMAL;	break;
-			case REGEXP_OPCODE_WORD_NOT:		etk::cout<<ETK_BASH_COLOR_MAGENTA	<< (char*)"\\W" << ETK_BASH_COLOR_NORMAL;	break;
-			case '\n':							etk::cout<<ETK_BASH_COLOR_MAGENTA	<< (char*)"\\n" << ETK_BASH_COLOR_NORMAL;	break;
-			case '\t':							etk::cout<<ETK_BASH_COLOR_MAGENTA	<< (char*)"\\t" << ETK_BASH_COLOR_NORMAL;	break;
-			default:							etk::cout<< (char)(data[i]&0x00FF );											break;
-		}
-	}
-}
-char * etk::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 etk::GetLenOfPTheseElem(etk::VectorType<int16_t> &data, int32_t startPos)
-{
-	int32_t pos = startPos;
-	int32_t nbOpen = 0;
-	// special case of the (...) or | ==> we search '|' or ')'
-	if(		REGEXP_OPCODE_PTHESE_OUT	== data[pos]
-		||	REGEXP_OPCODE_PIPE			== data[pos]) {
-		return 0;
-	}
-	// find size ...
-	while (pos < (int32_t)data.Size() ) {
-		if(REGEXP_OPCODE_PTHESE_IN == data[pos]) {
-			// find a sub section : 
-			nbOpen++;
-		} else if(0 < nbOpen) {
-			if (REGEXP_OPCODE_PTHESE_OUT == data[pos])
-			{
-				nbOpen--;
-				if (0 > nbOpen) {
-					TK_ERROR("Error in the (...) find element at "<< pos);
-					return -1;
-				}
-			}
-		} else if(		REGEXP_OPCODE_PTHESE_OUT	== data[pos]
-					||	REGEXP_OPCODE_PIPE			== data[pos])
-		{
-			// Find the end of the (...)
-			// just return the size inside
-			int32_t sizeInside = pos - startPos;
-			if (0 >= sizeInside) {
-				TK_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 etk::GetLenOfPThese(etk::VectorType<int16_t> &data, int32_t startPos)
-{
-	int32_t pos = startPos;
-	int32_t nbOpen = 0;
-	// special case of the (...) or | ==> we search '|' or ')'
-	if( REGEXP_OPCODE_PTHESE_OUT == data[pos]) {
-		return 0;
-	} else if( REGEXP_OPCODE_PTHESE_IN == data[pos])
-	{
-		pos++;
-		// find size ...
-		while (pos < (int32_t)data.Size() ) {
-			if(REGEXP_OPCODE_PTHESE_IN == data[pos]) {
-				// find a sub section : 
-				nbOpen++;
-			} else if(0 < nbOpen) {
-				if (REGEXP_OPCODE_PTHESE_OUT == data[pos])
-				{
-					nbOpen--;
-					if (0 > nbOpen) {
-						TK_ERROR("Error in the (...) find element at "<< pos);
-						return -1;
-					}
-				}
-			} else if( REGEXP_OPCODE_PTHESE_OUT	== data[pos])
-			{
-				// Find the end of the (...)
-				// just return the size inside
-				int32_t sizeInside = pos - startPos-1;
-				if (0 >= sizeInside) {
-					TK_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 etk::GetLenOfBracket(etk::VectorType<int16_t> &data, int32_t startPos)
-{
-	int32_t pos = startPos;
-	// special case of the (...) or | ==> we search '|' or ')'
-	if( REGEXP_OPCODE_BRACKET_OUT == data[pos]) {
-		return 0;
-	} else if( REGEXP_OPCODE_BRACKET_IN == data[pos]) {
-		pos++;
-		// find size ...
-		while (pos < (int32_t)data.Size() ) {
-			if(REGEXP_OPCODE_BRACKET_OUT == data[pos]) {
-				// Find the end of the [...]
-				// just return the size inside
-				int32_t sizeInside = pos - startPos -1 ;
-				if (0 >= sizeInside) {
-					TK_ERROR("Error in the [...] no data at "<< pos-1);
-					return sizeInside;
-				} else {
-					return sizeInside;
-				}
-			} else if(		REGEXP_OPCODE_TO != data[pos]
-						&&	(		0 > data[pos]
-								||	0xFF < data[pos]) )
-			{
-				TK_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 etk::GetLenOfBrace(etk::VectorType<int16_t> &data, int32_t startPos)
-{
-	int32_t pos = startPos;
-	// special case of the (...) or | ==> we search '|' or ')'
-	if( REGEXP_OPCODE_BRACE_OUT == data[pos]) {
-		return 0;
-	} else if( REGEXP_OPCODE_BRACE_IN == data[pos]) {
-		pos++;
-		// find size ...
-		while (pos < (int32_t)data.Size() ) {
-			if(REGEXP_OPCODE_BRACE_OUT == data[pos]) {
-				// Find the end of the [...]
-				// just return the size inside
-				int32_t sizeInside = pos - startPos -1 ;
-				if (0 >= sizeInside) {
-					TK_ERROR("Error in the {...} no data at "<< pos-1);
-					return sizeInside;
-				} else {
-					return sizeInside;
-				}
-			} else if(		',' != data[pos]
-						&&	(		'0' > data[pos]
-								||	'9' < data[pos]) )
-			{
-				TK_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 etk::GetLenOfNormal(etk::VectorType<int16_t> &data, int32_t startPos)
-{
-	int32_t pos = startPos;
-
-	// find size ...
-	while (pos < (int32_t)data.Size() ) {
-		switch(data[pos])
-		{
-			case REGEXP_OPCODE_PTHESE_IN:
-			case REGEXP_OPCODE_PTHESE_OUT:
-			case REGEXP_OPCODE_BRACKET_IN:
-			case REGEXP_OPCODE_BRACKET_OUT:
-			case REGEXP_OPCODE_BRACE_IN:
-			case REGEXP_OPCODE_BRACE_OUT:
-			case REGEXP_OPCODE_TO:
-			case REGEXP_OPCODE_STAR:
-			case REGEXP_OPCODE_DOT:
-			case REGEXP_OPCODE_QUESTION:
-			case REGEXP_OPCODE_PLUS:
-			case REGEXP_OPCODE_PIPE:
-			case REGEXP_OPCODE_START_OF_LINE:
-			case REGEXP_OPCODE_END_OF_LINE:
-			case REGEXP_OPCODE_DIGIT:
-			case REGEXP_OPCODE_DIGIT_NOT:
-			case REGEXP_OPCODE_LETTER:
-			case REGEXP_OPCODE_LETTER_NOT:
-			case REGEXP_OPCODE_SPACE:
-			case REGEXP_OPCODE_SPACE_NOT:
-			case REGEXP_OPCODE_WORD:
-			case REGEXP_OPCODE_WORD_NOT:
-				{
-					// just return the size inside
-					int32_t sizeInside = pos - startPos;
-					if (0 >= sizeInside) {
-						TK_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 etk::ParseBrace(etk::VectorType<int16_t> &data, int32_t &min, int32_t &max)
-{
-	//TK_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 {
-			TK_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]) {
-			TK_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 {
-			TK_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) {
-		TK_ERROR("Minimum=" << min << " can not be < maximum=" << max );
-		return false;
-	}
-	return true;
-}
-
-

Sources/etk/Singleton.h

@@ -1,70 +0,0 @@
-/**
- *******************************************************************************
- * @file etk/Singleton.h
- * @brief ewol : singleton system class
- * @author Edouard DUPIN
- * @date 04/12/2010
- * @par Project
- * ewol TK
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#ifndef __ETK_SINGLETON_H__
-#define __ETK_SINGLETON_H__
-
-
-namespace etk {
-	template <typename T>
-	class Singleton
-	{
-		protected:
-			// Constructeur/destructeur
-			Singleton() { }
-			~Singleton() { /*std::cout << "destroying singleton." << std::endl;*/ }
-	
-		public:
-			// Interface publique
-			static T *Get()
-			{
-				if (NULL == _singleton)
-				{
-					_singleton = new T;
-				}
-	
-				return (static_cast<T*> (_singleton));
-			}
-	
-			static void Kill()
-			{
-				if (NULL != _singleton)
-				{
-					delete _singleton;
-					_singleton = NULL;
-				}
-			}
-	
-		private:
-		// Unique instance
-			static T *_singleton;
-	};
-	
-	template <typename T>
-			T *Singleton<T>::_singleton = NULL;
-}
-
-#endif
-
-

Sources/etk/Stream.cpp

@@ -1,31 +0,0 @@
-/**
- *******************************************************************************
- * @file etk/Stream.cpp
- * @brief Ewol Tool Kit : Basic etk::Stream for Log system ... (Sources)
- * @author Edouard DUPIN
- * @date 02/12/2011
- * @par Project
- * Ewol TK
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-#include <etk/Stream.h>
-
-etk::CCout etk::cout;
-etk::CEndl etk::endl;
-etk::CHex etk::hex;
-

Sources/etk/Stream.h

@@ -1,159 +0,0 @@
-/**
- *******************************************************************************
- * @file etk/Stream.h
- * @brief Ewol Tool Kit : Basic etk::Stream for Log system ... (header)
- * @author Edouard DUPIN
- * @date 02/12/2011
- * @par Project
- * Ewol TK
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-#ifndef __ETK_STREAM_H__
-#define __ETK_STREAM_H__
-
-#include <cstdio>
-#include <typeinfo>
-
-#if defined(__PLATFORM__Android)
-#	include <string.h>
-#	include <android/log.h>
-#	define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "====> EWOL", __VA_ARGS__))
-#	define LOGW(...) ((void)__android_log_print(ANDROID_LOG_WARN, "====> EWOL", __VA_ARGS__))
-#	define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, "====> EWOL", __VA_ARGS__))
-#endif
-
-namespace etk{
-	class CEndl{};
-	class CHex{};
-	class CCout{
-		private:
-			bool hex;
-		public:
-#if defined(__PLATFORM__Android)
-	private:
-		char m_tmpChar[2048];
-	public:
-		CCout(){
-			hex=false;
-			memset(m_tmpChar, 0, 2048*sizeof(char));
-		};
-		~CCout() { };
-		CCout& operator << (int t) {
-			char tmp[256];
-			sprintf(tmp,"%d", t);
-			strcat(m_tmpChar, tmp);
-			return *this;
-		}
-		CCout& operator << (unsigned int t) {
-			char tmp[256];
-			sprintf(tmp, "%d", t);
-			strcat(m_tmpChar, tmp);
-			return *this;
-		}
-		CCout& operator << (long t) {
-			char tmp[256];
-			sprintf(tmp, "%ld", t);
-			strcat(m_tmpChar, tmp);
-			return *this;
-		}
-		CCout& operator << (double t) {
-			char tmp[256];
-			sprintf(tmp, "%f", t);
-			strcat(m_tmpChar, tmp);
-			return *this;
-		}
-		CCout& operator << (float t) {
-			char tmp[256];
-			sprintf(tmp, "%f", t);
-			strcat(m_tmpChar, tmp);
-			return *this;
-		}
-		CCout& operator << (char * t) {
-			char tmp[256];
-			sprintf(tmp, "%s", t);
-			strcat(m_tmpChar, tmp);
-			return *this;
-		}
-		CCout& operator << (const char * t) {
-			char tmp[256];
-			sprintf(tmp, "%s", t);
-			strcat(m_tmpChar, tmp);
-			return *this;
-		}
-		CCout& operator << (char t) {
-			char tmp[256];
-			sprintf(tmp, "%c", t);
-			strcat(m_tmpChar, tmp);
-			return *this;
-		}
-		CCout& operator << (etk::CEndl t) {
-			strcat(m_tmpChar, "\n");
-			LOGI("%s", m_tmpChar);
-			memset(m_tmpChar, 0, 2048*sizeof(char));
-			return *this;
-		}
-#else
-		CCout(){
-			hex=false;
-		};
-		
-		~CCout() { };
-		CCout& operator << (int t) {
-			printf("%d", t);
-			return *this;
-		}
-		CCout& operator << (unsigned int t) {
-			printf("%d", t);
-			return *this;
-		}
-		CCout& operator << (long t) {
-			printf("%ld", t);
-			return *this;
-		}
-		CCout& operator << (double t) {
-			printf("%f", t);
-			return *this;
-		}
-		CCout& operator << (float t) {
-			printf("%f", t);
-			return *this;
-		}
-		CCout& operator << (char * t) {
-			printf("%s", t);
-			return *this;
-		}
-		CCout& operator << (const char * t) {
-			printf("%s", t);
-			return *this;
-		}
-		CCout& operator << (char t) {
-			printf("%c", t);
-			return *this;
-		}
-		CCout& operator << (etk::CEndl t) {
-			printf("\n");
-			return *this;
-		}
-#endif
-	};
-	extern etk::CCout cout;
-	extern etk::CEndl endl;
-	extern etk::CHex hex;
-}
-#endif
-

Sources/etk/String.cpp

@@ -1,724 +0,0 @@
-/**
- *******************************************************************************
- * @file etk/String.cpp
- * @brief Ewol Tool Kit : normal sting management... (sources)
- * @author Edouard DUPIN
- * @date 26/01/2011
- * @par Project
- * Ewol TK
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#include <etk/String.h>
-#include <etk/Memory.h>
-
-
-#undef __class__
-#define __class__	"etk::String"
-
-etk::CCout& etk::operator <<(etk::CCout &os, const etk::String &obj)
-{
-	os << (char*)&obj.m_data[0];
-	return os;
-}
-
-/**
- * @brief 
- *
- * @param[in,out] 
- *
- * @return 
- *
- */
-etk::String::~String(void)
-{
-	m_data.Clear();
-}
-
-
-/**
- * @brief 
- *
- * @param[in,out] 
- *
- * @return 
- *
- */
-etk::String::String(void)
-{
-	//TK_INFO("new etk::String()");
-	m_data.Clear();
-	m_data.PushBack('\0');
-}
-
-
-/**
- * @brief 
- *
- * @param[in,out] 
- *
- * @return 
- *
- */
-etk::String::String(const char myInput)
-{
-	m_data.Clear();
-	m_data.PushBack(myInput);
-	m_data.PushBack('\0');
-}
-
-
-/**
- * @brief 
- *
- * @param[in,out] 
- *
- * @return 
- *
- */
-etk::String::String(const char* inputData, int32_t len)
-{
-	m_data.Clear();
-	m_data.PushBack('\0');
-	Set(inputData, len);
-}
-
-void etk::String::Set(const char * inputData, int32_t len)
-{
-	if (NULL == inputData) {
-		// nothing to add ... 
-		return;
-	}
-	// 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 
- *
- */
-etk::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 
- *
- */
-etk::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);
-}
-
-etk::String::String(const etk::String &etkS)
-{
-	//etk_INFO("Constructeur de recopie");
-	m_data = etkS.m_data;
-}
-
-
-/**
- * @brief 
- *
- * @param[in,out] 
- *
- * @return 
- *
- */
-const etk::String& etk::String::operator= (const etk::String &etkS )
-{
-	//TK_INFO("OPERATOR de recopie");
-	if( this != &etkS ) // avoid copy to itself
-	{
-		m_data = etkS.m_data;
-	}
-	return *this;
-}
-
-
-/**
- * @brief 
- *
- * @param[in,out] 
- *
- * @return 
- *
- */
-const etk::String& etk::String::operator= (const char * inputData)
-{
-	m_data.Clear();
-	m_data.PushBack('\0');
-	if (NULL == inputData) {
-		return *this;
-	}
-	// 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 etk::String& etk::String::operator= (etk::VectorType<int8_t> inputData)
-{
-	m_data = inputData;
-	if (m_data.Size()>0) {
-		if (m_data[m_data.Size()-1] != '\0') {
-			m_data.PushBack('\0');
-		}
-	}
-	//TK_DEBUG("m_dataLen="<<m_dataLen << " m_dataLenUTF8="<<m_dataLenUTF8 << " description=" << m_data);
-	return *this;
-}
-
-
-/**
- * @brief 
- *
- * @param[in,out] 
- *
- * @return 
- *
- */
-bool etk::String::operator== (const etk::String& etkS) const
-{
-	if( this != &etkS ) {
-		if (etkS.m_data.Size() != m_data.Size()) {
-			//TK_DEBUG(" not the same size : " << etkS.m_data.Size() << "!=" << m_data.Size());
-			return false;
-		}
-		for (int32_t iii= 0; iii<m_data.Size(); iii++) {
-			//TK_DEBUG("     check : " << etkS.m_data[iii] << "!=" << m_data[iii]);
-			if (etkS.m_data[iii]!= m_data[iii]){
-				return false;
-			}
-		}
-		return true;
-	}
-	return true;
-}
-
-
-/**
- * @brief 
- *
- * @param[in,out] 
- *
- * @return 
- *
- */
-bool etk::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 etk::String::operator!= (const etk::String& etkS) const
-{
-	return !(*this == etkS);
-}
-
-
-/**
- * @brief 
- *
- * @param[in,out] 
- *
- * @return 
- *
- */
-bool etk::String::operator!= (const char * inputData) const
-{
-	return !(*this == inputData);
-}
-
-
-/**
- * @brief 
- *
- * @param[in,out] 
- *
- * @return 
- *
- */
-const etk::String& etk::String::operator+= (const etk::String &etkS)
-{
-	if (0 < etkS.Size()) {
-		// remove the last '\0'
-		m_data.PopBack();
-		// copy the data ...
-		m_data += etkS.m_data;
-		// This previous include the \0 in case of the 2 string are different...
-		if( this == &etkS ) {
-			// add the removed end string
-			m_data.PushBack('\0');
-		}
-	}
-	return *this;
-}
-
-
-/**
- * @brief 
- *
- * @param[in,out] 
- *
- * @return 
- *
- */
-const etk::String& etk::String::operator+= (const char * inputData)
-{
-	//TK_INFO("        string(arg) : \"" << inputData << "\"");
-	//TK_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 
- *
- */
-etk::String etk::String::operator+ (const etk::String &etkS)
-{
-	etk::String temp;
-	//TK_INFO("        string(arg) : \"" << etkS.m_data << "\"");
-	//TK_INFO("        string(direct) : \"" << m_data << "\"");
-	temp += *this;
-	temp += etkS;
-	return temp;
-}
-
-
-/**
- * @brief 
- *
- * @param[in,out] 
- *
- * @return 
- *
- */
-etk::String etk::String::operator+ (const char * inputData)
-{
-	etk::String temp;
-	//TK_INFO("        string(arg) : \"" << inputData << "\"");
-	//TK_INFO("        string(direct) : \"" << m_data << "\"");
-	temp += *this;
-	temp += inputData;
-	return temp;
-}
-
-
-
-
-
-/**
- * @brief 
- *
- * @param[in,out] 
- *
- * @return 
- *
- */
-bool etk::String::IsEmpty(void) const
-{
-	if(1 >= m_data.Size() ) {
-		return true;
-	} else {
-		return false;
-	}
-}
-
-
-/**
- * @brief 
- *
- * @param[in,out] 
- *
- * @return 
- *
- */
-int32_t etk::String::Size(void) const
-{
-	if (m_data.Size() == 0) {
-		return 0;
-	} else {
-		return m_data.Size() - 1;
-	}
-}
-
-
-/**
- * @brief 
- *
- * @param[in,out] 
- *
- * @return 
- *
- */
-void etk::String::Add(int32_t currentID, const char* inputData)
-{
-	// get the input lenght
-	int32_t len = strlen(inputData);
-	if (0 == len) {
-		TK_WARNING("no data to add on the current string");
-		return;
-	} else if (currentID < 0) {
-		TK_WARNING("Curent ID(" << currentID << ") < 0   ==> Add at the start");
-		currentID = 0;
-	} else if (currentID > Size() ) {
-		TK_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 etk::String::Remove(int32_t currentID, int32_t len)
-{
-	if (0 >= len) {
-		TK_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 etk::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 etk::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 etk::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
- *
- */
-etk::String etk::String::Extract(int32_t posStart, int32_t posEnd)
-{
-	etk::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
- *
- */
-etk::VectorType<int8_t> etk::String::GetVector(void)
-{
-	etk::VectorType<int8_t> out = m_data;
-	out.PopBack();
-	return out;
-}
-
-
-
-/**
- * @brief Unitary test for the string system
- *
- * @param ---
- *
- * @return ---
- *
- */
-void etk::TestUntaire_String(void)
-{
-	TK_WARNING("*********************************************************");
-	TK_WARNING("**  Test Unitaire 'etkString'  (START)");
-	TK_WARNING("*********************************************************");
-	
-	int32_t iddd = 0;
-	etk::String * monString = new etk::String();
-	TK_INFO("phase : " << iddd++ << " : \"" << *monString << "\"");
-	delete(monString);
-	
-	monString = new etk::String("test de direct data");
-	TK_INFO("phase : " << iddd++ << " : \"" << *monString << "\"");
-	delete(monString);
-	
-	monString = new etk::String("test de direct data", 7);
-	TK_INFO("phase : " << iddd++ << " : \"" << *monString << "\"");
-	delete(monString);
-	
-	int32_t testId = -6789;
-	monString = new etk::String(testId);
-	TK_INFO("phase : " << iddd++ << " : \"" << *monString << "\"");
-	delete(monString);
-	
-	uint32_t testId2 = 12345;
-	monString = new etk::String((unsigned int)testId2);
-	TK_INFO("phase : " << iddd++ << " : \"" << *monString << "\"");
-	delete(monString);
-	
-	etk::String plop = "otherString";
-	monString = new etk::String(plop);
-	TK_INFO("phase : " << iddd++ << " : \"" << *monString << "\"");
-	delete(monString);
-	
-	
-	etk::String s1 = "test de base ...";
-	s1 += s1;
-	TK_INFO("phase : " << iddd++ << " : \"" << s1 << "\"");
-	s1 += " plop 2 ";
-	TK_INFO("phase : " << iddd++ << " : \"" << s1 << "\"");
-	s1 += plop;
-	TK_INFO("phase : " << iddd++ << " : \"" << s1 << "\"");
-	s1 = plop;
-	TK_INFO("phase : " << iddd++ << " : \"" << s1 << "\"");
-	s1 = "test direct 44";
-	TK_INFO("phase : " << iddd++ << " : \"" << s1 << "\"");
-	etk::VectorType<int8_t> vb1;
-	vb1.PushBack('v');
-	vb1.PushBack('b');
-	vb1.PushBack('1');
-	s1 = vb1;
-	TK_INFO("phase : " << iddd++ << " : \"" << s1 << "\"");
-	vb1.Clear();
-	vb1.PushBack('v');
-	vb1.PushBack('b');
-	vb1.PushBack('2');
-	vb1.PushBack('\0');
-	s1 = vb1;
-	TK_INFO("phase : " << iddd++ << " : \"" << s1 << "\"");
-	
-	if (s1 == "vb2") {
-		TK_INFO("phase : " << iddd++ << " : == OK");
-	} else {
-		TK_ERROR("phase : " << iddd++ << " : == ERROR");
-	}
-	
-	
-	if (s1 == "vb3") {
-		TK_ERROR("phase : " << iddd++ << " : == ERROR");
-	} else {
-		TK_INFO("phase : " << iddd++ << " : == OK");
-	}
-	
-	
-	if (s1 != "vb3") {
-		TK_INFO("phase : " << iddd++ << " : == OK");
-	} else {
-		TK_ERROR("phase : " << iddd++ << " : == ERROR");
-	}
-	
-	
-	if (s1 != "vb2") {
-		TK_ERROR("phase : " << iddd++ << " : == ERROR");
-	} else {
-		TK_INFO("phase : " << iddd++ << " : == OK");
-	}
-	
-	
-	etk::String s2 = "vb2";
-	etk::String s3 = "vb3";
-	
-	if (s1 == s2) {
-		TK_INFO("phase : " << iddd++ << " : == OK");
-	} else {
-		TK_ERROR("phase : " << iddd++ << " : == ERROR");
-	}
-	
-	
-	if (s1 == s3) {
-		TK_ERROR("phase : " << iddd++ << " : == ERROR");
-	} else {
-		TK_INFO("phase : " << iddd++ << " : == OK");
-	}
-	
-	
-	if (s1 != s3) {
-		TK_INFO("phase : " << iddd++ << " : == OK");
-	} else {
-		TK_ERROR("phase : " << iddd++ << " : == ERROR");
-	}
-	
-	
-	if (s1 != s2) {
-		TK_ERROR("phase : " << iddd++ << " : == ERROR");
-	} else {
-		TK_INFO("phase : " << iddd++ << " : == OK");
-	}
-	TK_WARNING("*********************************************************");
-	TK_WARNING("**  Test Unitaire 'etkString'  (STOP)");
-	TK_WARNING("*********************************************************");
-}
-

Sources/etk/String.h

@@ -1,93 +0,0 @@
-/**
- *******************************************************************************
- * @file etk/String.h
- * @brief Ewol Tool Kit : normal sting management... (header)
- * @author Edouard DUPIN
- * @date 26/01/2011
- * @par Project
- * Ewol TK
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#ifndef __ETK_STRING_H__
-#define __ETK_STRING_H__
-
-#include <etk/Stream.h>
-#include <etk/VectorType.h>
-
-namespace etk
-{
-	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 etk::String &etkS);
-			// destructor : 
-			~String(void);
-			
-			const etk::String& operator= (const etk::String &etkS );	// assigment
-			const etk::String& operator= (const char * inputData);
-			const etk::String& operator= (etk::VectorType<int8_t> inputData);
-			bool  operator== (const etk::String& etkS) const;			// == operator
-			bool  operator== (const char * inputData) const;
-			bool  operator!= (const etk::String& etkS) const;			// != operator
-			bool  operator!= (const char * inputData) const;
-			const etk::String& operator+= (const etk::String &etkS);	// += operator
-			const etk::String& operator+= (const char * inputData);
-			etk::String operator+ (const etk::String &etkS);			// + operator
-			etk::String operator+ (const char * inputData);
-			//operator const char *()
-			friend etk::CCout& operator <<( etk::CCout &os,const etk::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);
-	
-			etk::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);
-			etk::String   Extract(int32_t posStart=0, int32_t posEnd=0x7FFFFFFF);
-	
-		private :
-			etk::VectorType<int8_t> m_data;
-	};
-
-	void TestUntaire_String(void);
-	
-	etk::CCout& operator <<(etk::CCout &os, const etk::String &obj);
-	
-}
-
-
-
-
-
-#endif
-

Sources/etk/Types.h

@@ -1,115 +0,0 @@
-/**
- *******************************************************************************
- * @file etk/Types.h
- * @brief Ewol Tool Kit : generique define type
- * @author Edouard DUPIN
- * @date 08/06/2010
- * @par Project
- * Ewol TK
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#ifndef __ETK_TYPES_H__
-#define __ETK_TYPES_H__
-
-// includes system, malloc, EXIT_SUCCESS
-#include <stdlib.h>
-// includes fopen, fwrite, fseek, ftell
-#include <stdio.h>
-#include <stdarg.h>
-#include <string.h>
-#include <assert.h>
-
-
-#ifndef __int8_t_defined
-#   define __int8_t_defined
-    typedef   signed char                    int8_t;
-    typedef   signed short int               int16_t;
-    typedef   int                            int32_t;
-    typedef   signed long long int           int64_t;
-#endif
-
-#ifndef __uint8_t_defined
-#   define __uint8_t_defined
-	typedef unsigned char                   uint8_t;
-	typedef unsigned short int              uint16_t;
-	typedef unsigned int                    uint32_t;
-#	if __WORDSIZE == 64
-		typedef unsigned long int               uint64_t;
-#	else
-		typedef unsigned long long int          uint64_t;
-#	endif
-#endif
-typedef int32_t       uniChar_t;
-
-
-
-
-#define etk_min(elemA, elemB)               ((elemA)<(elemB)) ? (elemA) : (elemB)
-#define etk_max(elemA, elemB)               ((elemA)<(elemB)) ? (elemB) : (elemA)
-#define etk_avg(minimim, elem, maximum)     ((minimim)>(elem)) ? (minimim) : ((maximum)<(elem)) ? (maximum) : (elem)
-
-extern "C"
-{
-	#ifdef EWOL_PECISION_DOUBLE
-		typedef double       etkFloat_t;
-		#define oglTypeFloat_t   GL_DOUBLE
-	#else
-		typedef float        etkFloat_t;
-		#define oglTypeFloat_t   GL_FLOAT
-	#endif
-	
-	struct etkPointAndPositionDouble{
-		etkFloat_t x;
-		etkFloat_t y;
-	};
-	
-	struct etkPointAndPositionInt{
-		int32_t x;
-		int32_t y;
-	};
-	
-	typedef etkPointAndPositionDouble     point_ts;
-	typedef etkPointAndPositionDouble     position_ts;
-	typedef etkPointAndPositionDouble     size_ts;
-	typedef etkPointAndPositionInt        intSize_ts;
-	
-	typedef struct {
-		etkFloat_t x;
-		etkFloat_t y;
-		etkFloat_t z;
-	}coord3D_ts;
-	typedef struct {
-		etkFloat_t x;
-		etkFloat_t y;
-	}coord2D_ts;
-	typedef struct {
-		etkFloat_t u;
-		etkFloat_t v;
-	}texCoord_ts;
-	typedef struct {
-		etkFloat_t red;
-		etkFloat_t green;
-		etkFloat_t blue;
-		etkFloat_t alpha;
-	}color_ts;
-}
-
-
-
-#endif
-
-

Sources/etk/Vector.h

@@ -1,509 +0,0 @@
-/**
- *******************************************************************************
- * @file etk/Vector.h
- * @brief Ewol Tool Kit : Basic etk::Vector (template)
- * @author Edouard DUPIN
- * @date 07/04/2011
- * @par Project
- * Ewol TK
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#ifndef __ETK_VECTOR_H__
-#define __ETK_VECTOR_H__
-
-#include <etk/Type.h>
-#include <etk/Memory.h>
-
-#undef __class__
-#define __class__	"etk::Vector"
-
-/**
- * @brief etkVector 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 rtk
-{
-
-template<class T, int32_t INC=0> class Vector
-{
-	public:
-		class Iterator
-		{
-			// Private data : 
-			private:
-				int32_t			  m_current;		// curent Id on the vector
-				etk::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_etkVector->Size() )
-					{
-						return true;
-					} else {
-						return false;
-					}
-				}
-				/**
-				 * @brief Incremental operator
-				 * @return Reference on the current iterator incremented
-				 */
-				Iterator& operator++ ()
-				{
-					if(		NULL != m_etkVector
-						&&	m_current < m_etkVector->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
-				{
-					TK_CHECK_INOUT(m_current >= 0 && m_current < m_etkVector->Size());
-					return &m_etkVector->Get(m_current);
-				}
-				/**
-				 * @brief 
-				 *
-				 * @param[in,out] ---
-				 *
-				 * @return ---
-				 *
-				 */
-				T & operator* () const
-				{
-					TK_CHECK_INOUT(m_current >= 0 && m_current < m_etkVector->Size());
-					return m_etkVector->Get(m_current);
-				}
-			private:
-				/**
-				 * @brief 
-				 *
-				 * @param[in,out] ---
-				 *
-				 * @return ---
-				 *
-				 */
-				Iterator(etk::Vector<T> * myVector, int pos):
-					m_current(pos),
-					m_Vector(myVector)
-				{
-					// nothing to do ...
-				}
-				friend class etk::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 etk::Vector<T> & myVector):
-		m_size(myVector.m_size),
-		m_count(myVector.m_count),
-		m_data(NULL)
-	{
-		int32_t i;
-		ETK_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 etk::Vector<T> & etkVector)
-	{
-		int32_t i;
-		this->~etkVector(); 
-		m_size = etkVector.m_size;
-		m_count = etkVector.m_count;
-		TK_MALLOC_CAST(m_data, m_size, T, reinterpret_cast<T*>);
-		for(i=0; i<m_count; i++) {
-			new (&m_data[i]) T(etkVector[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;
-			ETK_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) {
-			ETK_FREE(m_data);
-		}
-	}
-};
-
-}
-
-#undef __class__
-#define __class__	NULL
-
-#endif
-

Sources/etk/VectorType.h

@@ -1,672 +0,0 @@
-/**
- *******************************************************************************
- * @file etk/VectorType.h
- * @brief Ewol Tool Kit : Basic VectorType for direct data insertion (template)
- * @author Edouard DUPIN
- * @date 07/04/2011
- * @par Project
- * Ewol TK
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#ifndef __ETK_VECTOR_TYPE_H__
-#define __ETK_VECTOR_TYPE_H__
-
-#include <etk/Types.h>
-#include <etk/DebugInternal.h>
-#include <etk/Memory.h>
-
-#undef __class__
-#define __class__	"etk::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 etk
-{
-
-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 etkVector
-				 */
-				Iterator():
-					m_current(-1),
-					m_VectorType(NULL)
-				{
-					// nothing to do ...
-				}
-				/**
-				 * @brief Recopy constructor on a specific etkVector.
-				 * @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 etkVector 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
-				{
-					TK_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
-				{
-					TK_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 etk::VectorType<MY_TYPE> & Evb)
-		{
-			m_allocated = Evb.m_allocated;
-			m_size      = Evb.m_size;
-			m_increment = Evb.m_increment;
-			m_data      = NULL;
-			//TK_DEBUG("USE Specific vector allocator ... Evb.m_size=" << Evb.m_size << " Evb.m_increment=" << Evb.m_increment);
-			// allocate all same data
-			ETK_MALLOC(m_data, m_allocated, MY_TYPE);
-			TK_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) {
-				ETK_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 etk::VectorType<MY_TYPE> & Evb)
-		{
-			//TK_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) {
-					ETK_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
-				ETK_MALLOC(m_data, m_allocated, MY_TYPE);
-				TK_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 etk::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) {
-				TK_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) {
-				TK_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) {
-				TK_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) {
-				TK_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) {
-				TK_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 ...
-				ETK_REALLOC(m_data, m_size, MY_TYPE);
-			}
-			// Check result with assert : 
-			TK_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)
-				ETK_MALLOC(m_data, requestSize, MY_TYPE);
-			} else {
-				// move datas
-				ETK_REALLOC(m_data, requestSize, MY_TYPE);
-			}
-			// Check result with assert : 
-			TK_ASSERT(NULL!=m_data, "Error in data allocation");
-			// set the new allocation size
-			m_allocated = requestSize;
-		}
-};
-}
-
-#undef __class__
-#define __class__	NULL
-
-#endif
-

Sources/ewol/Android.mk

@@ -1,35 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE := ewol
-LOCAL_STATIC_LIBRARIES := libzip libpng
-
-LOCAL_C_INCLUDES := $(LOCAL_PATH)/../../Sources $(LOCAL_PATH)/../libzip/ $(LOCAL_PATH)/../libpng/
-
-LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/../../Sources
-LOCAL_EXPORT_LDLIBS := -lGLESv1_CM -ldl -llog -lz
-
-LOCAL_CFLAGS := -D__PLATFORM__Android \
-                -Wno-write-strings \
-                -DETK_DEBUG_LEVEL=3 \
-                -DEWOL_DEBUG_LEVEL=3 \
-                -DEWOL_VERSION_TAG_NAME="\"UNKNOW-debug\"" \
-                -DVERSION_BUILD_TIME="\"pasd_heure\"" \
-                -DDATA_IN_APK \
-
-# load the common sources file of the platform
-include $(LOCAL_PATH)/file.mk
-
-LOCAL_SRC_FILES := \
-	../../Sources/base/guiAndroid.cpp \
-	$(addprefix ../../Sources/, $(FILE_LIST))
-
-#for freetype : https://github.com/cdave1/freetype2-android
-
-# Ewol Test Software :
-LOCAL_LDLIBS := -lGLESv1_CM -ldl -llog -lz
-
-include $(BUILD_STATIC_LIBRARY)
-
-

Sources/ewol/Debug.cpp

@@ -1,28 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/Debug.h
- * @brief Ewol : log wrapper (Sources)
- * @author Edouard DUPIN
- * @date 19/10/2010
- * @par Project
- * Ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-#include <ewol/Debug.h>
-
-const char * ewolLibName = "ewol    ";

Sources/ewol/Debug.h

@@ -1,74 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/Debug.h
- * @brief Ewol : log wrapper (header)
- * @author Edouard DUPIN
- * @date 19/10/2010
- * @par Project
- * Ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#ifndef __EWOL_DEBUG_H__
-#define __EWOL_DEBUG_H__
-
-#include <etk/Types.h>
-#include <etk/Debug.h>
-
-extern const char * ewolLibName;
-
-#define EWOL_CRITICAL(data)         ETK_CRITICAL(ewolLibName, data)
-// General 
-#if EWOL_DEBUG_LEVEL > 0
-#	define EWOL_WARNING(data)       ETK_WARNING(ewolLibName, data)
-#	define EWOL_ERROR(data)         ETK_ERROR(ewolLibName, data)
-#else
-#	define EWOL_WARNING(data)       do {}while(0)
-#	define EWOL_ERROR(data)         do {}while(0)
-#endif
-
-#if EWOL_DEBUG_LEVEL > 1
-#	define EWOL_INFO(data)          ETK_INFO(ewolLibName, data)
-#else
-#	define EWOL_INFO(data)          do {}while(0)
-#endif
-
-#if EWOL_DEBUG_LEVEL > 2
-#	define EWOL_DEBUG(data)         ETK_DEBUG(ewolLibName, data)
-#else
-#	define EWOL_DEBUG(data)         do {}while(0)
-#endif
-
-#if EWOL_DEBUG_LEVEL > 3
-#	define EWOL_VERBOSE(data)         ETK_VERBOSE(ewolLibName, data)
-#else
-#	define EWOL_VERBOSE(data)         do {}while(0)
-#endif
-
-#define EWOL_TODO(data)             EWOL_WARNING("TODO : " << data)
-
-#define EWOL_ASSERT(cond, data)     ETK_ASSERT(ewolLibName, cond, data)
-
-#if EWOL_DEBUG_LEVEL > 1
-#	define EWOL_CHECK_INOUT(cond)   ETK_CHECK_INOUT_ASSERT(ewolLibName, cond)
-#elif EWOL_DEBUG_LEVEL > 0
-#	define EWOL_CHECK_INOUT(cond)   ETK_CHECK_INOUT_WARNING(ewolLibName, cond)
-#else
-#	define EWOL_CHECK_INOUT(cond)   do { } while (0)
-#endif
-
-#endif
-

Sources/ewol/Font.h

@@ -1,109 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/Font.h
- * @brief ewol Font system (header)
- * @author Edouard DUPIN
- * @date 29/10/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#ifndef __EWOL_FONT_H__
-#define __EWOL_FONT_H__
-
-#include <etk/Types.h>
-#include <ewol/Debug.h>
-#include <etk/File.h>
-
-
-namespace ewol
-{
-	// TODO : Create a subNameSpace:
-	/*
-	namespace font {
-		// set default folder name of the font : 
-		void        SetFolder(etk::String folderName);
-		void        SetDefault(etk::String fontName, int32_t size);
-		// unload all font loaded
-		void        Init(void);
-		void        UnInit(void);
-		// load the fonts...
-		int32_t     Load(etk::String fontName, int32_t size); // return ID of font
-		int32_t     GetDefaultId(void);
-		void        Unload(int32_t id);
-		
-		// get the size of a long string in UTF8 (note that \n and \r represent unknown char...)
-		int32_t     GetWidth(int32_t fontID, const uniChar_t * unicodeString);
-		int32_t     GetWidth(int32_t fontID, const char *      utf8String);
-		int32_t     GetHeight(int32_t fontID);
-		
-		
-		void        DrawText(int32_t                        fontID,
-		                     coord2D_ts &                   drawPosition,
-		                     const char *                   utf8String,
-		                     uint32_t &                     fontTextureId,
-		                     etk::VectorType<coord2D_ts> &  coord,
-		                     etk::VectorType<texCoord_ts> & coordTex);
-		
-		void        DrawText(int32_t                        fontID,
-		                     coord2D_ts &                   drawPosition,
-		                     const uniChar_t *              unicodeString,
-		                     uint32_t &                     fontTextureId,
-		                     etk::VectorType<coord2D_ts> &  coord,
-		                     etk::VectorType<texCoord_ts> & coordTex);
-		
-		int32_t Load(etk::File fontFileName);
-		void    DrawText(etkFloat_t x, etkFloat_t y, const char * myString);
-	};
-	*/
-	// set default folder name of the font : 
-	void        SetFontFolder(etk::String folderName);
-	void        SetDefaultFont(etk::String fontName, int32_t size);
-	// unload all font loaded
-	void        InitFont(void);
-	void        UnInitFont(void);
-	// load the fonts...
-	int32_t     LoadFont(etk::String fontName, int32_t size); // return ID of font
-	int32_t     GetDefaultFontId(void);
-	void        UnloadFont(int32_t id);
-	
-	// get the size of a long string in UTF8 (note that \n and \r represent unknown char...)
-	int32_t     GetWidth(int32_t fontID, const uniChar_t * unicodeString);
-	int32_t     GetWidth(int32_t fontID, const char *      utf8String);
-	int32_t     GetHeight(int32_t fontID);
-	
-	
-	void        DrawText(int32_t                        fontID,
-	                     coord2D_ts &                   drawPosition,
-	                     const char *                   utf8String,
-	                     uint32_t &                     fontTextureId,
-	                     etk::VectorType<coord2D_ts> &  coord,
-	                     etk::VectorType<texCoord_ts> & coordTex);
-	
-	void        DrawText(int32_t                        fontID,
-	                     coord2D_ts &                   drawPosition,
-	                     const uniChar_t *              unicodeString,
-	                     uint32_t &                     fontTextureId,
-	                     etk::VectorType<coord2D_ts> &  coord,
-	                     etk::VectorType<texCoord_ts> & coordTex);
-	
-	int32_t LoadFont(etk::File fontFileName);
-	void    DrawText(etkFloat_t x, etkFloat_t y, const char * myString);
-};
-
-#endif
-

Sources/ewol/FontBitmap.cpp

@@ -1,543 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/FontBitmap.cpp
- * @brief ewol Font system (sources)
- * @author Edouard DUPIN
- * @date 29/10/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-#include <ewol/Font.h>
-#include <ewol/Texture.h>
-#include <etk/VectorType.h>
-#include <importgl.h>
-
-
-#undef __class__
-#define __class__	"ewol::FontBitmap"
-
-extern "C"
-{
-	typedef struct {
-		uniChar_t   unicodeCharVal;
-		int32_t     width;
-		texCoord_ts posStart;
-		texCoord_ts posStop;
-		etkFloat_t ratio;
-	}UTF8Element_ts;
-}
-
-
-namespace ewol
-{
-	class EbtFont
-	{
-		public:
-			EbtFont(etk::File newFile, etk::String fontName, int32_t size)
-			{
-				m_loadedOK = false;
-				m_filename = newFile;
-				m_fontName = fontName;
-				m_size = size;
-				m_elements.Clear();
-				for (int32_t iii=0x0; iii<0x81; iii++) {
-					UTF8Element_ts tmpchar;
-					tmpchar.unicodeCharVal = iii;
-					tmpchar.width = 0;
-					tmpchar.posStart.u = 0;
-					tmpchar.posStart.v = 0;
-					tmpchar.posStop.u = 0;
-					tmpchar.posStop.v = 0;
-					tmpchar.ratio = 0;
-					m_elements.PushBack(tmpchar);
-				}
-				if(false == m_filename.fOpenRead()) {
-					EWOL_ERROR("Can not Open the file named=\"" << m_filename << "\"");
-					return;
-				}
-				// load all element of the file ...
-				char elementLine[2048];
-				int32_t lineID=1;
-				while (NULL != m_filename.fGets(elementLine, 2048) )
-				{
-					//EWOL_DEBUG(" Read file Line : " << elementLine);
-					if (    '\n' != elementLine[0] // EOL
-					     && '\0' != elementLine[0] // EOF
-					     && '#'  != elementLine[0] // Comment line
-					   )
-					{
-						if (0 == strncmp("name:", elementLine, 5)) {
-							char extractString[256] = "";
-							sscanf(elementLine, "name:%s", extractString);
-							m_fontName = extractString;
-							EWOL_INFO("Find font named : \"" << m_fontName << "\"");
-						} else if (0 == strncmp("source:", elementLine, 7)) {
-							char extractString[256] = "";
-							sscanf(elementLine, "source:%s", extractString);
-							m_bitmapName = extractString;
-						} else if (0 == strncmp("0x00", elementLine, 4)) {
-							int32_t GlyphPositionX;
-							int32_t GlyphPositionY;
-							int32_t GlyphSizeX;
-							int32_t GlyphSizeY;
-							sscanf(elementLine, "0x00 (%d,%d) (%d,%d)", &GlyphPositionX, &GlyphPositionY, &GlyphSizeX, &GlyphSizeY);
-							ClearAll(GlyphPositionX, GlyphPositionY, GlyphSizeX, GlyphSizeY);
-						} else if (0 == strncmp("0x", elementLine, 2)) {
-							uint32_t utf8Value;
-							int32_t GlyphPositionX;
-							int32_t GlyphPositionY;
-							int32_t GlyphSizeX;
-							int32_t GlyphSizeY;
-							sscanf(elementLine, "0x%x (%d,%d) (%d,%d)", &utf8Value, &GlyphPositionX, &GlyphPositionY, &GlyphSizeX, &GlyphSizeY);
-							SetGlyphID(utf8Value, lineID, GlyphPositionX, GlyphPositionY, GlyphSizeX, GlyphSizeY);
-						} else {
-							EWOL_ERROR("error when parsing the line : " << lineID << "\"" << elementLine << "\"");
-						}
-					}
-					lineID++;
-				}
-				// close the file at end of reading...
-				m_filename.fClose();
-				// Load Bitmap : 
-				etk::String bitmapRealFile = m_filename.GetFolder() + "/" + m_bitmapName;
-				EWOL_INFO("load text font image : \"" << bitmapRealFile << "\"");
-				etk::File tmpFile(bitmapRealFile, m_filename.GetTypeAccess());
-				m_textureId = ewol::LoadTexture(tmpFile);
-				m_textureLoaded = true;
-				m_loadedOK = true;
-			};
-			
-			~EbtFont(void)
-			{
-				if (true == m_textureLoaded) {
-					ewol::UnLoadTexture(m_textureId);
-				}
-			};
-			bool loadedOK(void)
-			{
-				return m_loadedOK;
-			};
-		private:
-			void ClearAll(int32_t x, int32_t y, int32_t w, int32_t h)
-			{
-				EWOL_DEBUG("Find default font glyph : (" << x << "," << y << ") (" << w << "," << h << ") ");
-				for (int32_t iii=0; iii< 0x80; iii++) {
-					m_elements[iii].posStart.u = (etkFloat_t)x / 512.0;
-					m_elements[iii].posStart.v = (etkFloat_t)y / 512.0;
-					m_elements[iii].posStop.u = (etkFloat_t)(x+w) / 512.0;
-					m_elements[iii].posStop.v = (etkFloat_t)(y+h) / 512.0;
-					m_elements[iii].ratio = (etkFloat_t)w/(etkFloat_t)h;
-					m_elements[iii].width = m_size * 1.48 * m_elements[iii].ratio;
-				}
-			};
-			void SetGlyphID(int32_t utf8Value, int32_t lineID, int32_t x, int32_t y, int32_t w, int32_t h)
-			{
-				EWOL_DEBUG("Add font glyph : "<< utf8Value << " (" << x << "," << y << ") (" << w << "," << h << ") ");
-				if (utf8Value < 0x80) {
-					m_elements[utf8Value].posStart.u = (etkFloat_t)x / 512.0;
-					m_elements[utf8Value].posStart.v = (etkFloat_t)y / 512.0;
-					m_elements[utf8Value].posStop.u = (etkFloat_t)(x+w) / 512.0;
-					m_elements[utf8Value].posStop.v = (etkFloat_t)(y+h) / 512.0;
-					m_elements[utf8Value].ratio = (etkFloat_t)w/(etkFloat_t)h;
-					m_elements[utf8Value].width = m_size * 1.48 * m_elements[utf8Value].ratio;
-				} else {
-					EWOL_ERROR("not manage glyph with ID > 0x7F line : " << lineID);
-				}
-			};
-			
-		public:
-			etk::File GetFileName(void)
-			{
-				return m_filename;
-			};
-			etk::String GetName(void)
-			{
-				return m_fontName;
-			};
-			bool IsLoaded(void)
-			{
-				return m_textureLoaded;
-			};
-			bool Check(etk::String fontName, int32_t size)
-			{
-				if (m_loadedOK == -1) {
-					return false;
-				}
-				if(    m_fontName == fontName
-				    && m_size == size)
-				{
-					return true;
-				}
-				return false;
-			};
-			
-		private:
-			etk::File      m_filename;
-			bool           m_loadedOK;
-			etk::String    m_fontName;
-			int32_t        m_size;
-			uint32_t       m_textureId;
-			bool           m_textureLoaded;
-			etk::String    m_bitmapName;
-			etk::VectorType<UTF8Element_ts>   m_elements;    // 
-		public:
-			etk::VectorType<UTF8Element_ts> & GetRefOnElement(void)
-			{
-				return m_elements;
-			};
-			uint32_t GetOglId(void)
-			{
-				return GetTextureGLID(m_textureId);
-			};
-			int32_t GetHeight(void)
-			{
-				return m_size*1.42;
-			};
-			int32_t GetSize(void)
-			{
-				return m_size;
-			};
-	};
-};
-
-static etk::VectorType<ewol::EbtFont*> s_listLoadedFonts;
-
-static etk::String s_currentFolderName = "";
-static etk::String s_currentDefaultFontName = "";
-static int32_t s_currentDefaultFontId = -1;
-
-void ewol::SetFontFolder(etk::String folderName)
-{
-	if (s_currentFolderName != "") {
-		EWOL_WARNING("Change the FontFolder, old=\"" << s_currentFolderName << "\"");
-	}
-	EWOL_TODO("Check if folder exist");
-	s_currentFolderName = folderName;
-	EWOL_INFO("New default font folder name=\"" << s_currentFolderName << "\"");
-}
-
-void ewol::InitFont(void)
-{
-	// nothing to do ...
-}
-
-void ewol::UnInitFont(void)
-{
-	EWOL_TODO("later");
-}
-
-void ewol::SetDefaultFont(etk::String fontName, int32_t size)
-{
-	if (s_currentDefaultFontName != "") {
-		EWOL_WARNING("Change the default Ewol Font, old=\"" << s_currentDefaultFontName << "\"");
-	}
-	EWOL_INFO("New default Font Name=\"" << fontName << "\"");
-	int32_t tmpId = ewol::LoadFont(fontName, size);
-	if (-1 == tmpId) {
-		if (s_currentDefaultFontName == "") {
-			EWOL_ASSERT(-1 != tmpId, "Error to load the default Font\"" << fontName << "\"");
-		} else {
-			EWOL_CRITICAL("Unable to load the new default font:\"" << fontName << "\"");
-		}
-		return;
-	}
-	// save the default font parameters ...
-	s_currentDefaultFontName = fontName;
-	s_currentDefaultFontId = tmpId;
-}
-
-int32_t ewol::GetDefaultFontId(void)
-{
-	return s_currentDefaultFontId;
-}
-
-int32_t ewol::LoadFont(etk::String fontName, int32_t size)
-{
-	// check if folder file
-	etk::String tmpFileName = s_currentFolderName + "/" + fontName + ".ebt";
-	etk::File fileName(tmpFileName, etk::FILE_TYPE_DATA);
-	if (false == fileName.Exist()) {
-		EWOL_ERROR("Font does not exist: \"" << fileName.GetCompleateName() << "\"");
-		return -1;
-	}
-	for (int32_t iii=0; iii < s_listLoadedFonts.Size(); iii++) {
-		if (true == s_listLoadedFonts[iii]->Check(fontName, size)) {
-			return iii;
-		}
-	}
-	EbtFont * tmpFont = new EbtFont(fileName, fontName, size);
-	s_listLoadedFonts.PushBack(tmpFont);
-	return s_listLoadedFonts.Size()-1;
-}
-
-
-
-void ewol::UnloadFont(int32_t id)
-{
-	EWOL_TODO("I do not think it was a good idea... will be done later");
-}
-
-
-
-
-void ewol::DrawText(int32_t                        fontID,
-                    coord2D_ts &                   drawPosition,
-                    const uniChar_t *              unicodeString,
-                    uint32_t &                     fontTextureId,
-                    etk::VectorType<coord2D_ts> &  coord,
-                    etk::VectorType<texCoord_ts> & coordTex)
-{
-	if(fontID>=s_listLoadedFonts.Size() || fontID < 0) {
-		EWOL_WARNING("try to display text with an fontID that does not existed " << fontID);
-		return;
-	}
-	etk::VectorType<UTF8Element_ts> & listOfElement = s_listLoadedFonts[fontID]->GetRefOnElement();
-	
-	fontTextureId = s_listLoadedFonts[fontID]->GetOglId();
-	EWOL_DEBUG("****************    plop " << fontTextureId);
-	int32_t size = s_listLoadedFonts[fontID]->GetHeight();
-	
-	etkFloat_t posDrawX = drawPosition.x;
-	while(*unicodeString != 0) {
-		int32_t tmpChar = *unicodeString++;
-		if (tmpChar >= 0x80) {
-			tmpChar = 0;
-		}
-		etkFloat_t sizeWidth = listOfElement[tmpChar].width;
-		if (tmpChar != 0x20) {
-			// set texture coordonates :
-			coordTex.PushBack(listOfElement[tmpChar].posStart);
-			texCoord_ts tmpTex;
-			tmpTex.u = listOfElement[tmpChar].posStop.u;
-			tmpTex.v = listOfElement[tmpChar].posStart.v;
-			coordTex.PushBack(tmpTex);
-			coordTex.PushBack(listOfElement[tmpChar].posStop);
-			tmpTex.u = listOfElement[tmpChar].posStart.u;
-			tmpTex.v = listOfElement[tmpChar].posStop.v;
-			coordTex.PushBack(tmpTex);
-			// set display positions :
-			coord2D_ts tmpCoord;
-			tmpCoord.x = posDrawX;
-			tmpCoord.y = drawPosition.y;
-			coord.PushBack(tmpCoord);
-			tmpCoord.x = posDrawX + sizeWidth;
-			coord.PushBack(tmpCoord);
-			tmpCoord.y = drawPosition.y + size;
-			coord.PushBack(tmpCoord);
-			tmpCoord.x = posDrawX;
-			coord.PushBack(tmpCoord);
-		}
-		posDrawX += sizeWidth;
-	}
-	drawPosition.x = posDrawX;
-}
-
-
-void ewol::DrawText(int32_t                        fontID,
-                    coord2D_ts &                   drawPosition,
-                    const char *                   utf8String,
-                    uint32_t &                     fontTextureId,
-                    etk::VectorType<coord2D_ts> &  coord,
-                    etk::VectorType<texCoord_ts> & coordTex)
-{
-	// TODO : This code des not work, why ????
-	/*
-	int32_t tmpstringLen = strlen(utf8String);
-	int32_t * tmpUnicodeString = new int32_t(tmpstringLen+1);
-	// TODO : generate a better convertor...
-	for (int32_t iii=0; iii<tmpstringLen; iii++) {
-		tmpUnicodeString[iii] = utf8String[iii];
-	}
-	tmpUnicodeString[tmpstringLen] = 0;
-	// unicode display ...
-	//DrawText(fontID, drawPosition, tmpUnicodeString, fontTextureId, coord, coordTex);
-	// clean temporary data ..
-	delete [] tmpUnicodeString;
-	*/
-	if(fontID>=s_listLoadedFonts.Size() || fontID < 0) {
-		EWOL_WARNING("try to display text with an fontID that does not existed " << fontID);
-		return;
-	}
-	etk::VectorType<UTF8Element_ts> & listOfElement = s_listLoadedFonts[fontID]->GetRefOnElement();
-	char * tmpVal = (char*)utf8String;
-	
-	fontTextureId = s_listLoadedFonts[fontID]->GetOglId();
-	//EWOL_DEBUG("****************    plop2 " << fontTextureId);
-	int32_t size = s_listLoadedFonts[fontID]->GetHeight();
-	
-	etkFloat_t posDrawX = drawPosition.x;
-	while(*tmpVal != 0) {
-		int32_t tmpChar = *tmpVal++;
-		int32_t charIndex;
-		if (tmpChar >= 0x80) {
-			charIndex = 0;
-		} else if (tmpChar < 0x20) {
-			charIndex = 0;
-		} else if (tmpChar < 0x80) {
-			charIndex = tmpChar; // - 0x1F;
-		} else {
-			for (int32_t iii=0x80/*-0x20*/; iii < listOfElement.Size(); iii++) {
-				if (listOfElement[iii].unicodeCharVal == tmpChar) {
-					charIndex = iii;
-					break;
-				}
-			}
-			// TODO : Update if possible the mapping
-			charIndex = 0;
-		}
-		etkFloat_t sizeWidth = listOfElement[charIndex].width;
-		// 0x01 == 0x20 == ' ';
-		if (tmpChar != 0x01) {
-			#if !defined(__PLATFORM__Android)
-				// set texture coordonates :
-				coordTex.PushBack(listOfElement[charIndex].posStart);
-				texCoord_ts tmpTex;
-				tmpTex.u = listOfElement[charIndex].posStop.u;
-				tmpTex.v = listOfElement[charIndex].posStart.v;
-				coordTex.PushBack(tmpTex);
-				coordTex.PushBack(listOfElement[charIndex].posStop);
-				tmpTex.u = listOfElement[charIndex].posStart.u;
-				tmpTex.v = listOfElement[charIndex].posStop.v;
-				coordTex.PushBack(tmpTex);
-				// set display positions :
-				/*int32_t xxxx = posDrawX;
-				int32_t yyyy = drawPosition.y;*/
-				coord2D_ts tmpCoord;
-				tmpCoord.x = posDrawX;
-				tmpCoord.y = drawPosition.y;
-				coord.PushBack(tmpCoord);
-				tmpCoord.x = posDrawX + sizeWidth;
-				coord.PushBack(tmpCoord);
-				tmpCoord.y = drawPosition.y + size;
-				coord.PushBack(tmpCoord);
-				tmpCoord.x = posDrawX;
-				coord.PushBack(tmpCoord);
-			#else
-				// NOTE : Android does not support the Quads elements ...
-				/* Step 1 : 
-				 *   ********     
-				 *     ******     
-				 *       ****     
-				 *         **     
-				 *                
-				 */
-				// set texture coordonates :
-				coordTex.PushBack(listOfElement[charIndex].posStart);
-				texCoord_ts tmpTex;
-				tmpTex.u = listOfElement[charIndex].posStop.u;
-				tmpTex.v = listOfElement[charIndex].posStart.v;
-				coordTex.PushBack(tmpTex);
-				coordTex.PushBack(listOfElement[charIndex].posStop);
-				// set display positions :
-				coord2D_ts tmpCoord;
-				tmpCoord.x = posDrawX;
-				tmpCoord.y = drawPosition.y;
-				coord.PushBack(tmpCoord);
-				tmpCoord.x = posDrawX + sizeWidth;
-				coord.PushBack(tmpCoord);
-				tmpCoord.y = drawPosition.y + size;
-				coord.PushBack(tmpCoord);
-				
-				/* Step 2 : 
-				 *              
-				 *   **         
-				 *   ****       
-				 *   ******     
-				 *   ********   
-				 */
-				
-				// set texture coordonates :
-				coordTex.PushBack(listOfElement[charIndex].posStart);
-				coordTex.PushBack(listOfElement[charIndex].posStop);
-				tmpTex.u = listOfElement[charIndex].posStart.u;
-				tmpTex.v = listOfElement[charIndex].posStop.v;
-				coordTex.PushBack(tmpTex);
-				
-				// set display positions :
-				tmpCoord.x = posDrawX;
-				tmpCoord.y = drawPosition.y;
-				coord.PushBack(tmpCoord);
-				tmpCoord.x = posDrawX + sizeWidth;
-				tmpCoord.y = drawPosition.y + size;
-				coord.PushBack(tmpCoord);
-				tmpCoord.x = posDrawX;
-				coord.PushBack(tmpCoord);
-			#endif
-		}
-		posDrawX += sizeWidth;
-	}
-	drawPosition.x = posDrawX;
-	
-}
-
-int32_t ewol::GetWidth(int32_t fontID, const char * utf8String)
-{
-	if(fontID>=s_listLoadedFonts.Size() || fontID < 0) {
-		EWOL_WARNING("try to display text with an fontID that does not existed " << fontID);
-		return 0;
-	}
-	etk::VectorType<UTF8Element_ts> & listOfElement = s_listLoadedFonts[fontID]->GetRefOnElement();
-	char * tmpVal = (char*)utf8String;
-	
-	etkFloat_t posDrawX = 0.0;
-	while(*tmpVal != 0) {
-		int32_t tmpChar = *tmpVal++;
-		int32_t charIndex;
-		if (tmpChar >= 0x80) {
-			charIndex = 0;
-		} else if (tmpChar < 0x20) {
-			charIndex = 0;
-		} else if (tmpChar < 0x80) {
-			charIndex = tmpChar /*- 0x1F*/;
-		} else {
-			for (int32_t iii=0x80/*-0x20*/; iii < listOfElement.Size(); iii++) {
-				if (listOfElement[iii].unicodeCharVal == tmpChar) {
-					charIndex = iii;
-					break;
-				}
-			}
-			// TODO : Update if possible the mapping
-			charIndex = 0;
-		}
-		posDrawX += listOfElement[charIndex].width;
-	}
-	return posDrawX;
-}
-
-int32_t ewol::GetHeight(int32_t fontID)
-{
-	if(fontID>=s_listLoadedFonts.Size() || fontID < 0) {
-		EWOL_WARNING("try to display text with an fontID that does not existed " << fontID);
-		return 10;
-	}
-	return s_listLoadedFonts[fontID]->GetHeight();
-}
-
-
-
-
-
-
-
-
-
-
-
-
-

Sources/ewol/FontFreeType.cpp

@@ -1,664 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/FontFreeType.cpp
- * @brief ewol Font system wrapper on freetype(sources)
- * @author Edouard DUPIN
- * @date 05/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-#include <ewol/Font.h>
-#include <ewol/Texture.h>
-#include <etk/VectorType.h>
-
-/*
-#include <GL/glx.h>
-#include <GL/glut.h>
-#if defined(EWOL_X11_MODE__XF86V)
-#	include <X11/extensions/xf86vmode.h>
-#elif defined(EWOL_X11_MODE__XRENDER)
-#	include <X11/extensions/Xrender.h>
-#endif
-*/
-#include <importgl.h>
-#if defined(__PLATFORM__Linux)
-#	include <ft2build.h>
-#else
-#	include <freetype/ft2build.h>
-#endif
-
-#include FT_FREETYPE_H
-
-#undef __class__
-#define __class__	"ewol::FontFreeType"
-
-
-
-extern "C"
-{
-	typedef struct {
-		uniChar_t   unicodeCharVal;
-		int32_t     width;
-		texCoord_ts posStart;
-		texCoord_ts posStop;
-		etkFloat_t ratio;
-	}freeTypeFontElement_ts;
-};
-
-// free Font hnadle of librairies ... entry for acces ...
-static FT_Library library;
-
-static int32_t nextP2(int32_t value)
-{
-	int32_t val=1;
-	for (int32_t iii=1; iii<31; iii++) {
-		if (value <= val) {
-			return val;
-		}
-		val *=2;
-	}
-	EWOL_CRITICAL("impossible CASE....");
-	return val;
-}
-
-static int32_t simpleSQRT(int32_t value)
-{
-	int32_t val=1;
-	for (int32_t iii=1; iii<1000; iii++) {
-		val =iii*iii;
-		if (value <= val) {
-			return iii;
-		}
-	}
-	EWOL_CRITICAL("impossible CASE....");
-	return val;
-}
-
-void ewol::InitFont(void)
-{
-	int32_t error = FT_Init_FreeType( &library );
-	if(0 != error) {
-		EWOL_CRITICAL(" when loading FreeType Librairy ...");
-	}
-}
-
-// keep only one instance of every font in freetype
-class FTFontInternal
-{
-	private:
-		void Display(void)
-		{
-			EWOL_INFO("    nuber of glyph       = " << (int)m_fftFace->num_glyphs);
-			if ((FT_FACE_FLAG_SCALABLE & m_fftFace->face_flags) != 0) {
-				EWOL_INFO("    flags                = FT_FACE_FLAG_SCALABLE (enable)");
-			} else {
-				EWOL_DEBUG("    flags                = FT_FACE_FLAG_SCALABLE (disable)");
-			}
-			if ((FT_FACE_FLAG_FIXED_SIZES & m_fftFace->face_flags) != 0) {
-					EWOL_INFO("    flags                = FT_FACE_FLAG_FIXED_SIZES (enable)");
-			} else {
-				EWOL_DEBUG("    flags                = FT_FACE_FLAG_FIXED_SIZES (disable)");
-			}
-			if ((FT_FACE_FLAG_FIXED_WIDTH & m_fftFace->face_flags) != 0) {
-				EWOL_INFO("    flags                = FT_FACE_FLAG_FIXED_WIDTH (enable)");
-			} else {
-				EWOL_DEBUG("    flags                = FT_FACE_FLAG_FIXED_WIDTH (disable)");
-			}
-			if ((FT_FACE_FLAG_SFNT & m_fftFace->face_flags) != 0) {
-				EWOL_INFO("    flags                = FT_FACE_FLAG_SFNT (enable)");
-			} else {
-				EWOL_DEBUG("    flags                = FT_FACE_FLAG_SFNT (disable)");
-			}
-			if ((FT_FACE_FLAG_HORIZONTAL & m_fftFace->face_flags) != 0) {
-				EWOL_INFO("    flags                = FT_FACE_FLAG_HORIZONTAL (enable)");
-			} else {
-				EWOL_DEBUG("    flags                = FT_FACE_FLAG_HORIZONTAL (disable)");
-			}
-			if ((FT_FACE_FLAG_VERTICAL & m_fftFace->face_flags) != 0) {
-				EWOL_INFO("    flags                = FT_FACE_FLAG_VERTICAL (enable)");
-			} else {
-				EWOL_DEBUG("    flags                = FT_FACE_FLAG_VERTICAL (disable)");
-			}
-			if ((FT_FACE_FLAG_KERNING & m_fftFace->face_flags) != 0) {
-				EWOL_INFO("    flags                = FT_FACE_FLAG_KERNING (enable)");
-			} else {
-				EWOL_DEBUG("    flags                = FT_FACE_FLAG_KERNING (disable)");
-			}
-			/* Deprecated flag
-			if ((FT_FACE_FLAG_FAST_GLYPHS & face->face_flags) != 0) {
-				EWOL_INFO("    flags                = FT_FACE_FLAG_FAST_GLYPHS (enable)");
-			} else {
-				EWOL_DEBUG("    flags                = FT_FACE_FLAG_FAST_GLYPHS (disable)");
-			}
-			*/
-			if ((FT_FACE_FLAG_MULTIPLE_MASTERS & m_fftFace->face_flags) != 0) {
-				EWOL_INFO("    flags                = FT_FACE_FLAG_MULTIPLE_MASTERS (enable)");
-			} else {
-				EWOL_DEBUG("    flags                = FT_FACE_FLAG_MULTIPLE_MASTERS (disable)");
-			}
-			if ((FT_FACE_FLAG_GLYPH_NAMES & m_fftFace->face_flags) != 0) {
-				EWOL_INFO("    flags                = FT_FACE_FLAG_GLYPH_NAMES (enable)");
-			} else {
-				EWOL_DEBUG("    flags                = FT_FACE_FLAG_GLYPH_NAMES (disable)");
-			}
-			if ((FT_FACE_FLAG_EXTERNAL_STREAM & m_fftFace->face_flags) != 0) {
-				EWOL_INFO("    flags                = FT_FACE_FLAG_EXTERNAL_STREAM (enable)");
-			} else {
-				EWOL_DEBUG("    flags                = FT_FACE_FLAG_EXTERNAL_STREAM (disable)");
-			}
-			if ((FT_FACE_FLAG_HINTER & m_fftFace->face_flags) != 0) {
-				EWOL_INFO("    flags                = FT_FACE_FLAG_HINTER (enable)");
-			} else {
-				EWOL_DEBUG("    flags                = FT_FACE_FLAG_HINTER (disable)");
-			}
-			if ((FT_FACE_FLAG_CID_KEYED & m_fftFace->face_flags) != 0) {
-				EWOL_INFO("    flags                = FT_FACE_FLAG_CID_KEYED (enable)");
-			} else {
-				EWOL_DEBUG("    flags                = FT_FACE_FLAG_CID_KEYED (disable)");
-			}
-			if ((FT_FACE_FLAG_TRICKY & m_fftFace->face_flags) != 0) {
-				EWOL_INFO("    flags                = FT_FACE_FLAG_TRICKY (enable)");
-			} else {
-				EWOL_DEBUG("    flags                = FT_FACE_FLAG_TRICKY (disable)");
-			}
-			EWOL_INFO("    unit per EM          = " << m_fftFace->units_per_EM);
-			EWOL_INFO("    num of fixed sizes   = " << m_fftFace->num_fixed_sizes);
-			//EWOL_INFO("    Availlable sizes     = " << (int)m_fftFace->available_sizes);
-			
-			//EWOL_INFO("    Current size         = " << (int)m_fftFace->size);
-		}
-	public:
-		FTFontInternal(etk::File fontFileName, etk::String fontName)
-		{
-			m_fontName = fontName;
-			m_fileName = fontFileName;
-			int32_t error = FT_New_Face( library, m_fileName.GetCompleateName().c_str(), 0, &m_fftFace );
-			if( FT_Err_Unknown_File_Format == error) {
-				EWOL_ERROR("... the font file could be opened and read, but it appears ... that its font format is unsupported");
-			} else if (0 != error) {
-				EWOL_ERROR("... another error code means that the font file could not ... be opened or read, or simply that it is broken...");
-			} else {
-				// all OK
-				EWOL_INFO("load font : \"" << m_fileName << "\" ");
-				Display();
-			}
-		}
-		~FTFontInternal(void)
-		{
-			
-		}
-	public:
-		etk::String GetFontName(void) {return m_fontName;};
-		bool GenerateBitmapFont(int32_t size, int32_t &height, int32_t textureId, etk::VectorType<freeTypeFontElement_ts> & listElement)
-		{
-			// 300dpi (hight quality) 96 dpi (normal quality)
-			int32_t fontQuality = 96;
-			//int32_t fontQuality = 150;
-			//int32_t fontQuality = 300;
-			// Select Size ...
-			// note tha <<6==*64 corespond with the 1/64th of points calculation of freetype
-			int32_t error = FT_Set_Char_Size(m_fftFace, size<<6, size<<6, fontQuality, fontQuality);
-			// the line height to have a correct display
-			height = size*1.43f;
-
-			// a small shortcut
-			FT_GlyphSlot slot = m_fftFace->glyph;
-			
-			EWOL_DEBUG("Max size for ths glyph size=" << size << " is (" << m_fftFace->max_advance_width << "," << m_fftFace->max_advance_height << ")");
-			
-			// retrieve glyph index from character code 
-			int32_t glyph_index = FT_Get_Char_Index(m_fftFace, 'A' );
-			// load glyph image into the slot (erase previous one)
-			error = FT_Load_Glyph(m_fftFace, // handle to face object
-			                      glyph_index, // glyph index
-			                      FT_LOAD_DEFAULT );
-			if ( error ) {
-				EWOL_ERROR("FT_Load_Glyph");
-			}
-			EWOL_DEBUG("linearHoriAdvance=" << (slot->linearHoriAdvance >> 6));
-			EWOL_DEBUG("linearVertAdvance=" << (slot->linearVertAdvance >> 6));
-			EWOL_DEBUG("metrics.horiAdvance=" << (slot->metrics.horiAdvance >> 6));
-			EWOL_DEBUG("metrics.vertAdvance=" << (slot->metrics.vertAdvance >> 6));
-			
-			int32_t nbElement = listElement.Size();
-			int32_t coter = simpleSQRT(nbElement);
-			int32_t glyphMaxWidth = slot->metrics.horiAdvance>>6;
-			int32_t glyphMaxHeight = slot->metrics.vertAdvance>>6;
-			int32_t textureWidth = nextP2(coter*glyphMaxWidth);
-			int32_t nbRaws = textureWidth / glyphMaxWidth;
-			int32_t nbLine = (nbElement / nbRaws) + 1;
-			int32_t textureHeight = nextP2(nbLine*glyphMaxHeight);
-			EWOL_DEBUG("Generate a text texture for char(" << nbRaws << "," << nbLine << ") with size=(" << textureWidth << "," << textureHeight << ")");
-			
-			// Allocate Memory For The Texture Data.
-			GLubyte* expanded_data = new GLubyte[ 2 * textureWidth * textureHeight];
-			// clean the data : 
-			for(int j=0; j <textureHeight;j++) {
-				for(int i=0; i < textureWidth; i++){
-					expanded_data[2*(i+j*textureWidth)+0] = 0;
-					expanded_data[2*(i+j*textureWidth)+1] = 0;
-				}
-			}
-			
-			int32_t tmpRowId = 0;
-			int32_t tmpLineId = 0;
-			// Generate for All Elements :
-			for (int32_t iii=0; iii<listElement.Size(); iii++) {
-				// increment the position of the texture
-				if (iii!=0) {
-					tmpRowId++;
-					if (tmpRowId>=nbRaws) {
-						tmpRowId = 0;
-						tmpLineId++;
-					}
-				}
-				// retrieve glyph index from character code 
-				glyph_index = FT_Get_Char_Index(m_fftFace, listElement[iii].unicodeCharVal );
-				// load glyph image into the slot (erase previous one)
-				error = FT_Load_Glyph(m_fftFace, // handle to face object
-				                      glyph_index, // glyph index
-				                      FT_LOAD_DEFAULT );
-				if ( error ) {
-					EWOL_ERROR("FT_Load_Glyph");
-				}
-				
-				// convert to an anti-aliased bitmap
-				error = FT_Render_Glyph(slot, FT_RENDER_MODE_NORMAL );
-				if ( error ) {
-					EWOL_ERROR("FT_Render_Glyph");
-				}
-				int32_t tmpWidth=slot->bitmap.width;
-				int32_t tmpHeight=slot->bitmap.rows;
-				/*
-				EWOL_DEBUG("elem=" << listElement[iii].unicodeCharVal
-				           <<" size=(" << tmpWidth << "," << tmpHeight << ")"
-				           << " for bitmap (left=" << slot->bitmap_left << ",top=" << slot->bitmap_top << ")");
-				EWOL_DEBUG(" BEARING=(" << (slot->metrics.horiBearingX>>6) << "," << (slot->metrics.vertBearingY>>6) << ")" );
-				*/
-				for(int32_t j=0; j < tmpHeight;j++) {
-					for(int32_t i=0; i < tmpWidth; i++){
-						int32_t position = 2*(   (tmpRowId *glyphMaxWidth  + i /*+ (slot->metrics.horiBearingX>>6)*/ )
-						                       + (tmpLineId*glyphMaxHeight + j + (size-(slot->metrics.horiBearingY>>6)) ) * textureWidth);
-						//EWOL_DEBUG(" BEARING=(" << i << "," << j << ") pos=" << position);
-						expanded_data[position+0] = slot->bitmap.buffer[i + tmpWidth*j];
-						expanded_data[position+1] = slot->bitmap.buffer[i + tmpWidth*j];
-					}
-				}
-				listElement[iii].width = glyphMaxWidth;
-				listElement[iii].posStart.u = (etkFloat_t)(tmpRowId *glyphMaxWidth) / (etkFloat_t)textureWidth;
-				listElement[iii].posStart.v = (etkFloat_t)(tmpLineId*glyphMaxHeight) / (etkFloat_t)textureHeight;
-				listElement[iii].posStop.u = (etkFloat_t)(tmpRowId *glyphMaxWidth + glyphMaxWidth) / (etkFloat_t)textureWidth;
-				listElement[iii].posStop.v = (etkFloat_t)(tmpLineId*glyphMaxHeight + glyphMaxHeight + 1) / (etkFloat_t)textureHeight;
-			}
-			// Now We Just Setup Some Texture Parameters.
-			glBindTexture( GL_TEXTURE_2D, textureId);
-			glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
-			glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
-			
-			// Here We Actually Create The Texture Itself, Notice That We Are Using GL_LUMINANCE_ALPHA To Indicate That we Are Using 2 Channel Data.
-			glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, textureWidth, textureHeight, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, expanded_data );
-			
-			// With The Texture Created, We Don't Need The Expanded Data Anymore.
-			delete [] expanded_data;
-		
-			return false;
-		}
-	private:
-		etk::String  m_fontName;
-		etk::File    m_fileName;
-		FT_Face      m_fftFace;
-};
-
-static etk::VectorType<FTFontInternal*> m_listLoadedTTFont;
-
-
-static etk::String s_currentFolderName = "";
-static etk::String s_currentDefaultFontName = "";
-static int32_t s_currentDefaultFontId = -1;
-
-class FTFont{
-	public:
-		FTFont(etk::File fontfileName, etk::String fontName, int32_t size)
-		{
-			m_trueTypeFontId = -1;
-			for (int32_t iii=0; iii < m_listLoadedTTFont.Size(); iii++) {
-				if (m_listLoadedTTFont[iii]->GetFontName() == fontName) {
-					m_trueTypeFontId = iii;
-				}
-			}
-			if (-1==m_trueTypeFontId) {
-				// load a new one ...
-				FTFontInternal * tmpElement = new FTFontInternal(fontfileName, fontName);
-				m_listLoadedTTFont.PushBack(tmpElement);
-				m_trueTypeFontId = m_listLoadedTTFont.Size() -1;
-			}
-			// set the bassic charset:
-			m_elements.Clear();
-			freeTypeFontElement_ts tmpchar1;
-			tmpchar1.unicodeCharVal = 0;
-			m_elements.PushBack(tmpchar1);
-			for (int32_t iii=0x20; iii<127; iii++) {
-				freeTypeFontElement_ts tmpchar;
-				tmpchar.unicodeCharVal = iii;
-				m_elements.PushBack(tmpchar);
-			}
-			m_size = size;
-			//generate font
-			glGenTextures(1, &m_textureId);
-			m_listLoadedTTFont[m_trueTypeFontId]->GenerateBitmapFont(m_size, m_lineHeight, m_textureId, m_elements);
-		}
-		~FTFont(void)
-		{
-			
-		}
-		bool Check(etk::String fontName, int32_t size)
-		{
-			if (m_trueTypeFontId == -1) {
-				return false;
-			}
-			if(    m_listLoadedTTFont[m_trueTypeFontId]->GetFontName() == fontName
-			    && m_size == size)
-			{
-				return true;
-			}
-			return false;
-		};
-		
-		etk::VectorType<freeTypeFontElement_ts> & GetRefOnElement(void)
-		{
-			return m_elements;
-		};
-		
-		uint32_t GetOglId(void)
-		{
-			return m_textureId;
-		};
-		
-		int32_t GetSize(void)
-		{
-			return m_size;
-		};
-		
-		int32_t GetHeight(void)
-		{
-			return m_lineHeight;
-		};
-		
-	private:
-		int32_t                                   m_trueTypeFontId;
-		uint32_t                                  m_textureId;   // internal texture ID
-		int32_t                                   m_size;        // nb pixel height
-		int32_t                                   m_lineHeight;  // nb pixel height
-		int32_t                                   m_interline;   // nb pixel between 2 lines
-		etk::VectorType<freeTypeFontElement_ts>   m_elements;    // 
-		
-};
-
-static etk::VectorType<FTFont*> m_listLoadedFont;
-
-#undef __class__
-#define __class__	"ewol::FontFreeType"
-
-void ewol::SetFontFolder(etk::String folderName)
-{
-	if (s_currentFolderName != "") {
-		EWOL_WARNING("Change the FontFolder, old=\"" << s_currentFolderName << "\"");
-	}
-	EWOL_TODO("Check if folder exist");
-	s_currentFolderName = folderName;
-	EWOL_INFO("New default font folder name=\"" << s_currentFolderName << "\"");
-}
-
-
-void ewol::UnInitFont(void)
-{
-	EWOL_TODO("later");
-}
-
-void ewol::SetDefaultFont(etk::String fontName, int32_t size)
-{
-	if (s_currentDefaultFontName != "") {
-		EWOL_WARNING("Change the default Ewol Font, old=\"" << s_currentDefaultFontName << "\"");
-	}
-	EWOL_INFO("New default Font Name=\"" << fontName << "\"");
-	int32_t tmpId = ewol::LoadFont(fontName, size);
-	if (-1 == tmpId) {
-		if (s_currentDefaultFontName == "") {
-			EWOL_ASSERT(-1 != tmpId, "Error to load the default Font\"" << fontName << "\"");
-		} else {
-			EWOL_CRITICAL("Unable to load the new default font:\"" << fontName << "\"");
-		}
-		return;
-	}
-	// save the default font parameters ...
-	s_currentDefaultFontName = fontName;
-	s_currentDefaultFontId = tmpId;
-}
-
-int32_t ewol::GetDefaultFontId(void)
-{
-	return s_currentDefaultFontId;
-}
-
-int32_t ewol::LoadFont(etk::String fontName, int32_t size)
-{
-	// check if folder file
-	etk::String tmpFileName = s_currentFolderName + "/" + fontName + ".ttf";
-	etk::File fileName(tmpFileName);
-	if (false == fileName.Exist()) {
-		EWOL_ERROR("Font does not exist: \"" << fileName.GetCompleateName() << "\"");
-		return -1;
-	}
-	for (int32_t iii=0; iii < m_listLoadedFont.Size(); iii++) {
-		if (true == m_listLoadedFont[iii]->Check(fontName, size)) {
-			return iii;
-		}
-	}
-	FTFont * tmpFont = new FTFont(fileName, fontName, size);
-	m_listLoadedFont.PushBack(tmpFont);
-	return m_listLoadedFont.Size()-1;
-}
-
-void ewol::UnloadFont(int32_t id)
-{
-	EWOL_TODO("I do not think it was a good idea... will be done later");
-}
-
-
-
-
-
-void ewol::DrawText(int32_t                        fontID,
-                    coord2D_ts &                   drawPosition,
-                    const uniChar_t *              unicodeString,
-                    uint32_t &                     fontTextureId,
-                    etk::VectorType<coord2D_ts> &  coord,
-                    etk::VectorType<texCoord_ts> & coordTex)
-{
-	if(fontID>=m_listLoadedFont.Size() || fontID < 0) {
-		EWOL_WARNING("try to display text with an fontID that does not existed " << fontID);
-		return;
-	}
-	etk::VectorType<freeTypeFontElement_ts> & listOfElement = m_listLoadedFont[fontID]->GetRefOnElement();
-	
-	fontTextureId = m_listLoadedFont[fontID]->GetOglId();
-	int32_t size = m_listLoadedFont[fontID]->GetHeight();
-	
-	etkFloat_t posDrawX = drawPosition.x;
-	while(*unicodeString != 0) {
-		int32_t tmpChar = *unicodeString++;
-		if (tmpChar >= 0x80) {
-			tmpChar = 0;
-		}
-		etkFloat_t sizeWidth = listOfElement[tmpChar].width;
-		if (tmpChar != 0x20) {
-			// set texture coordonates :
-			coordTex.PushBack(listOfElement[tmpChar].posStart);
-			texCoord_ts tmpTex;
-			tmpTex.u = listOfElement[tmpChar].posStop.u;
-			tmpTex.v = listOfElement[tmpChar].posStart.v;
-			coordTex.PushBack(tmpTex);
-			coordTex.PushBack(listOfElement[tmpChar].posStop);
-			tmpTex.u = listOfElement[tmpChar].posStart.u;
-			tmpTex.v = listOfElement[tmpChar].posStop.v;
-			coordTex.PushBack(tmpTex);
-			// set display positions :
-			coord2D_ts tmpCoord;
-			tmpCoord.x = posDrawX;
-			tmpCoord.y = drawPosition.y;
-			coord.PushBack(tmpCoord);
-			tmpCoord.x = posDrawX + sizeWidth;
-			coord.PushBack(tmpCoord);
-			tmpCoord.y = drawPosition.y + size;
-			coord.PushBack(tmpCoord);
-			tmpCoord.x = posDrawX;
-			coord.PushBack(tmpCoord);
-		}
-		posDrawX += sizeWidth;
-	}
-	drawPosition.x = posDrawX;
-}
-
-
-void ewol::DrawText(int32_t                        fontID,
-                    coord2D_ts &                   drawPosition,
-                    const char *                   utf8String,
-                    uint32_t &                     fontTextureId,
-                    etk::VectorType<coord2D_ts> &  coord,
-                    etk::VectorType<texCoord_ts> & coordTex)
-{
-	// TODO : This code des not work, why ????
-	/*
-	int32_t tmpstringLen = strlen(utf8String);
-	int32_t * tmpUnicodeString = new int32_t(tmpstringLen+1);
-	// TODO : generate a better convertor...
-	for (int32_t iii=0; iii<tmpstringLen; iii++) {
-		tmpUnicodeString[iii] = utf8String[iii];
-	}
-	tmpUnicodeString[tmpstringLen] = 0;
-	// unicode display ...
-	//DrawText(fontID, drawPosition, tmpUnicodeString, fontTextureId, coord, coordTex);
-	// clean temporary data ..
-	delete [] tmpUnicodeString;
-	*/
-	if(fontID>=m_listLoadedFont.Size() || fontID < 0) {
-		EWOL_WARNING("try to display text with an fontID that does not existed " << fontID);
-		return;
-	}
-	etk::VectorType<freeTypeFontElement_ts> & listOfElement = m_listLoadedFont[fontID]->GetRefOnElement();
-	char * tmpVal = (char*)utf8String;
-	
-	fontTextureId = m_listLoadedFont[fontID]->GetOglId();
-	int32_t size = m_listLoadedFont[fontID]->GetHeight();
-	
-	etkFloat_t posDrawX = drawPosition.x;
-	while(*tmpVal != 0) {
-		int32_t tmpChar = *tmpVal++;
-		int32_t charIndex;
-		if (tmpChar >= 0x80) {
-			charIndex = 0;
-		} else if (tmpChar < 0x20) {
-			charIndex = 0;
-		} else if (tmpChar < 0x80) {
-			charIndex = tmpChar - 0x1F;
-		} else {
-			for (int32_t iii=0x80-0x20; iii < listOfElement.Size(); iii++) {
-				if (listOfElement[iii].unicodeCharVal == tmpChar) {
-					charIndex = iii;
-					break;
-				}
-			}
-			// TODO : Update if possible the mapping
-			charIndex = 0;
-		}
-		etkFloat_t sizeWidth = listOfElement[charIndex].width;
-		// 0x01 == 0x20 == ' ';
-		if (tmpChar != 0x01) {
-			// set texture coordonates :
-			coordTex.PushBack(listOfElement[charIndex].posStart);
-			texCoord_ts tmpTex;
-			tmpTex.u = listOfElement[charIndex].posStop.u;
-			tmpTex.v = listOfElement[charIndex].posStart.v;
-			coordTex.PushBack(tmpTex);
-			coordTex.PushBack(listOfElement[charIndex].posStop);
-			tmpTex.u = listOfElement[charIndex].posStart.u;
-			tmpTex.v = listOfElement[charIndex].posStop.v;
-			coordTex.PushBack(tmpTex);
-			// set display positions :
-			/*int32_t xxxx = posDrawX;
-			int32_t yyyy = drawPosition.y;*/
-			coord2D_ts tmpCoord;
-			tmpCoord.x = posDrawX;
-			tmpCoord.y = drawPosition.y;
-			coord.PushBack(tmpCoord);
-			tmpCoord.x = posDrawX + sizeWidth;
-			coord.PushBack(tmpCoord);
-			tmpCoord.y = drawPosition.y + size;
-			coord.PushBack(tmpCoord);
-			tmpCoord.x = posDrawX;
-			coord.PushBack(tmpCoord);
-		}
-		posDrawX += sizeWidth;
-	}
-	drawPosition.x = posDrawX;
-	
-}
-
-int32_t ewol::GetWidth(int32_t fontID, const char * utf8String)
-{
-	if(fontID>=m_listLoadedFont.Size() || fontID < 0) {
-		EWOL_WARNING("try to display text with an fontID that does not existed " << fontID);
-		return 0;
-	}
-	etk::VectorType<freeTypeFontElement_ts> & listOfElement = m_listLoadedFont[fontID]->GetRefOnElement();
-	char * tmpVal = (char*)utf8String;
-	
-	etkFloat_t posDrawX = 0.0;
-	while(*tmpVal != 0) {
-		int32_t tmpChar = *tmpVal++;
-		int32_t charIndex;
-		if (tmpChar >= 0x80) {
-			charIndex = 0;
-		} else if (tmpChar < 0x20) {
-			charIndex = 0;
-		} else if (tmpChar < 0x80) {
-			charIndex = tmpChar - 0x1F;
-		} else {
-			for (int32_t iii=0x80-0x20; iii < listOfElement.Size(); iii++) {
-				if (listOfElement[iii].unicodeCharVal == tmpChar) {
-					charIndex = iii;
-					break;
-				}
-			}
-			// TODO : Update if possible the mapping
-			charIndex = 0;
-		}
-		posDrawX += listOfElement[charIndex].width;
-	}
-	return posDrawX;
-}
-
-int32_t ewol::GetHeight(int32_t fontID)
-{
-	if(fontID>=m_listLoadedFont.Size() || fontID < 0) {
-		EWOL_WARNING("try to display text with an fontID that does not existed " << fontID);
-		return 10;
-	}
-	return m_listLoadedFont[fontID]->GetHeight();
-}

Sources/ewol/Linux.mk

@@ -1,36 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE := ewol
-LOCAL_STATIC_LIBRARIES := libzip libpng
-
-LOCAL_C_INCLUDES := $(LOCAL_PATH)/ $(LOCAL_PATH)/../libzip/ $(LOCAL_PATH)/../libpng/
-
-LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/../../Sources
-LOCAL_EXPORT_LDLIBS := -lGLESv1_CM -ldl -llog -lz
-
-LOCAL_CFLAGS := -D__PLATFORM__Linux \
-                -Wno-write-strings \
-                -DETK_DEBUG_LEVEL=3 \
-                -DEWOL_DEBUG_LEVEL=3 \
-                -DEWOL_VERSION_TAG_NAME="\"UNKNOW-debug\"" \
-                -DVERSION_BUILD_TIME="\"pasd_heure\"" \
-                -DDATA_IN_APK \
-
-# load the common sources file of the platform
-include $(LOCAL_PATH)/file.mk
-
-LOCAL_SRC_FILES := \
-	base/guiX11.cpp \
-	$(FILE_LIST)
-
-#for freetype : https://github.com/cdave1/freetype2-android
-
-# Ewol Test Software :
-LOCAL_LDLIBS := -lGLESv1_CM -ldl -llog -lz
-
-
-include $(BUILD_STATIC_LIBRARY)
-
-

Sources/ewol/OObject.cpp

@@ -1,63 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/OObject.cpp
- * @brief ewol OpenGl Object system (Sources)
- * @author Edouard DUPIN
- * @date 24/10/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#include <etk/Types.h>
-#include <etk/String.h>
-#include <ewol/OObject.h>
-#include <importgl.h>
-
-
-#undef __class__
-#define __class__	"ewol::OObject"
-
-
-ewol::OObject::OObject(void)
-{
-	m_name="";
-}
-
-
-ewol::OObject::~OObject(void)
-{
-	
-}
-
-void ewol::OObject::SetName(etk::String & name)
-{
-	m_name = name;
-}
-
-void ewol::OObject::SetName(const char * name)
-{
-	if (NULL != name) {
-		m_name = name;
-	}
-}
-
-etk::String ewol::OObject::GetName(void)
-{
-	return m_name;
-}
-
-

Sources/ewol/OObject.h

@@ -1,84 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/OObject.h
- * @brief ewol OpenGl Object system (header)
- * @author Edouard DUPIN
- * @date 24/10/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#ifndef __EWOL_O_OBJECT_H__
-#define __EWOL_O_OBJECT_H__
-
-#include <etk/Types.h>
-#include <etk/File.h>
-#include <ewol/Debug.h>
-#include <ewol/Font.h>
-#include <etk/VectorType.h>
-
-namespace ewol {
-	extern "C" {
-		typedef struct {
-			int32_t f;
-			int32_t s;
-			int32_t t;
-		}linkCoord_ts;
-	};
-	
-	class OObject
-	{
-		public:
-			OObject(void);
-			virtual ~OObject(void);
-		public:
-			virtual void Draw(void) = 0;
-			void SetName(etk::String & name);
-			void SetName(const char * name);
-			etk::String GetName(void);
-		public:
-			// use to crop element outside the display
-			virtual void UpdateSize(etkFloat_t sizeX, etkFloat_t sizeY) { };
-			// Move to the correct position display
-			virtual void UpdateOrigin(etkFloat_t x, etkFloat_t y) { };
-		private:
-			etk::String m_name;
-	};
-	
-	/*
-	class OObjectFile :public ewol::OObject
-	{
-		public:
-			OObjectFile(etk::File fileName) {};
-			virtual ~OObject2DColored(void) {};
-		public:
-			void Draw(void);
-			bool Save(etk::File fileName) { return false; };
-		protected:
-			etk::VectorType<OObject*>   m_listsubObject;   //!< an object file contain more than one object...
-			bool                        m_isBinaryFile;    //!< to know th mode of saving the file
-	};
-	*/
-};
-
-#endif
-
-
-#include <ewol/OObject/2DTextured.h>
-#include <ewol/OObject/2DColored.h>
-#include <ewol/OObject/2DText.h>
-

Sources/ewol/OObject/2DColored.cpp

@@ -1,610 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/OObject/2DColored.cpp
- * @brief ewol OpenGl Object system (Sources)
- * @author Edouard DUPIN
- * @date 09/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#include <ewol/OObject/2DColored.h>
-#include <importgl.h>
-#include <math.h>
-
-
-#undef __class__
-#define __class__	"ewol::OObject2DColored"
-
-
-ewol::OObject2DColored::OObject2DColored(void)
-{
-	m_triElement = 0;
-	SetColor(1.0, 1.0, 1.0, 1.0);
-}
-
-
-ewol::OObject2DColored::~OObject2DColored(void)
-{
-	m_coord.Clear();
-	m_coordColor.Clear();
-}
-
-
-void ewol::OObject2DColored::Draw(void)
-{
-	if (m_coord.Size()<=0) {
-		return;
-	}
-	// Enable Pointers
-	glEnableClientState( GL_VERTEX_ARRAY );
-	glEnableClientState( GL_COLOR_ARRAY );
-
-	
-	// Set the vertex pointer to our vertex data
-	glVertexPointer(2, oglTypeFloat_t, 0, &m_coord[0] );
-	glColorPointer(4, oglTypeFloat_t, 0, &m_coordColor[0] );
-	// Render : draw all of the triangles at once
-	glDrawArrays( GL_TRIANGLES, 0, m_coord.Size());
-	//glDrawElements( GL_TRIANGLES, 0, m_coord.Size());
-	//EWOL_DEBUG("Draw ..." << m_coord.Size()/3 << " triangle(s)");
-
-	// Disable Pointers
-	glDisableClientState( GL_COLOR_ARRAY );
-	glDisableClientState( GL_VERTEX_ARRAY );
-
-}
-
-
-void ewol::OObject2DColored::UpdateOrigin(etkFloat_t x, etkFloat_t y)
-{
-	for (int32_t iii=0; iii<m_coord.Size(); iii++) {
-		m_coord[iii].x += x;
-		m_coord[iii].y += y;
-	}
-}
-
-void generatePolyGone(etk::VectorType<coord2D_ts> & input, etk::VectorType<coord2D_ts> & output )
-{
-	if (input.Size()<3) {
-		return;
-	}
-	coord2D_ts basePoint = input[0];
-	// TODO : Regenerate a linear poligone generation
-	for (int32_t iii=1; iii<input.Size()-1; iii++) {
-		output.PushBack(basePoint);
-		output.PushBack(input[iii]);
-		output.PushBack(input[iii+1]);
-	}
-	//EWOL_DEBUG("generate Plygone : " << input.Size() << " ==> " << output.Size() );
-}
-
-void SutherlandHodgman(etk::VectorType<coord2D_ts> & input, etk::VectorType<coord2D_ts> & output, etkFloat_t sx, etkFloat_t sy, etkFloat_t ex, etkFloat_t ey)
-{
-	// with Sutherland-Hodgman-Algorithm
-	if (input.Size() <0) {
-		return;
-	}
-	//int32_t sizeInit=input.Size();
-	// last element :
-	coord2D_ts destPoint;
-	coord2D_ts lastElement = input[input.Size()-1];
-	bool inside = true;
-	if (lastElement.x < sx) {
-		inside = false;
-	}
-	//EWOL_DEBUG("generate an crop : ");
-	for(int32_t iii=0; iii<input.Size(); iii++) {
-		if(input[iii].x < sx) {
-			if(true == inside) {
-				//EWOL_DEBUG("element IN ==> OUT ");
-				//new point intersection ...
-				//y=aaax+bbb
-				etkFloat_t aaa = (lastElement.y-input[iii].y) / (lastElement.x-input[iii].x);
-				etkFloat_t bbb = lastElement.y - (aaa*lastElement.x);
-				destPoint.y = aaa*sx + bbb;
-				destPoint.x = sx;
-				output.PushBack(destPoint);
-			} else {
-				//EWOL_DEBUG("element OUT ==> OUT ");
-			}
-			inside = false;
-		} else {
-			if(true == inside) {
-				//EWOL_DEBUG("element IN ==> IN ");
-				output.PushBack(input[iii]);
-			} else {
-				//EWOL_DEBUG("element OUT ==> IN ");
-				//new point intersection ...
-				//y=aaax+bbb
-				etkFloat_t aaa = (lastElement.y-input[iii].y) / (lastElement.x-input[iii].x);
-				etkFloat_t bbb = lastElement.y - (aaa*lastElement.x);
-				destPoint.y = aaa*sx + bbb;
-				destPoint.x = sx;
-				output.PushBack(destPoint);
-				output.PushBack(input[iii]);
-			}
-			inside = true;
-		}
-		// update the last point position :
-		lastElement.x = input[iii].x;
-		lastElement.y = input[iii].y;
-	}
-	
-	//EWOL_DEBUG("generate an crop on element : " << sizeInit << " ==> " << output.Size() << "intermediate (1)");
-	input = output;
-	output.Clear();
-	lastElement = input[input.Size()-1];
-	inside = true;
-	if (lastElement.y < sy) {
-		inside = false;
-	}
-	for(int32_t iii=0; iii<input.Size(); iii++) {
-		if(input[iii].y < sy) {
-			if(true == inside) {
-				//EWOL_DEBUG("element IN ==> OUT ");
-				//new point intersection ...
-				//x=aaay+bbb
-				etkFloat_t aaa = (lastElement.x-input[iii].x) / (lastElement.y-input[iii].y);
-				etkFloat_t bbb = lastElement.x - (aaa*lastElement.y);
-				destPoint.y = sy;
-				destPoint.x = sy*aaa + bbb;
-				output.PushBack(destPoint);
-			} else {
-				//EWOL_DEBUG("element OUT ==> OUT ");
-			}
-			inside = false;
-		} else {
-			if(true == inside) {
-				//EWOL_DEBUG("element IN ==> IN ");
-				output.PushBack(input[iii]);
-			} else {
-				//EWOL_DEBUG("element OUT ==> IN ");
-				//new point intersection ...
-				//y=aaax+bbb
-				etkFloat_t aaa = (lastElement.x-input[iii].x) / (lastElement.y-input[iii].y);
-				etkFloat_t bbb = lastElement.x - (aaa*lastElement.y);
-				destPoint.y = sy;
-				destPoint.x = sy*aaa + bbb;
-				output.PushBack(destPoint);
-				output.PushBack(input[iii]);
-			}
-			inside = true;
-		}
-		// update the last point position :
-		lastElement.x = input[iii].x;
-		lastElement.y = input[iii].y;
-	}
-	
-	input = output;
-	output.Clear();
-	lastElement = input[input.Size()-1];
-	inside = true;
-	if (lastElement.x > ex) {
-		inside = false;
-	}
-	//EWOL_DEBUG("generate an crop : ");
-	for(int32_t iii=0; iii<input.Size(); iii++) {
-		if(input[iii].x > ex) {
-			if(true == inside) {
-				//EWOL_DEBUG("element IN ==> OUT ");
-				//new point intersection ...
-				//y=aaax+bbb
-				etkFloat_t aaa = (lastElement.y-input[iii].y) / (lastElement.x-input[iii].x);
-				etkFloat_t bbb = lastElement.y - (aaa*lastElement.x);
-				destPoint.y = aaa*ex + bbb;
-				destPoint.x = ex;
-				output.PushBack(destPoint);
-			} else {
-				//EWOL_DEBUG("element OUT ==> OUT ");
-			}
-			inside = false;
-		} else {
-			if(true == inside) {
-				//EWOL_DEBUG("element IN ==> IN ");
-				output.PushBack(input[iii]);
-			} else {
-				//EWOL_DEBUG("element OUT ==> IN ");
-				//new point intersection ...
-				//y=aaax+bbb
-				etkFloat_t aaa = (lastElement.y-input[iii].y) / (lastElement.x-input[iii].x);
-				etkFloat_t bbb = lastElement.y - (aaa*lastElement.x);
-				destPoint.y = aaa*ex + bbb;
-				destPoint.x = ex;
-				output.PushBack(destPoint);
-				output.PushBack(input[iii]);
-			}
-			inside = true;
-		}
-		// update the last point position :
-		lastElement.x = input[iii].x;
-		lastElement.y = input[iii].y;
-	}
-	
-	input = output;
-	output.Clear();
-	lastElement = input[input.Size()-1];
-	inside = true;
-	if (lastElement.y > ey) {
-		inside = false;
-	}
-	for(int32_t iii=0; iii<input.Size(); iii++) {
-		if(input[iii].y > ey) {
-			if(true == inside) {
-				//EWOL_DEBUG("element IN ==> OUT ");
-				//new point intersection ...
-				//x=aaay+bbb
-				etkFloat_t aaa = (lastElement.x-input[iii].x) / (lastElement.y-input[iii].y);
-				etkFloat_t bbb = lastElement.x - (aaa*lastElement.y);
-				destPoint.y = ey;
-				destPoint.x = ey*aaa + bbb;
-				output.PushBack(destPoint);
-			} else {
-				//EWOL_DEBUG("element OUT ==> OUT ");
-			}
-			inside = false;
-		} else {
-			if(true == inside) {
-				//EWOL_DEBUG("element IN ==> IN ");
-				output.PushBack(input[iii]);
-			} else {
-				//EWOL_DEBUG("element OUT ==> IN ");
-				//new point intersection ...
-				//y=aaax+bbb
-				etkFloat_t aaa = (lastElement.x-input[iii].x) / (lastElement.y-input[iii].y);
-				etkFloat_t bbb = lastElement.x - (aaa*lastElement.y);
-				destPoint.y = ey;
-				destPoint.x = ey*aaa + bbb;
-				output.PushBack(destPoint);
-				output.PushBack(input[iii]);
-			}
-			inside = true;
-		}
-		// update the last point position :
-		lastElement.x = input[iii].x;
-		lastElement.y = input[iii].y;
-	}
-	
-	
-	//EWOL_DEBUG("generate an crop on element : " << sizeInit << " ==> " << output.Size() );
-}
-
-
-void ewol::OObject2DColored::UpdateSize(etkFloat_t sizeX, etkFloat_t sizeY)
-{
-	// copy the data
-	etk::VectorType<coord2D_ts>   coord = m_coord;
-	etk::VectorType<color_ts>     color = m_coordColor;
-	// Clear the generated display ...
-	m_coord.Clear();
-	m_coordColor.Clear();
-	// Check if the triangle is in the area...
-	int32_t nbTriangle = coord.Size()/3;
-	for (int32_t iii=0; iii<nbTriangle; iii++) {
-		if(    coord[iii*3+0].x >= 0.0 && coord[iii*3+0].x < sizeX
-		    && coord[iii*3+0].y >= 0.0 && coord[iii*3+0].y < sizeY
-		    && coord[iii*3+1].x >= 0.0 && coord[iii*3+1].x < sizeX
-		    && coord[iii*3+1].y >= 0.0 && coord[iii*3+1].y < sizeY
-		    && coord[iii*3+2].x >= 0.0 && coord[iii*3+2].x < sizeX
-		    && coord[iii*3+2].y >= 0.0 && coord[iii*3+2].y < sizeY)
-		{
-			// point 1-2-3 inside
-			m_coord.PushBack(coord[iii*3+0]);
-			m_coordColor.PushBack(color[iii*3+0]);
-			m_coord.PushBack(coord[iii*3+1]);
-			m_coordColor.PushBack(color[iii*3+1]);
-			m_coord.PushBack(coord[iii*3+2]);
-			m_coordColor.PushBack(color[iii*3+2]);
-		} else {
-			etk::VectorType<coord2D_ts>   tmpCoord;
-			etk::VectorType<coord2D_ts>   tmpCoordOut;
-			tmpCoord.PushBack(coord[iii*3+0]);
-			tmpCoord.PushBack(coord[iii*3+1]);
-			tmpCoord.PushBack(coord[iii*3+2]);
-			
-			SutherlandHodgman(tmpCoord, tmpCoordOut, 0, 0, sizeX, sizeY);
-			tmpCoord.Clear();
-			generatePolyGone(tmpCoordOut, tmpCoord);
-			for (int32_t jjj=0; jjj<tmpCoord.Size(); jjj++) {
-				m_coord.PushBack(tmpCoord[jjj]);
-				m_coordColor.PushBack(color[iii*3+0]);
-			}
-		}
-	}
-}
-
-void ewol::OObject2DColored::GenerateTriangle(void)
-{
-	m_triElement = 0;
-	
-	m_coord.PushBack(m_triangle[0]);
-	m_coordColor.PushBack(m_color[0]);
-	m_coord.PushBack(m_triangle[1]);
-	m_coordColor.PushBack(m_color[1]);
-	m_coord.PushBack(m_triangle[2]);
-	m_coordColor.PushBack(m_color[2]);
-}
-
-
-void ewol::OObject2DColored::SetColor(color_ts color)
-{
-	if (m_triElement < 1) {
-		m_color[0] = color;
-	}
-	if (m_triElement < 2) {
-		m_color[1] = color;
-	}
-	if (m_triElement < 3) {
-		m_color[2] = color;
-	}
-}
-
-
-void ewol::OObject2DColored::SetColor(etkFloat_t red, etkFloat_t green, etkFloat_t blue, etkFloat_t alpha)
-{
-	if (m_triElement < 1) {
-		m_color[0].red = red;
-		m_color[0].green = green;
-		m_color[0].blue = blue;
-		m_color[0].alpha = alpha;
-	}
-	if (m_triElement < 2) {
-		m_color[1].red = red;
-		m_color[1].green = green;
-		m_color[1].blue = blue;
-		m_color[1].alpha = alpha;
-	}
-	if (m_triElement < 3) {
-		m_color[2].red = red;
-		m_color[2].green = green;
-		m_color[2].blue = blue;
-		m_color[2].alpha = alpha;
-	}
-	
-}
-
-void ewol::OObject2DColored::SetPoint(coord2D_ts point)
-{
-	m_triangle[m_triElement] = point;
-	m_triElement++;
-	if (m_triElement>=3) {
-		GenerateTriangle();
-	}
-}
-
-void ewol::OObject2DColored::SetPoint(etkFloat_t x, etkFloat_t y)
-{
-	m_triangle[m_triElement].x = x;
-	m_triangle[m_triElement].y = y;
-	m_triElement++;
-	if (m_triElement>=3) {
-		GenerateTriangle();
-	}
-}
-
-
-void ewol::OObject2DColored::ResetCount(void)
-{
-	m_triElement = 0;
-	m_color[1] = m_color[0];
-	m_color[2] = m_color[0];
-}
-
-void ewol::OObject2DColored::Line(etkFloat_t sx, etkFloat_t sy, etkFloat_t ex, etkFloat_t ey, etkFloat_t thickness)
-{
-	ResetCount();
-	if (sx == ex && sy == ey) {
-		EWOL_WARNING("Try to draw an line width 0");
-		return;
-	}
-	//teta = tan-1(oposer/adjacent)
-	etkFloat_t teta = 0;
-	if (sx <= ex) {
-		teta = atan((ey-sy)/(ex-sx));
-	} else {
-		teta = M_PI + atan((ey-sy)/(ex-sx));
-	}
-	if (teta < 0) {
-		teta += 2*M_PI;
-	} else if (teta > 2*M_PI) {
-		teta -= 2*M_PI;
-	}
-	//EWOL_DEBUG("teta = " << (teta*180/(M_PI)) << " deg." );
-	etkFloat_t offsety = sin(teta-M_PI/2) * (thickness/2);
-	etkFloat_t offsetx = cos(teta-M_PI/2) * (thickness/2);
-
-	SetPoint(sx - offsetx, sy - offsety);
-	SetPoint(sx + offsetx, sy + offsety);
-	SetPoint(ex + offsetx, ey + offsety);
-	
-	SetPoint(ex + offsetx, ey + offsety);
-	SetPoint(ex - offsetx, ey - offsety);
-	SetPoint(sx - offsetx, sy - offsety);
-}
-
-
-void ewol::OObject2DColored::Rectangle(etkFloat_t x, etkFloat_t y, etkFloat_t w, etkFloat_t h)
-{
-	ResetCount();
-
-	SetPoint(x    , y + h);
-	SetPoint(x    , y);
-	SetPoint(x + w, y);
-
-	SetPoint(x + w, y);
-	SetPoint(x + w, y + h);
-	SetPoint(x    , y + h);
-}
-
-void ewol::OObject2DColored::RectangleBorder(etkFloat_t x, etkFloat_t y, etkFloat_t w, etkFloat_t h, etkFloat_t thickness)
-{
-	// TODO : This did not manage the thickness of the line ...
-	Line(x,   y,   x+w, y,   thickness);
-	Line(x+w, y,   x+w, y+h, thickness);
-	Line(x+w, y+h, x,   y+h, thickness);
-	Line(x,   y+h, x,   y,   thickness);
-}
-
-void ewol::OObject2DColored::Circle(etkFloat_t x, etkFloat_t y, etkFloat_t radius, etkFloat_t thickness)
-{
-	ResetCount();
-	if (radius<0) {
-		radius *= -1;
-	}
-	if (radius < thickness/2) {
-		Disc(x, y, thickness/2 + radius);
-	}
-	int32_t nbOcurence = radius;
-	if (nbOcurence < 10)
-	{
-		nbOcurence = 10;
-	}
-	for (int32_t iii=0; iii<nbOcurence; iii++) {
-		
-		etkFloat_t angleOne = 2*M_PI* iii     / nbOcurence ;
-		etkFloat_t offsetExty = sin(angleOne) * (radius+thickness/2);
-		etkFloat_t offsetExtx = cos(angleOne) * (radius+thickness/2);
-		etkFloat_t offsetInty = sin(angleOne) * (radius-thickness/2);
-		etkFloat_t offsetIntx = cos(angleOne) * (radius-thickness/2);
-		
-		etkFloat_t angleTwo = 2*M_PI* (iii+1) / nbOcurence ;
-		etkFloat_t offsetExt2y = sin(angleTwo) * (radius+thickness/2);
-		etkFloat_t offsetExt2x = cos(angleTwo) * (radius+thickness/2);
-		etkFloat_t offsetInt2y = sin(angleTwo) * (radius-thickness/2);
-		etkFloat_t offsetInt2x = cos(angleTwo) * (radius-thickness/2);
-		
-		SetPoint(x + offsetIntx,  y + offsetInty);
-		SetPoint(x + offsetExtx,  y + offsetExty);
-		SetPoint(x + offsetExt2x, y + offsetExt2y);
-		
-		SetPoint(x + offsetExt2x, y + offsetExt2y);
-		SetPoint(x + offsetInt2x, y + offsetInt2y);
-		SetPoint(x + offsetIntx,  y + offsetInty);
-	}
-}
-
-void ewol::OObject2DColored::CirclePart(etkFloat_t x, etkFloat_t y, etkFloat_t radius, etkFloat_t thickness, etkFloat_t angleStart, etkFloat_t angleStop)
-{
-	ResetCount();
-	if (radius<0) {
-		radius *= -1;
-	}
-	if (radius < thickness/2) {
-		Disc(x, y, thickness/2 + radius);
-	}
-	
-	angleStart -= 90;
-	angleStop  -= 90;
-	etkFloat_t AStart = angleStart * (M_PI)/180;
-	//etkFloat_t AStop  = angleStop  * (M_PI)/180;
-	etkFloat_t angleLinear = (angleStop-angleStart)* (M_PI)/180;
-	
-	int32_t nbOcurence = radius;
-	if (nbOcurence < 10)
-	{
-		nbOcurence = 10;
-	}
-	for (int32_t iii=0; iii<nbOcurence; iii++) {
-		
-		etkFloat_t angleOne =  AStart + (angleLinear* iii     / nbOcurence) ;
-		etkFloat_t offsetExty = sin(angleOne) * (radius+thickness/2);
-		etkFloat_t offsetExtx = cos(angleOne) * (radius+thickness/2);
-		etkFloat_t offsetInty = sin(angleOne) * (radius-thickness/2);
-		etkFloat_t offsetIntx = cos(angleOne) * (radius-thickness/2);
-		
-		etkFloat_t angleTwo =  AStart + (angleLinear*  (iii+1) / nbOcurence );
-		etkFloat_t offsetExt2y = sin(angleTwo) * (radius+thickness/2);
-		etkFloat_t offsetExt2x = cos(angleTwo) * (radius+thickness/2);
-		etkFloat_t offsetInt2y = sin(angleTwo) * (radius-thickness/2);
-		etkFloat_t offsetInt2x = cos(angleTwo) * (radius-thickness/2);
-		
-		SetPoint(x + offsetIntx,  y + offsetInty);
-		SetPoint(x + offsetExtx,  y + offsetExty);
-		SetPoint(x + offsetExt2x, y + offsetExt2y);
-		
-		SetPoint(x + offsetExt2x, y + offsetExt2y);
-		SetPoint(x + offsetInt2x, y + offsetInt2y);
-		SetPoint(x + offsetIntx,  y + offsetInty);
-	}
-}
-
-void ewol::OObject2DColored::Disc(etkFloat_t x, etkFloat_t y, etkFloat_t radius)
-{
-	ResetCount();
-	if (radius<0) {
-		radius *= -1;
-	}
-	int32_t nbOcurence = radius*0.50;
-	if (nbOcurence < 15)
-	{
-		nbOcurence = 15;
-	}
-
-	// TODO : Generate a poligone instead if this ...
-	for (int32_t iii=0; iii<nbOcurence; iii++) {
-		SetPoint(x, y);
-		
-		etkFloat_t angleOne = 2*M_PI* iii / nbOcurence ;
-		etkFloat_t offsety = sin(angleOne) * radius;
-		etkFloat_t offsetx = cos(angleOne) * radius;
-		
-		SetPoint(x + offsetx, y + offsety);
-		
-		etkFloat_t angleTwo = 2*M_PI* (iii+1) / nbOcurence ;
-		offsety = sin(angleTwo) * radius;
-		offsetx = cos(angleTwo) * radius;
-		
-		SetPoint(x + offsetx, y + offsety);
-	}
-}
-
-void ewol::OObject2DColored::DiscPart(etkFloat_t x, etkFloat_t y, etkFloat_t radius, etkFloat_t angleStart, etkFloat_t angleStop)
-{
-	ResetCount();
-	if (radius<0) {
-		radius *= -1;
-	}
-	angleStart -= 90;
-	angleStop  -= 90;
-	etkFloat_t AStart = angleStart * (M_PI)/180;
-	//etkFloat_t AStop  = angleStop  * (M_PI)/180;
-	etkFloat_t angleLinear = (angleStop-angleStart)* (M_PI)/180;
-	//EWOL_DEBUG("Write a part of disk " << angleStart << " -> " << angleStop << "  ocurence=" << (angleLinear*180/(M_PI)) );
-	
-	int32_t nbOcurence = radius*0.50;
-	if (nbOcurence < 15)
-	{
-		nbOcurence = 15;
-	}
-	
-	// TODO : Generate a poligone instead if this ...
-	for (int32_t iii=0; iii<nbOcurence; iii++) {
-		SetPoint(x, y);
-		
-		etkFloat_t angleOne = AStart + (angleLinear* iii / nbOcurence) ;
-		etkFloat_t offsety = sin(angleOne) * radius;
-		etkFloat_t offsetx = cos(angleOne) * radius;
-		
-		SetPoint(x + offsetx, y + offsety);
-		
-		etkFloat_t angleTwo = AStart + (angleLinear* (iii+1) / nbOcurence) ;
-		offsety = sin(angleTwo) * radius;
-		offsetx = cos(angleTwo) * radius;
-		
-		SetPoint(x + offsetx, y + offsety);
-	}
-}

Sources/ewol/OObject/2DColored.h

@@ -1,69 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/OObject/2DColored.h
- * @brief ewol OpenGl Object system (header)
- * @author Edouard DUPIN
- * @date 09/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#ifndef __EWOL_O_OBJECT_2D_COLORED_H__
-#define __EWOL_O_OBJECT_2D_COLORED_H__
-
-#include <ewol/OObject.h>
-
-namespace ewol {
-	class OObject2DColored :public ewol::OObject
-	{
-		public:
-			OObject2DColored(void);
-			virtual ~OObject2DColored(void);
-		public:
-			virtual void Draw(void);
-		protected:
-			etk::VectorType<coord2D_ts>   m_coord;       //!< internal coord of the object
-			etk::VectorType<color_ts>     m_coordColor;  //!< internal color of the different point
-			//etk::VectorType<linkCoord_ts> m_linkCoord;   //!< internal link between point to generate triangle
-			int32_t    m_triElement;
-			color_ts   m_color[3];
-			coord2D_ts m_triangle[3];
-			void GenerateTriangle(void);
-			void ResetCount(void);
-		public:
-			void SetColor(etkFloat_t red, etkFloat_t green, etkFloat_t blue, etkFloat_t alpha = 1.0);
-			void SetColor(color_ts color);
-			void SetPoint(coord2D_ts point);
-			void SetPoint(etkFloat_t x, etkFloat_t y);
-			void Line(etkFloat_t sx, etkFloat_t sy, etkFloat_t ex, etkFloat_t ey, etkFloat_t thickness);
-			void Rectangle(etkFloat_t x, etkFloat_t y, etkFloat_t w, etkFloat_t h);
-			//void RectangleAngle(etkFloat_t x, etkFloat_t y, etkFloat_t w, etkFloat_t h, etkFloat_t angle);
-			void RectangleBorder(etkFloat_t x, etkFloat_t y, etkFloat_t w, etkFloat_t h, etkFloat_t thickness);
-			//void RectangleBorder(etkFloat_t x, etkFloat_t y, etkFloat_t w, etkFloat_t h, etkFloat_t thickness, etkFloat_t angle);
-			void Circle(etkFloat_t x, etkFloat_t y, etkFloat_t radius, etkFloat_t thickness);
-			void CirclePart(etkFloat_t x, etkFloat_t y, etkFloat_t radius, etkFloat_t thickness, etkFloat_t angleStart, etkFloat_t angleStop);
-			void Disc(etkFloat_t x, etkFloat_t y, etkFloat_t radius);
-			void DiscPart(etkFloat_t x, etkFloat_t y, etkFloat_t radius, etkFloat_t angleStart, etkFloat_t angleStop);
-		public:
-			// Ewol internal ... : done to update at the origin of the widget ...
-			virtual void UpdateSize(etkFloat_t sizeX, etkFloat_t sizeY);
-			virtual void UpdateOrigin(etkFloat_t x, etkFloat_t y);
-	};
-};
-
-#endif
-

Sources/ewol/OObject/2DText.cpp

@@ -1,108 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/OObject/2DText.cpp
- * @brief ewol OpenGl Object system (Sources)
- * @author Edouard DUPIN
- * @date 09/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#include <ewol/OObject/2DText.h>
-#include <importgl.h>
-
-#undef __class__
-#define __class__	"ewol::OObject2DText"
-
-ewol::OObject2DText::OObject2DText(etk::String FontName, int32_t size, color_ts textColorFg)
-{
-	m_textColorFg = textColorFg;
-	if (FontName == "") {
-		m_FontId = GetDefaultFontId();
-	} else {
-		EWOL_TODO("pas encore fait...");
-		//m_FontId = GetFontIdWithName(FontName);
-		m_FontId = -1;
-		return;
-	}
-}
-// open with default font ...
-ewol::OObject2DText::OObject2DText(void)
-{
-	m_textColorFg.red = 0.0;
-	m_textColorFg.green = 0.0;
-	m_textColorFg.blue = 0.0;
-	m_textColorFg.alpha = 1.0;
-	m_FontId = GetDefaultFontId();
-}
-
-ewol::OObject2DText::~OObject2DText(void)
-{
-	
-}
-
-void ewol::OObject2DText::Draw(void)
-{
-	if (m_coord.Size()<=0) {
-		// TODO : a remètre ...
-		//EWOL_WARNING("Nothink to draw...");
-		return;
-	}
-	glColor4f(m_textColorFg.red, m_textColorFg.green, m_textColorFg.blue, m_textColorFg.alpha);
-	glEnable(GL_TEXTURE_2D);
-	glBindTexture(GL_TEXTURE_2D, m_FontTextureId);
-	glEnableClientState( GL_VERTEX_ARRAY );						// Enable Vertex Arrays
-	glEnableClientState( GL_TEXTURE_COORD_ARRAY );				// Enable Texture Coord Arrays
-	glVertexPointer( 2, oglTypeFloat_t, 0, &m_coord[0] );
-	glTexCoordPointer( 2, oglTypeFloat_t, 0, &m_coordTex[0] );
-	#if !defined(__PLATFORM__Android)
-		glDrawArrays( GL_QUADS, 0, m_coord.Size());
-	#else
-		// NOTE : Android does not support the Quads elements ...
-		glDrawArrays( GL_TRIANGLES, 0, m_coord.Size());
-	#endif
-	//EWOL_DEBUG("request draw of " << m_coord.Size() << " elements");
-	glDisableClientState( GL_VERTEX_ARRAY );					// Disable Vertex Arrays
-	glDisableClientState( GL_TEXTURE_COORD_ARRAY );				// Disable Texture Coord Arrays
-	glDisable(GL_TEXTURE_2D);
-}
-
-void ewol::OObject2DText::Text(etkFloat_t x, etkFloat_t y, const char* utf8String)
-{
-	m_FontTextureId = 0;
-	m_coord.Clear();
-	m_coordTex.Clear();
-	if (m_FontId == -1) {
-		EWOL_ERROR("Font Id is not corectly defined");
-	}
-	coord2D_ts drawPosition;
-	drawPosition.x = x;
-	drawPosition.y = y;
-	ewol::DrawText(m_FontId, drawPosition, utf8String, m_FontTextureId, m_coord, m_coordTex);
-}
-
-void ewol::OObject2DText::UpdateOrigin(etkFloat_t x, etkFloat_t y)
-{
-	for (int32_t iii=0; iii<m_coord.Size(); iii++) {
-		m_coord[iii].x += x;
-		m_coord[iii].y += y;
-	}
-}
-
-
-
-

Sources/ewol/OObject/2DText.h

@@ -1,53 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/OObject/2DText.h
- * @brief ewol OpenGl Object system (header)
- * @author Edouard DUPIN
- * @date 09/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#ifndef __EWOL_O_OBJECT_2D_TEXT_H__
-#define __EWOL_O_OBJECT_2D_TEXT_H__
-
-#include <ewol/OObject.h>
-
-namespace ewol {
-	class OObject2DText :public ewol::OObject
-	{
-		public:
-			OObject2DText(etk::String FontName, int32_t size, color_ts textColorFg);
-			OObject2DText(void);
-			virtual ~OObject2DText(void);
-		public:
-			virtual void Draw(void);
-			// set a specific text
-			void Text(etkFloat_t x, etkFloat_t y, const char* utf8String);
-		protected:
-			int32_t                       m_FontId;        //!< font internal ID
-			color_ts                      m_textColorFg;   //!< text color ...
-			uint32_t                      m_FontTextureId; //!< font internal Texture ID
-			etk::VectorType<coord2D_ts>   m_coord;         //!< internal coord of the object
-			etk::VectorType<texCoord_ts>  m_coordTex;      //!< internal texture coordinate for every point
-		public:
-			virtual void UpdateOrigin(etkFloat_t x, etkFloat_t y);
-	};
-};
-
-#endif
-

Sources/ewol/OObject/2DTextured.cpp

@@ -1,120 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/OObject/2DTextured.cpp
- * @brief ewol OpenGl Object system (Sources)
- * @author Edouard DUPIN
- * @date 09/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#include <ewol/OObject/2DTextured.h>
-#include <ewol/Texture.h>
-#include <importgl.h>
-
-#undef __class__
-#define __class__	"ewol::OObject2DTextured"
-
-
-
-ewol::OObject2DTextured::OObject2DTextured(etk::File textureName)
-{
-	EWOL_DEBUG("Create OObject textured : \"" << textureName << "\"");
-	m_textureId = ewol::LoadTexture(textureName);
-}
-
-ewol::OObject2DTextured::~OObject2DTextured(void)
-{
-	ewol::UnLoadTexture(m_textureId);
-}
-
-void ewol::OObject2DTextured::Draw(void)
-{
-	if (m_coord.Size()<=0) {
-		EWOL_WARNING("Nothink to draw...");
-		return;
-	}
-	
-	glColor4f(1.0, 1.0, 1.0, 1.0);
-	glEnable(GL_TEXTURE_2D);
-	glBindTexture(GL_TEXTURE_2D, m_textureId);
-	glEnableClientState( GL_VERTEX_ARRAY );						// Enable Vertex Arrays
-	glEnableClientState( GL_TEXTURE_COORD_ARRAY );				// Enable Texture Coord Arrays
-	glVertexPointer( 2, oglTypeFloat_t, 0, &m_coord[0] );
-	glTexCoordPointer( 2, oglTypeFloat_t, 0, &m_coordTex[0] );
-	glDrawArrays( GL_TRIANGLES, 0, m_coord.Size());
-	//EWOL_DEBUG("request draw of " << m_coord.Size() << " elements");
-	glDisableClientState( GL_VERTEX_ARRAY );					// Disable Vertex Arrays
-	glDisableClientState( GL_TEXTURE_COORD_ARRAY );				// Disable Texture Coord Arrays
-	glDisable(GL_TEXTURE_2D);
-}
-
-void ewol::OObject2DTextured::Rectangle(etkFloat_t x, etkFloat_t y, etkFloat_t w, etkFloat_t h, etkFloat_t texX, etkFloat_t texY, etkFloat_t texSX, etkFloat_t texSY)
-{
-	//EWOL_DEBUG("Add rectangle : ...");
-	coord2D_ts point;
-	texCoord_ts tex;
-
-	tex.u = texX;
-	tex.v = texY;
-	point.x = x;
-	point.y = y;
-	m_coord.PushBack(point);
-	m_coordTex.PushBack(tex);
-
-
-	tex.u = texSX;
-	tex.v = texY;
-	point.x = x + w;
-	point.y = y;
-	m_coord.PushBack(point);
-	m_coordTex.PushBack(tex);
-
-
-	tex.u = texSX;
-	tex.v = texSY;
-	point.x = x + w;
-	point.y = y + h;
-	m_coord.PushBack(point);
-	m_coordTex.PushBack(tex);
-
-	m_coord.PushBack(point);
-	m_coordTex.PushBack(tex);
-
-	tex.u = texX;
-	tex.v = texSY;
-	point.x = x;
-	point.y = y + h;
-	m_coord.PushBack(point);
-	m_coordTex.PushBack(tex);
-
-	tex.u = texX;
-	tex.v = texY;
-	point.x = x;
-	point.y = y;
-	m_coord.PushBack(point);
-	m_coordTex.PushBack(tex);
-}
-
-void ewol::OObject2DTextured::UpdateOrigin(etkFloat_t x, etkFloat_t y)
-{
-	for (int32_t iii=0; iii<m_coord.Size(); iii++) {
-		m_coord[iii].x += x;
-		m_coord[iii].y += y;
-	}
-}
-

Sources/ewol/OObject/2DTextured.h

@@ -1,49 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/OObject/2DTextured.h
- * @brief ewol OpenGl Object system (header)
- * @author Edouard DUPIN
- * @date 09/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#ifndef __EWOL_O_OBJECT_2D_TEXTURED_H__
-#define __EWOL_O_OBJECT_2D_TEXTURED_H__
-
-#include <ewol/OObject.h>
-
-namespace ewol {
-	class OObject2DTextured :public ewol::OObject
-	{
-		public:
-			OObject2DTextured(etk::File textureName);
-			virtual ~OObject2DTextured(void);
-		public:
-			virtual void Draw(void);
-			void Rectangle(etkFloat_t x, etkFloat_t y, etkFloat_t w, etkFloat_t h, etkFloat_t texX=0.0, etkFloat_t texY=0.0, etkFloat_t texSX=1.0, etkFloat_t texSY=1.0);
-		protected:
-			uint32_t                      m_textureId;   //!< texture internal ID
-			etk::VectorType<coord2D_ts>   m_coord;       //!< internal coord of the object
-			etk::VectorType<texCoord_ts>  m_coordTex;    //!< internal texture coordinate for every point
-		public:
-			virtual void UpdateOrigin(etkFloat_t x, etkFloat_t y);
-	};
-};
-
-#endif
-

Sources/ewol/Texture.cpp

@@ -1,477 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/Texture.cpp
- * @brief ewol Texture loading system (sources)
- * @author Edouard DUPIN
- * @date 28/10/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-
-#include <ewol/Texture.h>
-#include <importgl.h>
-#include <ewol/ewol.h>
-
-extern "C"
-{
-#pragma pack(push,1)
-	typedef struct
-	{
-		int16_t bfType;
-		int32_t bfSize;
-		int32_t bfReserved;
-		int32_t bfOffBits;
-	} bitmapFileHeader_ts;
-	
-	typedef struct
-	{
-		int32_t biSize;
-		int32_t biWidth;
-		int32_t biHeight;
-		int16_t biPlanes;
-		int16_t biBitCount;
-		int32_t biCompression;
-		int32_t biSizeImage;
-		int32_t biXPelsPerMeter;
-		int32_t biYPelsPerMeter;
-		int32_t biClrUsed;
-		int32_t biClrImportant;
-	} bitmapInfoHeader_ts;
-#pragma pack(pop)
-
-	typedef enum {
-		BITS_16_R5G6B5,
-		BITS_16_X1R5G5B5,
-		BITS_24_R8G8B8,
-		BITS_32_X8R8G8B8,
-		BITS_32_A8R8G8B8
-	} modeBitmap_te;
-};
-
-
-#undef __class__
-#define __class__	"ewol::Bitmap"
-
-class Bitmap
-{
-	private:
-		modeBitmap_te       m_dataMode;
-		int32_t             m_width;
-		int32_t             m_height;
-		int32_t             m_size;
-		uint8_t *           m_data;
-		uint8_t *           m_dataGenerate;
-		bitmapFileHeader_ts m_FileHeader;
-		bitmapInfoHeader_ts m_InfoHeader;
-	public:
-		Bitmap(etk::File & fileName) : m_data(NULL), m_dataGenerate(NULL)
-		{
-			m_dataMode = BITS_16_R5G6B5;
-			m_width = 0;
-			m_height = 0;
-			m_size = 0;
-
-			// Get the fileSize ...
-			/*if (fileName.Size() < (int32_t)(sizeof(bitmapFileHeader_ts) + sizeof(bitmapInfoHeader_ts) ) ) {
-				EWOL_ERROR("not enought data in the file named=\"" << fileName << "\"");
-				return;
-			}*/
-			if(false == fileName.fOpenRead() ) {
-				EWOL_ERROR("Can not find the file name=\"" << fileName << "\"");
-				return;
-			}
-			// get the data : 
-			if (fileName.fRead(&m_FileHeader,sizeof(bitmapFileHeader_ts),1) != 1) {
-				EWOL_ERROR("error loading file header");
-				fileName.fClose();
-				return;
-			}
-			if (fileName.fRead(&m_InfoHeader,sizeof(bitmapInfoHeader_ts),1) != 1) {
-				EWOL_ERROR("error loading file header");
-				fileName.fClose();
-				return;
-			}
-			if(false == fileName.fSeek(m_FileHeader.bfOffBits, SEEK_SET)) {
-				EWOL_ERROR("error with the 'bfOffBits' in the file named=\"" << fileName << "\"");
-				fileName.fClose();
-				return;
-			}
-			// Check the header error : 
-			if (m_FileHeader.bfType != 0x4D42) {
-				EWOL_ERROR("the file=\"" << fileName << "\" is not a bitmap file ...");
-				fileName.fClose();
-				return;
-			}
-			if (m_FileHeader.bfReserved != 0x00000000) {
-				EWOL_ERROR("the bfReserved feald is not at 0 ==> not supported format ...");
-				fileName.fClose();
-				return;
-			}
-			if(    m_InfoHeader.biBitCount == 16
-			    && m_InfoHeader.biCompression == 0)
-			{
-				m_dataMode = BITS_16_X1R5G5B5;
-			} else if(    m_InfoHeader.biBitCount == 16
-			         && m_InfoHeader.biCompression == 3)
-			{
-				m_dataMode = BITS_16_R5G6B5;
-			} else if(    m_InfoHeader.biBitCount == 24
-			           && m_InfoHeader.biCompression == 0)
-			{
-				m_dataMode = BITS_24_R8G8B8;
-			} else if(    m_InfoHeader.biBitCount == 32
-			           && m_InfoHeader.biCompression == 3)
-			{
-				m_dataMode = BITS_32_X8R8G8B8;
-			} else if(    m_InfoHeader.biBitCount == 32
-			           && m_InfoHeader.biCompression == 0)
-			{
-				m_dataMode = BITS_32_A8R8G8B8;
-			} else {
-				EWOL_ERROR("the biBitCount & biCompression fealds are unknow ==> not supported format ...");
-				fileName.fClose();;
-				return;
-			}
-			m_width = m_InfoHeader.biWidth;
-			m_height = m_InfoHeader.biHeight;
-			
-			if(0 != m_InfoHeader.biSizeImage)
-			{
-				m_data=new uint8_t[m_InfoHeader.biSizeImage];
-				if (fileName.fRead(m_data,m_InfoHeader.biSizeImage,1) != 1){
-					EWOL_CRITICAL("Can not read the file with the good size...");
-				}
-				// allocate the destination data ...
-				m_dataGenerate=new uint8_t[m_width*m_height*4];
-			}
-			fileName.fClose();
-			// need now to generate RGBA data ...
-			switch(m_dataMode)
-			{
-				case BITS_16_R5G6B5:
-					{
-						uint16_t * pointer = (uint16_t*)m_data;
-						for(int32_t yyy=0; yyy<m_height; yyy++) {
-							for(int32_t xxx=0; xxx<m_width; xxx++) {
-								m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 0] = (int8_t)((*pointer & 0xF800) >> 8);
-								m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 1] = (int8_t)((*pointer & 0x07E0) >> 3);
-								m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 2] = (int8_t)(*pointer << 3);
-								m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 3] = 0xFF;
-								pointer++;
-							}
-						}
-					}
-					break;
-				case BITS_16_X1R5G5B5:
-					{
-						uint16_t * pointer = (uint16_t*)m_data;
-						for(int32_t yyy=0; yyy<m_height; yyy++) {
-							for(int32_t xxx=0; xxx<m_width; xxx++) {
-								m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 0] = (int8_t)((*pointer & 0x7C00) >> 7);
-								m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 1] = (int8_t)((*pointer & 0x03E0) >> 2);
-								m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 2] = (int8_t)(*pointer << 3);
-								m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 3] = 0xFF;
-								pointer++;
-							}
-						}
-					}
-					break;
-				case BITS_24_R8G8B8:
-					{
-						uint8_t * pointer = m_data;
-						for(int32_t yyy=0; yyy<m_height; yyy++) {
-							for(int32_t xxx=0; xxx<m_width; xxx++) {
-								m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 0] = *pointer++;
-								m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 1] = *pointer++;
-								m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 2] = *pointer++;
-								m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 3] = 0xFF;
-							}
-						}
-					}
-					break;
-				case BITS_32_X8R8G8B8:
-					{
-						uint8_t * pointer = m_data;
-						for(int32_t yyy=0; yyy<m_height; yyy++) {
-							for(int32_t xxx=0; xxx<m_width; xxx++) {
-								pointer++;
-								m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 0] = *pointer++;
-								m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 1] = *pointer++;
-								m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 2] = *pointer++;
-								m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 3] = 0xFF;
-							}
-						}
-					}
-					break;
-				case BITS_32_A8R8G8B8:
-					{
-						uint8_t * pointer = m_data;
-						for(int32_t yyy=0; yyy<m_height; yyy++) {
-							for(int32_t xxx=0; xxx<m_width; xxx++) {
-								m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 0] = *pointer++;
-								m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 1] = *pointer++;
-								m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 2] = *pointer++;
-								m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 3] = *pointer++;
-							}
-						}
-					}
-					break;
-				default:
-					EWOL_DEBUG("        mode = ERROR");
-					break;
-			}
-		}
-		
-		~Bitmap(void)
-		{
-			if (NULL != m_data) {
-				delete(m_data);
-			}
-			if (NULL != m_dataGenerate) {
-				delete(m_dataGenerate);
-			}
-		}
-		
-		bool LoadOK(void) { if (NULL != m_dataGenerate) { return true; } else { return false; } };
-		
-		int32_t Width(void)  { return m_width; };
-		int32_t Height(void) { return m_height; };
-		uint8_t * Data(void)   { return m_dataGenerate; };
-		
-		void Display(void)
-		{
-			if (NULL == m_data) {
-				EWOL_ERROR("Might loading error of this Bitmap ...");
-				return;
-			}
-			EWOL_DEBUG(" -----------------------------------------------------------");
-			if (false) {
-				EWOL_DEBUG("Display caracteristic of the bitmap : ");
-				EWOL_DEBUG("    Header of file :");
-				EWOL_DEBUG("        bfType    =" << m_FileHeader.bfType << "      19778 : must always be set to 'BM' to declare that this is a .bmp-file.");
-				EWOL_DEBUG("        bfSize    =" << m_FileHeader.bfSize << "      specifies the size of the file in bytes.");
-				EWOL_DEBUG("        bfReserved=" << m_FileHeader.bfReserved << "      must always be set to zero.");
-				EWOL_DEBUG("        bfOffBits =" << m_FileHeader.bfOffBits << "      1078 : specifies the offset from the beginning of the file to the bitmap data.");
-				EWOL_DEBUG("    info header of file :");
-				EWOL_DEBUG("        biSize         =" << m_InfoHeader.biSize << "      specifies the size of the BITMAPINFOHEADER structure, in bytes.");
-				EWOL_DEBUG("        biWidth        =" << m_InfoHeader.biWidth << "      specifies the width of the image, in pixels.");
-				EWOL_DEBUG("        biHeight       =" << m_InfoHeader.biHeight << "      specifies the height of the image, in pixels.");
-				EWOL_DEBUG("        biPlanes       =" << m_InfoHeader.biPlanes << "      specifies the number of planes of the target device, must be set to zero.");
-				EWOL_DEBUG("        biBitCount     =" << m_InfoHeader.biBitCount << "      specifies the number of bits per pixel.");
-				EWOL_DEBUG("        biCompression  =" << m_InfoHeader.biCompression << "      Specifies the type of compression, usually set to zero (no compression).");
-				EWOL_DEBUG("        biSizeImage    =" << m_InfoHeader.biSizeImage << "      specifies the size of the image data, in bytes. If there is no compression, it is valid to set this member to zero.");
-				EWOL_DEBUG("        biXPelsPerMeter=" << m_InfoHeader.biXPelsPerMeter << "      specifies the the horizontal pixels per meter on the designated targer device, usually set to zero.");
-				EWOL_DEBUG("        biYPelsPerMeter=" << m_InfoHeader.biYPelsPerMeter << "      specifies the the vertical pixels per meter on the designated targer device, usually set to zero.");
-				EWOL_DEBUG("        biClrUsed      =" << m_InfoHeader.biClrUsed << "      speglTexImage2Dcifies the number of colors used in the bitmap, if set to zero the number of colors is calculated using the biBitCount member.");
-				EWOL_DEBUG("        biClrImportant =" << m_InfoHeader.biClrImportant << "      specifies the number of color that are 'important' for the bitmap, if set to zero, all colors are important.");
-			}
-			EWOL_DEBUG("Bitmap : " << m_width << "x" << m_height);
-			switch(m_dataMode)
-			{
-				case BITS_16_R5G6B5:
-					EWOL_DEBUG("        mode = 16 bits R5G6B5");
-					break;
-				case BITS_16_X1R5G5B5:
-					EWOL_DEBUG("        mode = 16 bits X1R5G5B5");
-					break;
-				case BITS_24_R8G8B8:
-					EWOL_DEBUG("        mode = 24 bits R8G8B8");
-					break;
-				case BITS_32_X8R8G8B8:
-					EWOL_DEBUG("        mode = 32 bits X8R8G8B8");
-					break;
-				case BITS_32_A8R8G8B8:
-					EWOL_DEBUG("        mode = 32 bits A8R8G8B8");
-					break;
-				default:
-					EWOL_DEBUG("        mode = ERROR");
-					break;
-			}
-		}
-};
-
-
-
-class LoadedTexture
-{
-	public:
-		etk::File m_filename;
-		int32_t   m_nbTimeLoaded;
-		int32_t   m_imageSize; // must be x=y ...
-		uint32_t  m_openGlTextureID;
-		Bitmap*   m_imageData;
-		bool      m_loaded;
-};
-
-etk::VectorType<LoadedTexture*> listLoadedTexture;
-
-static bool OGLContextLoaded=false;
-
-#undef __class__
-#define __class__	"ewol"
-
-void ewol::TextureOGLContext(bool enable)
-{
-	if (OGLContextLoaded != enable) {
-		OGLContextLoaded = enable;
-		if (true == OGLContextLoaded) {
-			EWOL_WARNING("POST loading the Texture");
-			for (int32_t iii=0; iii < listLoadedTexture.Size(); iii++) {
-				GLuint textureid;
-				glGenTextures(1, &textureid);
-				glBindTexture(GL_TEXTURE_2D, textureid);
-				//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-				//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-				//--- mode nearest
-				//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-				//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-				//#ifdef __PLATFORM__Linux
-				//--- Mode linear
-				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-				//#endif
-				EWOL_WARNING("Set in OpenGl texture =" << listLoadedTexture[iii]->m_imageData->Width() 
-				             << "px different of height=" << listLoadedTexture[iii]->m_imageData->Height() 
-				             << "px in file:" << listLoadedTexture[iii]->m_filename << " in id OGL : " << textureid);
-				glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
-				             listLoadedTexture[iii]->m_imageData->Width(),
-				             listLoadedTexture[iii]->m_imageData->Height(),
-				             0, GL_RGBA, GL_UNSIGNED_BYTE,
-				             listLoadedTexture[iii]->m_imageData->Data());
-				listLoadedTexture[iii]->m_openGlTextureID = textureid;
-				listLoadedTexture[iii]->m_loaded = true;
-			}
-			ewol::ForceRedrawAll();
-		} else {
-			for (int32_t iii=0; iii < listLoadedTexture.Size(); iii++) {
-				EWOL_DEBUG("unlink openGL texture ID=" << iii << " file:" << listLoadedTexture[iii]->m_filename);
-				glDeleteTextures(1,&listLoadedTexture[iii]->m_openGlTextureID);
-				listLoadedTexture[iii]->m_loaded = false;
-				listLoadedTexture[iii]->m_openGlTextureID = -1;
-			}
-		}
-	}
-}
-
-
-
-
-int32_t ewol::LoadTexture(etk::File fileName)
-{
-	if (listLoadedTexture.Size()!=0) {
-		for (int32_t iii=0; iii<listLoadedTexture.Size(); iii++) {
-			if (listLoadedTexture[iii]->m_filename == fileName) {
-				listLoadedTexture[iii]->m_nbTimeLoaded++;
-				return listLoadedTexture[iii]->m_openGlTextureID;
-			}
-		}
-	}
-	etk::String fileExtention = fileName.GetExtention();
-	if (fileExtention ==  "bmp") {
-		if (false == fileName.Exist()) {
-			EWOL_ERROR("File does not Exist ... " << fileName);
-			return -1;
-		}
-		Bitmap * myBitmap = new Bitmap(fileName);
-		myBitmap->Display();
-		if (myBitmap->LoadOK() == true) {
-			if (myBitmap->Width()!= myBitmap->Height()) {
-				EWOL_ERROR("Texture can not have Width=" << myBitmap->Width() << "px different of height=" << myBitmap->Height() << "px in file:" << fileName);
-				return -1;
-			}
-			LoadedTexture *tmpTex = new LoadedTexture();
-			int32_t outTextureID = -1;
-			GLuint textureid = 0;
-			if (NULL != tmpTex) {
-				tmpTex->m_filename        = fileName;
-				tmpTex->m_nbTimeLoaded    = 1;
-				tmpTex->m_imageSize       = myBitmap->Width();
-				tmpTex->m_openGlTextureID = -1;
-				tmpTex->m_imageData       = myBitmap;
-				tmpTex->m_loaded          = false;
-				if (true == OGLContextLoaded) {
-					glGenTextures(1, &textureid);
-					glBindTexture(GL_TEXTURE_2D, textureid);
-					//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-					//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-					//--- mode nearest
-					//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-					//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-					//#ifdef __PLATFORM__Linux
-					//--- Mode linear
-					glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-					glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-					//#endif
-					EWOL_WARNING("Set in OpenGl texture =" << myBitmap->Width() << "px different of height=" << myBitmap->Height() << "px in file:" << fileName << " in id OGL : " <<textureid);
-					glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, myBitmap->Width(), myBitmap->Height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, myBitmap->Data());
-					tmpTex->m_openGlTextureID = textureid;
-					tmpTex->m_loaded = true;
-				}
-				listLoadedTexture.PushBack(tmpTex);
-				outTextureID = listLoadedTexture.Size()-1;
-			} else {
-				EWOL_ERROR("Allocation ERROR... ");
-			}
-			return outTextureID;
-		} else {
-			return -1;
-		}
-	} else {
-		EWOL_ERROR("Extention not managed " << fileName << " Sopported extention : .bmp");
-		return -1;
-	}
-}
-
-void ewol::UnLoadTexture(uint32_t textureID)
-{
-	if (textureID>=0 && (int32_t)textureID<listLoadedTexture.Size()) {
-		listLoadedTexture[textureID]->m_nbTimeLoaded--;
-		if (0 == listLoadedTexture[textureID]->m_nbTimeLoaded) {
-			EWOL_DEBUG("Remove openGL texture ID=" << textureID << " file:" << listLoadedTexture[textureID]->m_filename);
-			if (true == listLoadedTexture[textureID]->m_loaded) {
-				glDeleteTextures(1,&listLoadedTexture[textureID]->m_openGlTextureID);
-			}
-			delete(listLoadedTexture[textureID]);
-			listLoadedTexture[textureID] = NULL;
-			listLoadedTexture.Erase(textureID);
-		}
-		return;
-	}
-	EWOL_CRITICAL("Can not find TextureId=" << (int)textureID << " in the list of texture loaded...==> to remove it ...");
-}
-
-uint32_t ewol::GetTextureGLID(uint32_t textureID)
-{
-	if (textureID>=0 && (int32_t)textureID<listLoadedTexture.Size()) {
-		return listLoadedTexture[textureID]->m_openGlTextureID;
-	}
-	return -1;
-}
-
-
-int32_t ewol::GetTextureSize(uint32_t textureID)
-{
-	for (int32_t iii=0; iii<listLoadedTexture.Size(); iii++) {
-		if (listLoadedTexture[iii]->m_openGlTextureID == textureID) {
-			return listLoadedTexture[iii]->m_imageSize;
-		}
-	}
-	EWOL_ERROR("Can not find TextureId=" << textureID << " in the list of texture loaded...");
-	return -1;
-}

Sources/ewol/Texture.h

@@ -1,50 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/Texture.h
- * @brief ewol Texture loading system (header)
- * @author Edouard DUPIN
- * @date 28/10/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#ifndef __EWOL_TEXTURE_H__
-#define __EWOL_TEXTURE_H__
-
-#include <etk/Types.h>
-#include <ewol/Debug.h>
-#include <etk/File.h>
-
-namespace ewol
-{
-	// TODO : Create a subNameSpace:
-	/*
-	namespace texture {
-		int32_t Load(etk::File fileName);
-		void    UnLoad(uint32_t textureID);
-		int32_t GetSize(uint32_t textureID);
-	};
-	*/
-	int32_t  LoadTexture(etk::File fileName);
-	void     UnLoadTexture(uint32_t textureID);
-	int32_t  GetTextureSize(uint32_t textureID);
-	uint32_t GetTextureGLID(uint32_t textureID);
-	void     TextureOGLContext(bool enable);
-};
-
-#endif
-

Sources/ewol/Widget.cpp

@@ -1,242 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/Widget.cpp
- * @brief basic ewol Widget (Sources)
- * @author Edouard DUPIN
- * @date 18/10/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#include <ewol/Widget.h>
-#include <ewol/WidgetManager.h>
-
-#undef __class__
-#define __class__	"ewol::Widget"
-
-ewol::Widget::Widget(void)
-{
-	m_origin.x = 0.0;
-	m_origin.y = 0.0;
-	m_size.x = 10.0;
-	m_size.y = 10.0;
-	m_minSize.x = -1.0;
-	m_minSize.y = -1.0;
-	// user settings :
-	m_userMinSize.x = -1.0;
-	m_userMinSize.y = -1.0;
-	SetExpendX();
-	SetExpendY();
-	SetFillX();
-	SetFillY();
-	m_genericDraw = true;
-	m_specificDraw = false;
-	ewol::widgetManager::Add(this);
-	m_canFocus = false;
-	m_hasFocus = false;
-}
-
-ewol::Widget::~Widget(void)
-{
-	ewol::widgetManager::Rm(this);
-}
-
-
-
-bool ewol::Widget::CalculateSize(etkFloat_t availlableX, etkFloat_t availlableY)
-{
-	m_size.x = availlableX;
-	m_size.y = availlableY;
-	return true;
-}
-
-
-bool ewol::Widget::GenEventInput(int32_t IdInput, eventInputType_te typeEvent, etkFloat_t x, etkFloat_t y)
-{
-	bool ended = false;
-	//EWOL_WARNING("Input event : " << IdInput << " pos(" << x << "," << y << ")");
-	for(int32_t iii=m_inputEvent.Size()-1; iii>=0; iii--) {
-		if (EWOL_EVENT_AREA == m_inputEvent[iii].mode) {
-			if(    m_inputEvent[iii].area.origin.x <= x
-			    && m_inputEvent[iii].area.origin.y <= y
-			    && m_inputEvent[iii].area.origin.x + m_inputEvent[iii].area.size.x > x
-			    && m_inputEvent[iii].area.origin.y + m_inputEvent[iii].area.size.y > y )
-			{
-				if(    (m_inputEvent[iii].area.flags & (1<<(IdInput-1)) )
-				    && (    (    (FLAG_EVENT_INPUT_MOTION          & m_inputEvent[iii].area.flags) && EVENT_INPUT_TYPE_MOVE   == typeEvent)
-				         || (    (FLAG_EVENT_INPUT_ENTER           & m_inputEvent[iii].area.flags) && EVENT_INPUT_TYPE_ENTER  == typeEvent)
-				         || (    (FLAG_EVENT_INPUT_LEAVE           & m_inputEvent[iii].area.flags) && EVENT_INPUT_TYPE_LEAVE  == typeEvent)
-				         || (    (FLAG_EVENT_INPUT_DOWN            & m_inputEvent[iii].area.flags) && EVENT_INPUT_TYPE_DOWN   == typeEvent)
-				         || (    (FLAG_EVENT_INPUT_UP              & m_inputEvent[iii].area.flags) && EVENT_INPUT_TYPE_UP     == typeEvent)
-				         || (    (FLAG_EVENT_INPUT_CLICKED         & m_inputEvent[iii].area.flags) && EVENT_INPUT_TYPE_SINGLE == typeEvent)
-				         || (    (FLAG_EVENT_INPUT_CLICKED_DOUBLE  & m_inputEvent[iii].area.flags) && EVENT_INPUT_TYPE_DOUBLE == typeEvent)
-				         || (    (FLAG_EVENT_INPUT_CLICKED_TRIPLE  & m_inputEvent[iii].area.flags) && EVENT_INPUT_TYPE_TRIPLE == typeEvent)
-				       )
-				  )
-				{
-					ended = OnEventArea(m_inputEvent[iii].generateEventId, x, y);
-					if (true == ended) {
-						break;
-					}
-					// todo : call other link widget :
-					if (-1 != m_inputEvent[iii].widgetCall) {
-						ewol::Widget * tmpWidget = NULL;
-						//tmpWidget = ewol::GetWidgetWithID(newEvent.widgetCall);
-						ended = tmpWidget->OnEventAreaExternal(ewol::widgetManager::GetId(this), m_inputEvent[iii].generateEventId, x, y);
-						if (true == ended) {
-							break;
-						}
-					}
-				}
-			}
-		}
-	}
-	if (false == ended) {
-		return OnEventInput(IdInput, typeEvent, x, y);
-	}
-	return ended;
-}
-
-
-bool ewol::Widget::GenEventShortCut(bool shift, bool control, bool alt, bool pomme, char UTF8_data[UTF8_MAX_SIZE])
-{
-	return true;
-}
-
-
-bool ewol::Widget::AddEventArea(coord origin, coord size, uint64_t flags, const char * generateEventId)
-{
-	/*
-	if(    origin.x < 0.0
-	    || origin.y < 0.0)
-	{
-		EWOL_WARNING("origin under 0.0 ... out of range");
-		return false;
-	}
-	if(    size.x < 0.0
-	    || size.y < 0.0)
-	{
-		EWOL_WARNING("size under 0.0 ... out of range");
-		return false;
-	}
-	if(    origin.x > m_size.x
-	    || origin.y > m_size.y)
-	{
-		EWOL_WARNING("origin out of range");
-		return false;
-	}
-	if(    origin.x + size.x > m_size.x
-	    || origin.y + size.y > m_size.y)
-	{
-		EWOL_WARNING("end area out of size");
-		return false;
-	}
-	*/
-	event_ts newEvent;
-	newEvent.generateEventId = generateEventId;
-	newEvent.widgetCall = -1; // by default no widget is called
-	newEvent.mode = EWOL_EVENT_AREA;
-	newEvent.area.origin.x = origin.x + m_origin.x;
-	newEvent.area.origin.y = origin.y + m_origin.y;
-	newEvent.area.size = size;
-	newEvent.area.flags = flags;
-	m_inputEvent.PushBack(newEvent);
-	//EWOL_DEBUG("Add an area event...");
-	return true;
-}
-
-
-bool ewol::Widget::AddEventShortCut(bool shift, bool control, bool alt, bool pomme, char UTF8_data[UTF8_MAX_SIZE], const char * generateEventId)
-{
-	return true;
-}
-
-
-bool ewol::Widget::AddEventShortCut(char * descriptiveString, const char * generateEventId)
-{
-	return true;
-}
-
-
-bool ewol::Widget::ExternLinkOnEvent(const char * eventName, int32_t widgetId)
-{
-	return true;
-}
-
-
-
-
-void ewol::Widget::AddOObject(ewol::OObject* newObject, etk::String name)
-{
-	if (NULL == newObject) {
-		EWOL_ERROR("Try to add an empty object in the Widget generic display system : name=\"" << name << "\"");
-		return;
-	}
-	newObject->SetName(name);
-	//EWOL_INFO("UPDATE AT size : (" << m_size.x << "," << m_size.y << ")");
-	newObject->UpdateSize(m_size.x, m_size.y);
-	//EWOL_INFO("UPDATE AT origin : (" << m_origin.x << "," << m_origin.y << ")");
-	newObject->UpdateOrigin(m_origin.x, m_origin.y);
-	m_listOObject.PushBack(newObject);
-}
-
-
-ewol::OObject* ewol::Widget::GetOObject(etk::String name)
-{
-	for (int32_t iii=0; iii<m_listOObject.Size(); iii++) {
-		if (m_listOObject[iii]->GetName() == name) {
-			return m_listOObject[iii];
-		}
-	}
-	return NULL;
-}
-
-void ewol::Widget::RmOObjectElem(etk::String name)
-{
-	for (int32_t iii=0; iii<m_listOObject.Size(); iii++) {
-		if (m_listOObject[iii]->GetName() == name) {
-			delete(m_listOObject[iii]);
-			m_listOObject[iii] = NULL;
-			m_listOObject.Erase(iii);
-			return;
-		}
-	}
-}
-
-void ewol::Widget::ClearOObjectList(void)
-{
-	for (int32_t iii=0; iii<m_listOObject.Size(); iii++) {
-		delete(m_listOObject[iii]);
-		m_listOObject[iii] = NULL;
-	}
-	m_listOObject.Clear();
-}
-
-bool ewol::Widget::GenericDraw(void)
-{
-	for (int32_t iii=0; iii<m_listOObject.Size(); iii++) {
-		if (NULL != m_listOObject[iii]) {
-			m_listOObject[iii]->Draw();
-		}
-	}
-	return true;
-}
-
-
-//} // ???
-
-

Sources/ewol/Widget.h

@@ -1,281 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/Widget.h
- * @brief basic ewol Widget (header)
- * @author Edouard DUPIN
- * @date 18/10/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#ifndef __EWOL_WIDGET_H__
-#define __EWOL_WIDGET_H__
-
-#include <etk/Types.h>
-#include <ewol/Debug.h>
-#include <ewol/OObject.h>
-#include <etk/VectorType.h>
-
-namespace ewol {
-	extern "C" {
-		typedef struct {
-			etkFloat_t x;
-			etkFloat_t y;
-		} coord;
-	}
-	typedef enum {
-		EVENT_INPUT_TYPE_DOWN,
-		EVENT_INPUT_TYPE_MOVE,
-		EVENT_INPUT_TYPE_SINGLE,
-		EVENT_INPUT_TYPE_DOUBLE,
-		EVENT_INPUT_TYPE_TRIPLE,
-		EVENT_INPUT_TYPE_UP,
-		EVENT_INPUT_TYPE_ENTER,
-		EVENT_INPUT_TYPE_LEAVE,
-	} eventInputType_te;
-	
-	typedef enum {
-		EVENT_KB_TYPE_DOWN,
-		EVENT_KB_TYPE_UP,
-	} eventKbType_te;
-	
-	typedef enum {
-		EVENT_KB_MOVE_TYPE_LEFT,
-		EVENT_KB_MOVE_TYPE_RIGHT,
-		EVENT_KB_MOVE_TYPE_UP,
-		EVENT_KB_MOVE_TYPE_DOWN,
-		EVENT_KB_MOVE_TYPE_PAGE_UP,
-		EVENT_KB_MOVE_TYPE_PAGE_DOWN,
-		EVENT_KB_MOVE_TYPE_START,
-		EVENT_KB_MOVE_TYPE_END,
-	} eventKbMoveType_te;
-	
-	enum {
-		FLAG_EVENT_INPUT_1               = 1 << 0,
-		FLAG_EVENT_INPUT_2               = 1 << 1,
-		FLAG_EVENT_INPUT_3               = 1 << 2,
-		FLAG_EVENT_INPUT_4               = 1 << 3,
-		FLAG_EVENT_INPUT_5               = 1 << 4,
-		FLAG_EVENT_INPUT_6               = 1 << 5,
-		FLAG_EVENT_INPUT_7               = 1 << 6,
-		FLAG_EVENT_INPUT_8               = 1 << 7,
-		FLAG_EVENT_INPUT_9               = 1 << 8,
-		FLAG_EVENT_INPUT_10              = 1 << 9,
-		FLAG_EVENT_INPUT_11              = 1 << 10,
-		FLAG_EVENT_INPUT_12              = 1 << 11,
-		FLAG_EVENT_INPUT_13              = 1 << 12,
-		FLAG_EVENT_INPUT_14              = 1 << 13,
-		FLAG_EVENT_INPUT_15              = 1 << 14,
-		FLAG_EVENT_INPUT_16              = 1 << 15,
-		FLAG_EVENT_INPUT_17              = 1 << 16,
-		
-		FLAG_EVENT_INPUT_MOTION          = 1 << 20,
-		FLAG_EVENT_INPUT_ENTER           = 1 << 21,
-		FLAG_EVENT_INPUT_LEAVE           = 1 << 22,
-		FLAG_EVENT_INPUT_DOWN            = 1 << 23,
-		FLAG_EVENT_INPUT_UP              = 1 << 24,
-		FLAG_EVENT_INPUT_CLICKED         = 1 << 25,
-		FLAG_EVENT_INPUT_CLICKED_DOUBLE  = 1 << 26,
-		FLAG_EVENT_INPUT_CLICKED_TRIPLE  = 1 << 27,
-		FLAG_EVENT_INPUT_CLICKED_ALL     = FLAG_EVENT_INPUT_CLICKED + FLAG_EVENT_INPUT_CLICKED_DOUBLE + FLAG_EVENT_INPUT_CLICKED_TRIPLE,
-	};
-	
-	#define FLAG_EVENT_INPUT_BT_LEFT        (FLAG_EVENT_INPUT_1)
-	#define FLAG_EVENT_INPUT_BT_CENTER      (FLAG_EVENT_INPUT_2)
-	#define FLAG_EVENT_INPUT_BT_RIGHT       (FLAG_EVENT_INPUT_3)
-	#define FLAG_EVENT_INPUT_BT_SCROOL_UP   (FLAG_EVENT_INPUT_4)
-	#define FLAG_EVENT_INPUT_BT_SCROOL_DOWN (FLAG_EVENT_INPUT_5)
-	
-	
-	#define UTF8_MAX_SIZE          (8)
-	#define EWOL_EVENT_AREA        (0)
-	#define EWOL_EVENT_SHORTCUT    (1)
-	extern "C" {
-		typedef struct {
-			const char * generateEventId; // event generate ID (to be unique it was pointer on the string name)
-			int32_t widgetCall; //!< unique ID of the widget
-			int32_t mode; //!< EWOL_EVENT_UNION or EWOL_EVENT_SHORTCUT
-			union {
-				struct {
-					bool shift;
-					bool control;
-					bool alt;
-					bool pomme;
-					char UTF8_data[UTF8_MAX_SIZE];
-				} shortCut;
-				struct {
-					coord origin; // widget specific
-					coord size;   // widget specific
-					uint64_t flags; // widget specific
-				} area;
-			};
-		} event_ts;
-	};
-	
-	class Widget;
-	
-	class Widget {
-		public:
-			Widget(void);
-			virtual ~Widget(void);
-		
-		private:
-			ewol::Widget *  m_parrent;   //!< parrent of the current widget (if NULL ==> this is the main node(root))
-		public:
-			void SetParrent(ewol::Widget * newParrent) { m_parrent = newParrent; };
-		
-		// ----------------------------------------------------------------------------------------------------------------
-		// -- Widget Size:
-		// ----------------------------------------------------------------------------------------------------------------
-		protected:
-			// internal element calculated by the system
-			coord          m_origin;        //!< internal ... I do not really known how i can use it ...
-			coord          m_size;          //!< internal : current size of the widget
-			coord          m_minSize;       //!< user define the minimum size of the widget
-			// user configuaration
-			coord          m_userMinSize;   //!< user define the minimum size of the widget
-			bool           m_userExpendX;
-			bool           m_userExpendY;
-			bool           m_userFillX;
-			bool           m_userFillY;
-		public:
-			void           SetOrigin(etkFloat_t x, etkFloat_t y) { m_origin.x=x; m_origin.y=y; };
-			coord          GetOrigin(void) { return m_origin; };
-			virtual bool   CalculateSize(etkFloat_t availlableX, etkFloat_t availlableY); // this generate the current size ...
-			virtual bool   CalculateMinSize(void) {m_minSize.x = m_userMinSize.x; m_minSize.y = m_userMinSize.y; return true; }; //update the min Size ... and the expend parameters for the sizer
-			virtual void   SetMinSise(etkFloat_t x=-1, etkFloat_t y=-1) { m_userMinSize.x = x; m_userMinSize.y = y; };
-			coord          GetMinSize(void) { return m_minSize; };
-			coord          GetSize(void) { return m_size; };
-			void           SetCurrentSise(etkFloat_t x=-1, etkFloat_t y=-1) { m_size.x = x; m_size.y = y; };
-			coord          GetCurrentSize(void) { return m_size; };
-			virtual void   SetExpendX(bool newExpend=false) { m_userExpendX = newExpend; };
-			bool           CanExpentX(void) { return m_userExpendX; };
-			virtual void   SetExpendY(bool newExpend=false) { m_userExpendY = newExpend; };
-			bool           CanExpentY(void) { return m_userExpendY; };
-			virtual void   SetFillX(bool newFill=false) { m_userFillX = newFill; };
-			bool           CanFillX(void) { return m_userFillX; };
-			virtual void   SetFillY(bool newFill=false) { m_userFillY = newFill; };
-			bool           CanFillY(void) { return m_userFillY; };
-		
-		// ----------------------------------------------------------------------------------------------------------------
-		// -- Focus Area
-		// ----------------------------------------------------------------------------------------------------------------
-		private:
-			bool    m_hasFocus;        //!< set the focus on this widget
-			bool    m_canFocus;        //!< the focus can be done on this widget
-		public:
-			bool    SetFocus(void)
-			{
-				if (true == m_canFocus) {
-					m_hasFocus = true;
-					OnGetFocus();
-					return true;
-				}
-				return false;
-			}
-			bool    RmFocus(void)
-			{
-				if (true == m_canFocus) {
-					m_hasFocus = false;
-					OnLostFocus();
-					return true;
-				}
-				return false;
-			}
-			bool    GetFocus(void) { return m_hasFocus;};
-			bool    CanHaveFocus(void) { return m_canFocus;};
-			void    SetCanHaveFocus(bool canFocusState)
-			{
-				m_canFocus = canFocusState;
-				if (true == m_hasFocus) {
-					(void)RmFocus();
-				}
-			}
-		protected:
-			virtual void OnGetFocus(void) {};
-			virtual void OnLostFocus(void) {};
-		
-		// ----------------------------------------------------------------------------------------------------------------
-		// -- Input Event on the widget : The input is the muse for a computer, or the finger for the tablettes
-		// -- Shortcut: (only for computer) ==> must be manage otherwise for tablette pc
-		// ----------------------------------------------------------------------------------------------------------------
-		private:
-			etk::VectorType<event_ts> m_inputEvent;     //!< generic area and short-cut event
-		public:
-			// external acces to set an input event on this widget.
-			bool GenEventInput(int32_t IdInput, eventInputType_te typeEvent, etkFloat_t X, etkFloat_t Y); // call when input event arrive and call OnEventInput, if no event detected
-			bool GenEventShortCut(bool shift, bool control, bool alt, bool pomme, char UTF8_data[UTF8_MAX_SIZE]);
-		protected:
-			void EventAreaRemoveAll(void) { m_inputEvent.Clear(); };
-			bool AddEventArea(coord origin, coord size, uint64_t flags, const char * generateEventId);
-			bool AddEventShortCut(bool shift, bool control, bool alt, bool pomme, char UTF8_data[UTF8_MAX_SIZE], const char * generateEventId);
-			bool AddEventShortCut(char * descriptiveString, const char * generateEventId);
-		public:
-			// to link an extern widget at the internal event of this one it will access by here :
-			bool ExternLinkOnEvent(const char * eventName, int32_t widgetId);
-		protected:
-			virtual bool OnEventInput(int32_t IdInput, eventInputType_te typeEvent, etkFloat_t X, etkFloat_t Y) { return false; };
-			virtual bool OnEventArea(const char * generateEventId, etkFloat_t x, etkFloat_t y) { return false; };
-			// when an event arrive from an other widget, it will arrive here:
-			virtual bool OnEventAreaExternal(int32_t widgetID, const char * generateEventId, etkFloat_t x, etkFloat_t y) { return false; };
-		
-		// ----------------------------------------------------------------------------------------------------------------
-		// -- Keboard event (when one is present or when a graphical is present
-		// ----------------------------------------------------------------------------------------------------------------
-		public:
-			virtual bool OnEventKb(eventKbType_te typeEvent, char UTF8_data[UTF8_MAX_SIZE]) { return false; };
-			virtual bool OnEventKbMove(eventKbType_te typeEvent, eventKbMoveType_te moveTypeEvent) { return false; };
-		
-		
-		// ----------------------------------------------------------------------------------------------------------------
-		// -- Drawing : Special case ==> have internal system drawing management to prevent reconstriction of a widget
-		// --           this will automaticly regenerate the same view in openGL
-		// ----------------------------------------------------------------------------------------------------------------
-		private:
-			bool m_genericDraw;
-			bool m_specificDraw;
-			etk::VectorType<ewol::OObject*> m_listOObject;   //!< generic element to display...
-			bool GenericDraw(void);
-		protected:
-			void AddOObject(ewol::OObject* newObject, etk::String name = "");
-			ewol::OObject* GetOObject(etk::String name);
-			void RmOObjectElem(etk::String name);
-			void ClearOObjectList(void);
-			void GenericDrawDisable(void) { m_genericDraw = false; };
-			void GenericDrawEnable(void) { m_genericDraw = true; };
-			void SpecificDrawDisable(void) { m_specificDraw = false; };
-			void SpecificDrawEnable(void) { m_specificDraw = true; };
-			virtual bool OnDraw(void) { /*EWOL_ERROR("plop");*/ return true; };
-		public:
-			virtual void OnRegenerateDisplay(void) { };
-			bool GenDraw(void)
-			{
-				if (true == m_genericDraw) {
-					//EWOL_DEBUG("Draw generic...");
-					GenericDraw();
-				}
-				if (true == m_specificDraw) {
-					//EWOL_DEBUG("Draw Custum...");
-					OnDraw();
-				}
-				return true;
-			};
-
-	}; // end of the class Widget declaration
-};// end of nameSpace
-
-#endif

Sources/ewol/WidgetManager.cpp

@@ -1,189 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/WidgetManager.cpp
- * @brief basic ewol Widget Manager (Sources)
- * @author Edouard DUPIN
- * @date 13/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#include <ewol/WidgetManager.h>
-
-#undef __class__
-#define __class__	"ewol::WidgetManager"
-
-
-// internal element of the widget manager : 
-static etk::VectorType<ewol::Widget*>   m_widgetList;   // all widget allocated ==> all time increment ... never removed ...
-// For the focus Management
-static ewol::Widget * m_focusWidgetDefault = NULL;
-static ewol::Widget * m_focusWidgetCurrent = NULL;
-
-void ewol::widgetManager::Init(void)
-{
-	EWOL_INFO("user widget manager");
-}
-
-void ewol::widgetManager::UnInit(void)
-{
-	EWOL_INFO("Realease all FOCUS");
-	ewol::widgetManager::FocusSetDefault(NULL);
-	ewol::widgetManager::FocusRelease();
-	
-	EWOL_INFO(" Remove missing user widget");
-	for(int32_t iii=0; iii<m_widgetList.Size(); iii++) {
-		if (m_widgetList[iii]!=NULL) {
-			EWOL_WARNING("Un-Removed widget ... id=" << iii);
-			delete(m_widgetList[iii]);
-			m_widgetList[iii]=NULL;
-		}
-	}
-	m_widgetList.Clear();
-}
-
-void ewol::widgetManager::Add(ewol::Widget * newWidget)
-{
-	// Check existance
-	int32_t tmpID = ewol::widgetManager::GetId(newWidget);
-	if (-1 == tmpID) {
-		m_widgetList.PushBack(newWidget);
-	} else {
-		EWOL_WARNING("Widget Already added to the widget manager, id=" << tmpID);
-	}
-}
-
-void ewol::widgetManager::Rm(ewol::Widget * newWidget)
-{
-	// check existance
-	int32_t tmpID = ewol::widgetManager::GetId(newWidget);
-	if (-1 != tmpID) {
-		ewol::widgetManager::Rm(tmpID);
-	} else {
-		EWOL_ERROR("Widget already removed ...");
-	}
-}
-
-void ewol::widgetManager::Rm(int32_t widgetId)
-{
-	if (0 <= widgetId && widgetId < m_widgetList.Size()) {
-		if (m_widgetList[widgetId]!=NULL) {
-			if (m_focusWidgetCurrent==m_widgetList[widgetId]) {
-				ewol::widgetManager::FocusRelease();
-			}
-			if (m_focusWidgetDefault==m_widgetList[widgetId]) {
-				ewol::widgetManager::FocusSetDefault(NULL);
-			}
-			m_widgetList[widgetId]=NULL;
-		}
-	}
-}
-
-int32_t ewol::widgetManager::GetId(ewol::Widget * newWidget)
-{
-	if (NULL == newWidget) {
-		return -1;
-	}
-	for(int32_t iii=0; iii<m_widgetList.Size(); iii++) {
-		if (m_widgetList[iii] == newWidget) {
-			return iii;
-		}
-	}
-	return -1;
-}
-
-ewol::Widget * ewol::widgetManager::Get(int32_t widgetId)
-{
-	if (0 <= widgetId && widgetId < m_widgetList.Size()) {
-		return m_widgetList[widgetId];
-	}
-	return NULL;
-}
-
-/* *************************************************************************
- * Focus Area : 
- * *************************************************************************/
-
-void ewol::widgetManager::FocusKeep(ewol::Widget * newWidget)
-{
-	if (NULL == newWidget) {
-		// nothing to do ...
-		return;
-	}
-	if (false == newWidget->CanHaveFocus()) {
-		EWOL_VERBOSE("Widget can not have Focus, id=" << ewol::widgetManager::GetId(newWidget));
-		return;
-	}
-	if (newWidget == m_focusWidgetCurrent) {
-		// nothing to do ...
-		return;
-	}
-	if (NULL != m_focusWidgetCurrent) {
-		EWOL_DEBUG("Rm Focus on WidgetID=" << ewol::widgetManager::GetId(m_focusWidgetCurrent));
-		m_focusWidgetCurrent->RmFocus();
-	}
-	m_focusWidgetCurrent = newWidget;
-	if (NULL != m_focusWidgetCurrent) {
-		EWOL_DEBUG("Set Focus on WidgetID=" << ewol::widgetManager::GetId(m_focusWidgetCurrent));
-		m_focusWidgetCurrent->SetFocus();
-	}
-}
-
-
-void ewol::widgetManager::FocusSetDefault(ewol::Widget * newWidget)
-{
-	if (NULL != newWidget && false == newWidget->CanHaveFocus()) {
-		EWOL_VERBOSE("Widget can not have Focus, id=" << ewol::widgetManager::GetId(newWidget));
-		return;
-	}
-	if (m_focusWidgetDefault == m_focusWidgetCurrent) {
-		if (NULL != m_focusWidgetCurrent) {
-			EWOL_DEBUG("Rm Focus on WidgetID=" << ewol::widgetManager::GetId(m_focusWidgetCurrent));
-			m_focusWidgetCurrent->RmFocus();
-		}
-		m_focusWidgetCurrent = newWidget;
-		if (NULL != m_focusWidgetCurrent) {
-			EWOL_DEBUG("Set Focus on WidgetID=" << ewol::widgetManager::GetId(m_focusWidgetCurrent));
-			m_focusWidgetCurrent->SetFocus();
-		}
-	}
-	m_focusWidgetDefault = newWidget;
-}
-
-
-void ewol::widgetManager::FocusRelease(void)
-{
-	if (m_focusWidgetDefault == m_focusWidgetCurrent) {
-		// nothink to do ...
-		return;
-	}
-	if (NULL != m_focusWidgetCurrent) {
-		EWOL_DEBUG("Rm Focus on WidgetID=" << ewol::widgetManager::GetId(m_focusWidgetCurrent));
-		m_focusWidgetCurrent->RmFocus();
-	}
-	m_focusWidgetCurrent = m_focusWidgetDefault;
-	if (NULL != m_focusWidgetCurrent) {
-		EWOL_DEBUG("Set Focus on WidgetID=" << ewol::widgetManager::GetId(m_focusWidgetCurrent));
-		m_focusWidgetCurrent->SetFocus();
-	}
-}
-
-
-ewol::Widget * ewol::widgetManager::FocusGet(void)
-{
-	return m_focusWidgetCurrent;
-}

Sources/ewol/WidgetManager.h

@@ -1,52 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/WidgetManager.h
- * @brief basic ewol Widget Manager (Header)
- * @author Edouard DUPIN
- * @date 13/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#ifndef __EWOL_WIDGET_MANAGER_H__
-#define __EWOL_WIDGET_MANAGER_H__
-
-#include <etk/Types.h>
-#include <ewol/Debug.h>
-#include <ewol/OObject.h>
-#include <etk/VectorType.h>
-#include <ewol/Widget.h>
-
-namespace ewol {
-	namespace widgetManager {
-			void           Init(  void);
-			void           UnInit(void);
-			void           Add(   ewol::Widget * newWidget);
-			void           Rm(    ewol::Widget * newWidget);
-			void           Rm(    int32_t widgetId);
-			int32_t        GetId( ewol::Widget * newWidget);
-			ewol::Widget * Get(   int32_t widgetId);
-			
-			void           FocusKeep(      ewol::Widget * newWidget); // set the focus at the specific widget
-			void           FocusSetDefault(ewol::Widget * newWidget); // select the default focus getter
-			void           FocusRelease(   void); // Release focus from the current widget to the default
-			ewol::Widget * FocusGet(       void);
-	};
-};
-
-#endif
-

Sources/ewol/Windows.cpp

@@ -1,220 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/Windows.cpp
- * @brief ewol window system (sources)
- * @author Edouard DUPIN
- * @date 20/10/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#include <etk/Types.h>
-#include <etk/String.h>
-#include <ewol/Widget.h>
-#include <ewol/Windows.h>
-#include <ewol/OObject.h>
-#include <ewol/Texture.h>
-#include <ewol/Font.h>
-#include <ewol/ewol.h>
-#include <importgl.h>
-
-
-
-#undef __class__
-#define __class__	"ewol::Windows"
-
-
-//list of local events : 
-const char * ewolEventWindowsClose    = "ewol Windows close";
-const char * ewolEventWindowsMinimize = "ewol Windows minimize";
-const char * ewolEventWindowsExpend   = "ewol Windows expend/unExpend";
-
-
-ewol::Windows::Windows(void)
-{
-	SetCanHaveFocus(true);
-	m_subWidget = NULL;
-	// enable specific drawing system ...
-	SpecificDrawEnable();
-	
-	SetDecorationDisable();
-	if (true == m_hasDecoration) {
-		ewol::OObject2DColored * myOObject = new ewol::OObject2DColored();
-		// Close
-		myOObject->SetColor(1.0, 0.0, 0.0, 1.0);
-		myOObject->Rectangle( 0, 0, 20, 20);
-		// Reduce
-		myOObject->SetColor(0.0, 1.0, 0.0, 1.0);
-		myOObject->Rectangle(20, 0, 20, 20);
-		// Expend - Un-expend
-		myOObject->SetColor(0.0, 0.0, 1.0, 1.0);
-		myOObject->Rectangle(40, 0, 20, 20);
-		coord origin;
-		coord size;
-		origin.x = 0.0;
-		origin.y = 0.0;
-		size.x = 20;
-		size.y = 20;
-		AddEventArea(origin, size, FLAG_EVENT_INPUT_1 | FLAG_EVENT_INPUT_CLICKED_ALL, ewolEventWindowsClose);
-		origin.x = 20.0;
-		AddEventArea(origin, size, FLAG_EVENT_INPUT_1 | FLAG_EVENT_INPUT_CLICKED_ALL, ewolEventWindowsMinimize);
-		origin.x = 40.0;
-		AddEventArea(origin, size, FLAG_EVENT_INPUT_1 | FLAG_EVENT_INPUT_CLICKED_ALL, ewolEventWindowsExpend);
-		
-		AddOObject(myOObject, "leftBoutton");
-		
-		ewol::OObject2DText * myOObjectText = new ewol::OObject2DText();
-		myOObjectText->Text(62, 2, "My Title ...");
-		AddOObject(myOObjectText, "Title");
-	}
-}
-
-ewol::Windows::~Windows(void)
-{
-	if (NULL != m_subWidget) {
-		delete(m_subWidget);
-		m_subWidget=NULL;
-	}
-}
-
-bool ewol::Windows::CalculateSize(etkFloat_t availlableX, etkFloat_t availlableY)
-{
-	m_size.x = availlableX;
-	m_size.y = availlableY;
-	if (NULL != m_subWidget) {
-		m_subWidget->CalculateMinSize();
-		// TODO : Check if min Size is possible ...
-		// TODO : Herited from MinSize .. and expand ???
-		m_subWidget->CalculateSize(m_size.x, m_size.y);
-	}
-	// regenerate all the display ...
-	OnRegenerateDisplay();
-	return true;
-}
-
-
-bool ewol::Windows::OnEventInput(int32_t IdInput, eventInputType_te typeEvent, etkFloat_t x, etkFloat_t y)
-{
-	if (true == m_hasDecoration) {
-		if(    x >= 60
-		    && y <=20)
-		{
-			if(EVENT_INPUT_TYPE_MOVE == typeEvent && true == ewol::IsPressedInput(1) ) {
-				ewol::StartMoveSystem();
-			}
-		}
-		if(    x >= m_size.x - 20
-		    && y >= m_size.y - 20)
-		{
-			if(EVENT_INPUT_TYPE_MOVE == typeEvent && true == ewol::IsPressedInput(1) ) {
-				ewol::StartResizeSystem();
-			}
-		}
-	}
-	if (NULL != m_subWidget) {
-		m_subWidget->GenEventInput(IdInput, typeEvent, x, y);
-	}
-	return true;
-}
-
-void ewol::Windows::SysDraw(void)
-{
-
-	//EWOL_DEBUG("Drow on (" << m_size.x << "," << m_size.y << ")");
-	// set the size of the open GL system
-	glViewport(0,0,m_size.x,m_size.y);
-	
-	// Clear the screen with transparency ...
-	glClearColor(0.750, 0.750, 0.750, 0.5);
-	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-	
-	glMatrixMode(GL_PROJECTION);
-	glLoadIdentity();
-#if defined(__PLATFORM__Android)
-	glOrtho(-m_size.x/2, m_size.x/2, m_size.y/2, -m_size.y/2, -1, 1);
-	glMatrixMode(GL_MODELVIEW);
-	glLoadIdentity();
-	
-	glTranslatef(-m_size.x/2, -m_size.y/2, -1.0);
-#else
-	glOrtho(0., m_size.x, 0., -m_size.y, 1., 20.);
-	
-	glMatrixMode(GL_MODELVIEW);
-	glLoadIdentity();
-	glTranslatef(0, -m_size.y, -5);
-#endif
-	//http://www.khronos.org/opengles/documentation/opengles1_0/html/glBlendFunc.html
-	glEnable(GL_BLEND);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	//glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_DST_ALPHA);
-	//glBlendFunc(GL_SRC_ALPHA, GL_SRC_COLOR);
-
-	GenDraw();
-
-	glDisable(GL_BLEND);
-	return;
-}
-
-void ewol::Windows::OnRegenerateDisplay(void)
-{
-	if (NULL != m_subWidget) {
-		m_subWidget->OnRegenerateDisplay();
-	}
-}
-
-
-bool ewol::Windows::OnDraw(void)
-{
-	if (NULL != m_subWidget) {
-		m_subWidget->GenDraw();
-	}
-	return true;
-}
-
-bool ewol::Windows::OnEventArea(const char * generateEventId, etkFloat_t x, etkFloat_t y)
-{
-	bool eventIsOK = false;
-	//EWOL_DEBUG("Receive event : \"" << generateEventId << "\"");
-	if(ewolEventWindowsClose == generateEventId) {
-		EWOL_INFO("Request close of the windows");
-		ewol::Stop();
-		eventIsOK = true;
-	} else if(ewolEventWindowsMinimize == generateEventId) {
-		EWOL_INFO("Request Minimize of the windows");
-		eventIsOK = true;
-	} else if(ewolEventWindowsExpend == generateEventId) {
-		EWOL_INFO("Request Expend of the windows");
-		eventIsOK = true;
-	}
-	
-	return eventIsOK;
-}
-
-
-
-void ewol::Windows::SetSubWidget(ewol::Widget * widget)
-{
-	if (NULL != m_subWidget) {
-		EWOL_INFO("Remove current main windows Widget...");
-		delete(m_subWidget);
-		m_subWidget = NULL;
-	}
-	m_subWidget = widget;
-	// Regenerate the size calculation :
-	CalculateSize(m_size.x, m_size.y);
-}
-

Sources/ewol/Windows.h

@@ -1,83 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/Windows.h
- * @brief ewol window system (header)
- * @author Edouard DUPIN
- * @date 20/10/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#ifndef __EWOL_WINDOWS_H__
-#define __EWOL_WINDOWS_H__
-
-#include <etk/Types.h>
-#include <ewol/Debug.h>
-#include <etk/VectorType.h>
-#include <etk/Singleton.h>
-#include <ewol/Widget.h>
-
-namespace ewol {
-	class Windows :public ewol::Widget
-	{
-		public:
-			Windows(void);
-			virtual ~Windows(void);
-		// internal event at ewol system : 
-		public:
-			void SysDraw(void);
-			void SysOnShow(void) {};
-			void SysOnHide(void) {};
-			void SysOnKill(void) {};
-			void SysOnExpose(void) {};
-		public:
-			virtual void OnShow(void) { };
-			virtual void OnHide(void) { };
-			virtual bool OnKill(void) { return true; };
-			virtual void OnReduce(void) { };
-			virtual void On(void) { };
-		// from Widget management : 
-			virtual bool CalculateSize(etkFloat_t availlableX, etkFloat_t availlableY);
-			virtual bool OnEventArea(const char * generateEventId, etkFloat_t x, etkFloat_t y);
-		// Widget overwrite function
-		public:
-			virtual bool OnEventInput(int32_t IdInput, eventInputType_te typeEvent, etkFloat_t x, etkFloat_t y);
-		private:
-			bool m_hasDecoration;
-		public:
-			void SetDecorationDisable(void)
-			{
-				m_hasDecoration = false;
-			}
-			
-			void SetDecorationEnable(void)
-			{
-				m_hasDecoration = true;
-			}
-		private:
-			ewol::Widget *  m_subWidget;
-		public:
-			void SetSubWidget(ewol::Widget * widget);
-		protected:
-			virtual bool   OnDraw(void);
-		public:
-			virtual void OnRegenerateDisplay(void);
-	};
-};
-
-#endif
-

Sources/ewol/ewol.cpp

@@ -1,118 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/ewol.cpp
- * @brief Main code of ewol (sources)
- * @author Edouard DUPIN
- * @date 17/10/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-#include <ewol/ewol.h>
-#include <ewol/Font.h>
-#include <ewol/WidgetManager.h>
-#include <ewol/themeManager.h>
-
-#include <base/gui.h>
-
-#undef __class__
-#define __class__	"ewol"
-
-void ewol::Init(int argc, char *argv[])
-{
-	EWOL_INFO("v" EWOL_VERSION_TAG_NAME);
-	EWOL_INFO("Build Date: " VERSION_BUILD_TIME);
-	guiAbstraction::Init(argc, argv);
-	ewol::theme::Init();
-	ewol::widgetManager::Init();
-	ewol::InitFont();
-}
-
-void ewol::Run(void)
-{
-	guiAbstraction::Run();
-}
-
-void ewol::UnInit(void)
-{
-	guiAbstraction::UnInit();
-	ewol::UnInitFont();
-	ewol::widgetManager::UnInit();
-	ewol::theme::UnInit();
-}
-
-
-void ewol::DisplayWindows(ewol::Windows * windows)
-{
-	// Remove current Focus :
-	ewol::widgetManager::FocusSetDefault(NULL);
-	ewol::widgetManager::FocusRelease();
-	// set display of the windows :
-	guiAbstraction::SetDisplayOnWindows(windows);
-	// Set the new default Focus :
-	ewol::widgetManager::FocusSetDefault(windows);
-}
-
-
-void ewol::Stop(void)
-{
-	guiAbstraction::Stop();
-}
-
-
-void ewol::ChangeSize(int32_t w, int32_t h)
-{
-	guiAbstraction::ChangeSize(w, h);
-}
-
-void ewol::ChangePos(int32_t x, int32_t y)
-{
-	guiAbstraction::ChangePos(x, y);
-}
-
-void ewol::GetAbsPos(int32_t & x, int32_t & y)
-{
-	guiAbstraction::GetAbsPos(x, y);
-}
-
-
-void ewol::StartResizeSystem(void)
-{
-#ifdef __PLATFORM__Linux
-	guiAbstraction::StartResizeSystem();
-#endif
-}
-
-void ewol::StartMoveSystem(void)
-{
-#ifdef __PLATFORM__Linux
-	guiAbstraction::StartMoveSystem();
-#endif
-}
-
-
-bool ewol::IsPressedInput(int32_t inputID)
-{
-	return guiAbstraction::IsPressedInput(inputID);
-}
-
-void ewol::ForceRedrawAll(void)
-{
-	guiAbstraction::ForceRedrawAll();
-}
-

Sources/ewol/ewol.h

@@ -1,51 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/ewol.h
- * @brief Main include of ewol (header)
- * @author Edouard DUPIN
- * @date 17/10/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-#ifndef __EWOL_H__
-#define __EWOL_H__
-
-#include <etk/Types.h>
-#include <etk/String.h>
-#include <ewol/Widget.h>
-#include <ewol/Windows.h>
-
-namespace ewol {
-	void Init(int32_t argc, char *argv[]);
-	void Run(void);
-	void Stop(void);
-	void UnInit(void);
-	void DisplayWindows(ewol::Windows * windows);
-	void ChangeSize(int32_t w, int32_t h);
-	void ChangePos(int32_t x, int32_t y);
-	void GetAbsPos(int32_t & x, int32_t & y);
-	void StartResizeSystem(void);
-	void StartMoveSystem(void);
-	bool IsPressedInput(int32_t inputID);
-	void ForceRedrawAll(void);
-};
-
-
-
-#endif

Sources/ewol/file.mk

@@ -1,46 +0,0 @@
-
-
-FILE_LIST = \
-			tinyXML/tinyxml.cpp \
-			tinyXML/tinyxmlparser.cpp \
-			tinyXML/tinyxmlerror.cpp \
-			tinyXML/tinystr.cpp \
-			etk/Debug.cpp \
-			etk/DebugInternal.cpp \
-			etk/Memory.cpp \
-			etk/String.cpp \
-			etk/Stream.cpp \
-			etk/File.cpp \
-			etk/RegExp.cpp \
-			ewol/ewol.cpp \
-			ewol/Debug.cpp \
-			ewol/OObject.cpp \
-			ewol/OObject/2DText.cpp \
-			ewol/OObject/2DColored.cpp \
-			ewol/OObject/2DTextured.cpp \
-			ewol/Texture.cpp \
-			ewol/FontBitmap.cpp \
-			ewol/Widget.cpp \
-			ewol/WidgetManager.cpp \
-			ewol/Windows.cpp \
-			ewol/widget/Button.cpp \
-			ewol/widget/CheckBox.cpp \
-			ewol/widget/Entry.cpp \
-			ewol/widget/List.cpp \
-			ewol/widget/SizerHori.cpp \
-			ewol/widget/SizerVert.cpp \
-			ewol/widget/Test.cpp \
-			ewol/themeManager.cpp \
-			ewol/theme/Theme.cpp \
-			ewol/theme/EolElement.cpp \
-			ewol/theme/EolElementFrame.cpp \
-			ewol/theme/EolColor.cpp \
-			ewol/theme/EolBase.cpp \
-			ewol/theme/EolBaseCircle.cpp \
-			ewol/theme/EolBaseCirclePart.cpp \
-			ewol/theme/EolBaseLine.cpp \
-			ewol/theme/EolBasePolygone.cpp \
-			ewol/theme/EolBaseRect.cpp \
-			ewol/theme/EolBaseTriangle.cpp
-
-

Sources/ewol/theme/EolBase.cpp

@@ -1,47 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/theme/EolBase.cpp
- * @brief basic ewol theme eol file basic element Virtual Classes (Sources)
- * @author Edouard DUPIN
- * @date 23/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#include <ewol/theme/Theme.h>
-#include <ewol/theme/EolBase.h>
-
-#undef __class__
-#define __class__	"ewol::theme::EolBase"
-
-
-ewol::theme::EolBase::EolBase(void)
-{
-	//EWOL_DEBUG("new...");
-}
-
-ewol::theme::EolBase::~EolBase(void)
-{
-	
-}
-
-/*
-void ewol::theme::EolBase::Parse(TiXmlNode * pNode)
-{
-	EWOL_INFO("Element Base .. Generic ... nothing to parse..." );
-}
-*/

Sources/ewol/theme/EolBase.h

@@ -1,50 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/theme/EolBase.h
- * @brief basic ewol theme eol file basic element virtual Classes (Header)
- * @author Edouard DUPIN
- * @date 23/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-
-#ifndef __EWOL_THEME_EOL_BASE__H__
-#define __EWOL_THEME_EOL_BASE__H__
-
-#include <etk/Types.h>
-#include <etk/String.h>
-#include <ewol/OObject.h>
-#include <tinyXML/tinyxml.h>
-
-
-namespace ewol {
-	namespace theme {
-		class EolBase {
-			public:
-				EolBase(void);
-				virtual ~EolBase(void);
-				virtual void Parse(TiXmlNode * pNode) = 0;
-				virtual void Generate(const ewol::theme::Theme * myTheme, const ewol::theme::EolElement * myElement, ewol::OObject2DColored & newObject, etkFloat_t posX, etkFloat_t posY, etkFloat_t sizeX, etkFloat_t sizeY) = 0;
-		};
-	};
-};
-
-
-#endif
-

Sources/ewol/theme/EolBaseCircle.cpp

@@ -1,119 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/theme/EolBasicCircle.cpp
- * @brief basic ewol theme eol file basic element type=Circle (Sources)
- * @author Edouard DUPIN
- * @date 23/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#include <ewol/theme/Theme.h>
-#include <ewol/theme/EolBaseCircle.h>
-
-#undef __class__
-#define __class__	"ewol::theme::EolBaseCircle"
-
-
-
-ewol::theme::EolBaseCircle::EolBaseCircle(void)
-{
-	//EWOL_DEBUG("new element Base : Circle/Disk ...");
-}
-
-ewol::theme::EolBaseCircle::~EolBaseCircle(void)
-{
-	
-}
-
-void ewol::theme::EolBaseCircle::Parse(TiXmlNode * pNode)
-{
-	m_colorBG     = pNode->ToElement()->Attribute("colorBG");
-	m_colorBorder = pNode->ToElement()->Attribute("colorBorder");
-	
-	const char * tmp = pNode->ToElement()->Attribute("position");
-	if (NULL == tmp) {
-		m_posCenter.x=0;
-		m_posCenter.y=0;
-	} else {
-		double xxx,yyy;
-		// optimize for multiple type input ...
-		sscanf(tmp, "%lf;%lf", &xxx,&yyy);
-		m_posCenter.x=xxx;
-		m_posCenter.y=yyy;
-	}
-	
-	tmp = pNode->ToElement()->Attribute("radius");
-	if (NULL == tmp) {
-		m_radius=0;
-	} else {
-		double tmpVal;
-		// optimize for multiple type input ...
-		sscanf(tmp, "%lf", &tmpVal);
-		m_radius=tmpVal;
-	}
-	
-	tmp = pNode->ToElement()->Attribute("thickness");
-	if (NULL == tmp) {
-		m_thickness=0.01;
-	} else {
-		double tmpVal;
-		// optimize for multiple type input ...
-		sscanf(tmp, "%lf", &tmpVal);
-		m_thickness=tmpVal;
-	}
-	EWOL_DEBUG("(l " << pNode->Row() << ")     Parse Base Element : \"Circle\" : pos(" << m_posCenter.x << "," << m_posCenter.y << ") radius=" << m_radius
-	           << " colorBG=\"" << m_colorBG << "\" colorBorder=\"" << m_colorBorder << "\" thickness=" << m_thickness);
-}
-
-
-void ewol::theme::EolBaseCircle::Generate(const ewol::theme::Theme * myTheme, const ewol::theme::EolElement * myElement, ewol::OObject2DColored & newObject, etkFloat_t posX, etkFloat_t posY, etkFloat_t sizeX, etkFloat_t sizeY)
-{
-	if (m_colorBG != "") {
-		color_ts selectedColorBG = {1.0, 1.0, 1.0, 1.0};
-		bool res = false;
-		if (NULL != myElement) {
-			res = myElement->GetColor(m_colorBG, selectedColorBG);
-		}
-		// try from theme if not existed
-		if(    false == res
-		    && NULL != myTheme ) {
-			myElement->GetColor(m_colorBG, selectedColorBG);
-		}
-		newObject.SetColor(selectedColorBG);
-		newObject.Disc(posX + m_posCenter.x*sizeX, posY + m_posCenter.y*sizeY, m_radius*(sizeX+sizeY)/2);
-	}
-	if (m_colorBorder != "") {
-		color_ts selectedColorBorder = {0.0, 0.0, 0.0, 1.0};
-		bool res = false;
-		// try get color for current element
-		if (NULL != myElement) {
-			res = myElement->GetColor(m_colorBorder, selectedColorBorder);
-		}
-		// try from theme if not existed
-		if(    false == res
-		    && NULL != myTheme ) {
-			myElement->GetColor(m_colorBorder, selectedColorBorder);
-		}
-		newObject.SetColor(selectedColorBorder);
-		newObject.Circle(posX + m_posCenter.x*sizeX, posY + m_posCenter.y*sizeY, m_radius*(sizeX+sizeY)/2, m_thickness*(sizeX+sizeY)/2);
-	}
-}
-
-
-
-

Sources/ewol/theme/EolBaseCircle.h

@@ -1,57 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/theme/EolBasicCircle.h
- * @brief basic ewol theme eol file basic element type=Circle (Header)
- * @author Edouard DUPIN
- * @date 23/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#include <ewol/theme/EolBase.h>
-#include <ewol/theme/EolColor.h>
-
-#ifndef __EWOL_THEME_EOL_BASE_CIRCLE_H__
-#define __EWOL_THEME_EOL_BASE_CIRCLE_H__
-
-namespace ewol {
-	namespace theme {
-		class EolBaseCircle : public EolBase {
-			public:
-				EolBaseCircle(void);
-				virtual ~EolBaseCircle(void);
-				/*
-					<circle colorBG="..."    ==> generate condition to display background ...
-					        colorBorder="..."    ==> generate condition to display border ...
-					        position="0.53;0.56"
-					        radius="0.2"
-					        thickness="0.05"  ==> only if neededd by border, default 0.01
-					/>
-				*/
-				virtual void Parse(TiXmlNode * pNode);
-				virtual void Generate(const ewol::theme::Theme * myTheme, const ewol::theme::EolElement * myElement, ewol::OObject2DColored & newObject, etkFloat_t posX, etkFloat_t posY, etkFloat_t sizeX, etkFloat_t sizeY);
-			private:
-				etk::String     m_colorBG;
-				etk::String     m_colorBorder;
-				coord2D_ts      m_posCenter;
-				etkFloat_t      m_radius;
-				etkFloat_t      m_thickness;
-		};
-	};
-};
-#endif
-

Sources/ewol/theme/EolBaseCirclePart.cpp

@@ -1,28 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/theme/EolBasicCirclePart.cpp
- * @brief basic ewol theme eol file basic element type=CirclePart (Sources)
- * @author Edouard DUPIN
- * @date 23/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-#undef __class__
-#define __class__	"ewol::theme::EolBaseCirclePart"
-

Sources/ewol/theme/EolBaseCirclePart.h

@@ -1,32 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/theme/EolBasicCirclePart.h
- * @brief basic ewol theme eol file basic element type=CirclePart (Header)
- * @author Edouard DUPIN
- * @date 23/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-#include <ewol/theme/EolBase.h>
-
-#ifndef __EWOL_THEME_EOL_BASE_CIRCLE_PART_H__
-#define __EWOL_THEME_EOL_BASE_CIRCLE_PART_H__
-
-#endif
-

Sources/ewol/theme/EolBaseLine.cpp

@@ -1,101 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/theme/EolBaseLine.cpp
- * @brief basic ewol theme eol file basic element type=Line (Sources)
- * @author Edouard DUPIN
- * @date 23/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#include <ewol/theme/Theme.h>
-#include <ewol/theme/EolBaseLine.h>
-
-#undef __class__
-#define __class__	"ewol::theme::EolBaseLine"
-
-
-ewol::theme::EolBaseLine::EolBaseLine(void)
-{
-	//EWOL_DEBUG("new element Base : Line ...");
-}
-
-ewol::theme::EolBaseLine::~EolBaseLine(void)
-{
-	
-}
-
-
-void ewol::theme::EolBaseLine::Parse(TiXmlNode * pNode)
-{
-	m_color = pNode->ToElement()->Attribute("color");
-	
-	const char * tmp = pNode->ToElement()->Attribute("positionStart");
-	if (NULL == tmp) {
-		m_posStart.x=0;
-		m_posStart.y=0;
-	} else {
-		double xxx,yyy;
-		// optimize for multiple type input ...
-		sscanf(tmp, "%lf;%lf", &xxx,&yyy);
-		m_posStart.x=xxx;
-		m_posStart.y=yyy;
-	}
-	tmp = pNode->ToElement()->Attribute("positionStop");
-	if (NULL == tmp) {
-		m_posStop.x=0;
-		m_posStop.y=0;
-	} else {
-		double xxx,yyy;
-		// optimize for multiple type input ...
-		sscanf(tmp, "%lf;%lf", &xxx,&yyy);
-		m_posStop.x=xxx;
-		m_posStop.y=yyy;
-	}
-	tmp = pNode->ToElement()->Attribute("thickness");
-	if (NULL == tmp) {
-		m_thickness=0.01;
-	} else {
-		double tmpVal;
-		// optimize for multiple type input ...
-		sscanf(tmp, "%lf", &tmpVal);
-		m_thickness=tmpVal;
-	}
-	EWOL_DEBUG("(l " << pNode->Row() << ")     Parse Base Element : \"line\" : pos(" << m_posStart.x << "," << m_posStart.y << ") to pos(" << m_posStop.x << "," << m_posStop.y << ") thickness=" << m_thickness);
-}
-
-
-void ewol::theme::EolBaseLine::Generate(const ewol::theme::Theme * myTheme, const ewol::theme::EolElement * myElement, ewol::OObject2DColored & newObject, etkFloat_t posX, etkFloat_t posY, etkFloat_t sizeX, etkFloat_t sizeY)
-{
-	bool res = false;
-	color_ts selectedColor = {0.0, 0.0, 0.0, 1.0};
-	// try get color for current element
-	if (NULL != myElement) {
-		res = myElement->GetColor(m_color, selectedColor);
-	}
-	// try from theme if not existed
-	if(    false == res
-	    && NULL != myTheme ) {
-		myElement->GetColor(m_color, selectedColor);
-	}
-	newObject.SetColor(selectedColor);
-	newObject.Line(posX + m_posStart.x*sizeX, posY + m_posStart.y*sizeY, posX + m_posStop.x*sizeX, posY + m_posStop.y*sizeY, m_thickness*(sizeX+sizeY)/2);
-}
-
-
-
-

Sources/ewol/theme/EolBaseLine.h

@@ -1,58 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/theme/EolBaseLine.h
- * @brief basic ewol theme eol file basic element type=Line (Header)
- * @author Edouard DUPIN
- * @date 23/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-#include <ewol/theme/EolBase.h>
-#include <ewol/theme/EolColor.h>
-
-#ifndef __EWOL_THEME_EOL_BASE_LINE_H__
-#define __EWOL_THEME_EOL_BASE_LINE_H__
-
-namespace ewol {
-	namespace theme {
-		class EolBaseLine : public EolBase {
-			public:
-				EolBaseLine(void);
-				virtual ~EolBaseLine(void);
-				/*
-					<line color="..."
-					      positionStart="0.53;0.56"
-					      positionStop="0.22;0.11"
-					      thickness="0.05"
-					/>
-				*/
-				virtual void Parse(TiXmlNode * pNode);
-				virtual void Generate(const ewol::theme::Theme * myTheme, const ewol::theme::EolElement * myElement, ewol::OObject2DColored & newObject, etkFloat_t posX, etkFloat_t posY, etkFloat_t sizeX, etkFloat_t sizeY);
-			private:
-				etk::String     m_color;
-				coord2D_ts      m_posStart;
-				coord2D_ts      m_posStop;
-				etkFloat_t      m_thickness;
-		};
-	};
-};
-
-
-#endif
-

Sources/ewol/theme/EolBasePolygone.cpp

@@ -1,28 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/theme/EolBasePolygone.cpp
- * @brief basic ewol theme eol file basic element type=polygone (Sources)
- * @author Edouard DUPIN
- * @date 23/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-#undef __class__
-#define __class__	"ewol::theme::EolBasePolygone"
-

Sources/ewol/theme/EolBasePolygone.h

@@ -1,32 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/theme/EolBasePolygone.h
- * @brief basic ewol theme eol file basic element type=polygone (Header)
- * @author Edouard DUPIN
- * @date 23/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-#include <ewol/theme/EolBase.h>
-
-#ifndef __EWOL_THEME_EOL_BASE_POLYGONE_H__
-#define __EWOL_THEME_EOL_BASE_POLYGONE_H__
-
-#endif
-

Sources/ewol/theme/EolBaseRect.cpp

@@ -1,117 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/theme/EolBaseRect.cpp
- * @brief basic ewol theme eol file basic element type=rectangle (Sources)
- * @author Edouard DUPIN
- * @date 23/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#include <ewol/theme/Theme.h>
-#include <ewol/theme/EolBaseRect.h>
-
-#undef __class__
-#define __class__	"ewol::theme::EolBaseRect"
-
-
-
-ewol::theme::EolBaseRect::EolBaseRect(void)
-{
-	//EWOL_DEBUG("new element Base : Rectangle ...");
-}
-
-ewol::theme::EolBaseRect::~EolBaseRect(void)
-{
-	
-}
-
-
-void ewol::theme::EolBaseRect::Parse(TiXmlNode * pNode)
-{
-	const char * tmp = pNode->ToElement()->Attribute("position");
-	if (NULL == tmp) {
-		m_position.x=0;
-		m_position.y=0;
-	} else {
-		double xxx,yyy;
-		// optimize for multiple type input ...
-		sscanf(tmp, "%lf;%lf", &xxx,&yyy);
-		m_position.x=xxx;
-		m_position.y=yyy;
-	}
-	tmp = pNode->ToElement()->Attribute("size");
-	if (NULL == tmp) {
-		m_size.x=0;
-		m_size.y=0;
-	} else {
-		double xxx,yyy;
-		// optimize for multiple type input ...
-		sscanf(tmp, "%lf;%lf", &xxx,&yyy);
-		m_size.x=xxx;
-		m_size.y=yyy;
-	}
-	tmp = pNode->ToElement()->Attribute("thickness");
-	if (NULL == tmp) {
-		m_thickness=0.01;
-	} else {
-		double tmpVal;
-		// optimize for multiple type input ...
-		sscanf(tmp, "%lf", &tmpVal);
-		m_thickness=tmpVal;
-	}
-	m_colorBG     = pNode->ToElement()->Attribute("colorBG");
-	m_colorBorder = pNode->ToElement()->Attribute("colorBorder");
-	EWOL_DEBUG("(l " << pNode->Row() << ")     Parse Base Element : \"rect\" : pos(" << m_position.x << "," << m_position.y << ") "
-	           << "size(" << m_size.x << "," << m_size.y << ") colorBG=\"" << m_colorBG << "\" colorBorder=\"" << m_colorBorder << "\" thickness=" << m_thickness);
-}
-
-void ewol::theme::EolBaseRect::Generate(const ewol::theme::Theme * myTheme, const ewol::theme::EolElement * myElement, ewol::OObject2DColored & newObject, etkFloat_t posX, etkFloat_t posY, etkFloat_t sizeX, etkFloat_t sizeY)
-{
-	if (m_colorBG != "") {
-		color_ts selectedColorBG = {1.0, 1.0, 1.0, 1.0};
-		bool res = false;
-		if (NULL != myElement) {
-			res = myElement->GetColor(m_colorBG, selectedColorBG);
-		}
-		// try from theme if not existed
-		if(    false == res
-		    && NULL != myTheme ) {
-			myElement->GetColor(m_colorBG, selectedColorBG);
-		}
-		newObject.SetColor(selectedColorBG);
-		newObject.Rectangle(posX + m_position.x*sizeX, posY + m_position.y*sizeY, m_size.x*sizeX, m_size.y*sizeY);
-	}
-	if (m_colorBorder != "") {
-		color_ts selectedColorBorder = {0.0, 0.0, 0.0, 1.0};
-		bool res = false;
-		// try get color for current element
-		if (NULL != myElement) {
-			res = myElement->GetColor(m_colorBorder, selectedColorBorder);
-		}
-		// try from theme if not existed
-		if(    false == res
-		    && NULL != myTheme ) {
-			myElement->GetColor(m_colorBorder, selectedColorBorder);
-		}
-		newObject.SetColor(selectedColorBorder);
-		newObject.RectangleBorder(posX + m_position.x*sizeX, posY + m_position.y*sizeY, m_size.x*sizeX, m_size.y*sizeY, m_thickness*(sizeX+sizeY)/2);
-	}
-}
-
-
-

Sources/ewol/theme/EolBaseRect.h

@@ -1,59 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/theme/EolBaseRect.h
- * @brief basic ewol theme eol file basic element type=rectangle (Header)
- * @author Edouard DUPIN
- * @date 23/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-#include <ewol/theme/EolBase.h>
-#include <ewol/theme/EolColor.h>
-
-#ifndef __EWOL_THEME_EOL_BASE_RECT_H__
-#define __EWOL_THEME_EOL_BASE_RECT_H__
-
-namespace ewol {
-	namespace theme {
-		class EolBaseRect : public EolBase {
-			public:
-				EolBaseRect(void);
-				virtual ~EolBaseRect(void);
-				/*
-					<rect colorBG="..."    ==> generate condition to display background ...
-					      colorBorder="..."    ==> generate condition to display border ...
-					      position="0.53;0.56"
-					      size="0.22;0.11"
-					      thickness="0.05"  ==> only if neededd by border, default 0.01
-					/>
-				*/
-				virtual void Parse(TiXmlNode * pNode);
-				virtual void Generate(const ewol::theme::Theme * myTheme, const ewol::theme::EolElement * myElement, ewol::OObject2DColored & newObject, etkFloat_t posX, etkFloat_t posY, etkFloat_t sizeX, etkFloat_t sizeY);
-			private:
-				etk::String     m_colorBG;
-				etk::String     m_colorBorder;
-				coord2D_ts      m_position;
-				coord2D_ts      m_size;
-				etkFloat_t      m_thickness;
-		};
-	};
-};
-
-#endif
-

Sources/ewol/theme/EolBaseTriangle.cpp

@@ -1,28 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/theme/EolBaseTriangle.cpp
- * @brief basic ewol theme eol file basic element type=triangle (Sources)
- * @author Edouard DUPIN
- * @date 23/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-#undef __class__
-#define __class__	"ewol::theme::EolBaseTriangle"
-

Sources/ewol/theme/EolBaseTriangle.h

@@ -1,32 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/theme/EolBaseTriangle.h
- * @brief basic ewol theme eol file basic element type=triangle (Header)
- * @author Edouard DUPIN
- * @date 23/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-#include <ewol/theme/EolBase.h>
-
-#ifndef __EWOL_THEME_EOL_BASE_TRIANGLE_H__
-#define __EWOL_THEME_EOL_BASE_TRIANGLE_H__
-
-#endif
-

Sources/ewol/theme/EolColor.cpp

@@ -1,127 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/theme/EolColor.cpp
- * @brief basic ewol theme eol file color (Sources)
- * @author Edouard DUPIN
- * @date 23/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-#include <ewol/theme/EolColor.h>
-
-#undef __class__
-#define __class__	"ewol::theme::EolColor"
-
-
-
-ewol::theme::EolColor::EolColor(void)
-{
-	m_color.red = 0.0;
-	m_color.green = 0.0;
-	m_color.blue = 0.0;
-	m_color.alpha = 1.0;
-}
-
-ewol::theme::EolColor::~EolColor(void)
-{
-	
-}
-
-
-void ewol::theme::EolColor::Parse(TiXmlNode * pNode)
-{
-	m_name = pNode->ToElement()->Attribute("name");
-	const char *color = pNode->ToElement()->Attribute("val");
-	if (NULL != color) {
-		if (color[0] == '#') {
-			// Find a direct Color
-			unsigned int r=0;
-			unsigned int v=0;
-			unsigned int b=0;
-			unsigned int a=0xFF;
-			sscanf(color, "#%02x%02x%02x%02x", &r,&v,&b,&a);
-			m_color.red = (etkFloat_t)r/255.0;
-			m_color.green = (etkFloat_t)v/255.0;
-			m_color.blue = (etkFloat_t)b/255.0;
-			m_color.alpha = (etkFloat_t)a/255.0;
-		} else if (color[0] == '&') {
-			//find a reference Color
-			
-		} else {
-			// must be a float color
-			double r=0.0;
-			double v=0.0;
-			double b=0.0;
-			double a=1.0;
-			sscanf(color, "%lf;%lf;%lf;%lf", &r,&v,&b,&a);
-			m_color.red = (etkFloat_t)r;
-			m_color.green = (etkFloat_t)v;
-			m_color.blue = (etkFloat_t)b;
-			m_color.alpha = (etkFloat_t)a;
-			if (m_color.red>1.0) { m_color.red = 1.0; }
-			if (m_color.green>1.0) { m_color.green = 1.0; }
-			if (m_color.blue>1.0) { m_color.blue = 1.0; }
-			if (m_color.alpha>1.0) { m_color.alpha = 1.0; }
-		}
-	}
-	if (NULL != color) {
-		EWOL_INFO("(l " << pNode->Row() << ") color name=\"" << m_name << "\" \"" << color << "\" ==> red="<< m_color.red <<" green="<< m_color.green <<" blue="<< m_color.blue <<" alpha="<< m_color.alpha );
-	} else {
-		EWOL_INFO("(l " << pNode->Row() << ") color name=\"" << m_name << "\" \"\"???? ==> red="<< m_color.red <<" green="<< m_color.green <<" blue="<< m_color.blue <<" alpha="<< m_color.alpha );
-	}
-}
-
-
-etk::String ewol::theme::EolColor::GetName(void) const
-{
-	return m_name;
-}
-
-
-void ewol::theme::EolColor::SetName(etk::String & newName)
-{
-	m_name = newName;
-}
-
-
-bool ewol::theme::EolColor::HasName(etk::String & newName) const
-{
-	return m_name == newName;
-}
-
-
-color_ts ewol::theme::EolColor::Get(void) const
-{
-	return m_color;
-}
-
-
-void ewol::theme::EolColor::Set(color_ts newColor)
-{
-	m_color = newColor;
-}
-
-
-void ewol::theme::EolColor::Set(etkFloat_t red, etkFloat_t green, etkFloat_t blue, etkFloat_t alpha)
-{
-	m_color.red = red;
-	m_color.green = green;
-	m_color.blue = blue;
-	m_color.alpha = alpha;
-}

Sources/ewol/theme/EolColor.h

@@ -1,60 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/theme/EolColor.h
- * @brief basic ewol theme eol file color (Header)
- * @author Edouard DUPIN
- * @date 23/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-#ifndef __EWOL_THEME_EOL_COLOR_H__
-#define __EWOL_THEME_EOL_COLOR_H__
-
-
-#include <etk/Types.h>
-#include <etk/String.h>
-#include <etk/File.h>
-#include <ewol/OObject.h>
-#include <tinyXML/tinyxml.h>
-
-
-namespace ewol {
-	namespace theme {
-		class EolColor {
-			public:
-				EolColor(void);
-				virtual ~EolColor(void);
-				
-				void Parse(TiXmlNode * pNode);
-				etk::String GetName(void) const;
-				void SetName(etk::String & newName);
-				bool HasName(etk::String & newName) const;
-				color_ts Get(void) const;
-				void Set(color_ts newColor);
-				void Set(etkFloat_t red, etkFloat_t green, etkFloat_t blue, etkFloat_t alpha = 1);
-			private:
-				color_ts    m_color;
-				etk::String m_name;
-		};
-	};
-};
-
-
-#endif
-

Sources/ewol/theme/EolElement.cpp

@@ -1,288 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/theme/EolElement.cpp
- * @brief basic ewol theme eol file element (Sources)
- * @author Edouard DUPIN
- * @date 23/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#include <ewol/theme/Theme.h>
-
-#undef __class__
-#define __class__	"ewol::theme::EolElement"
-
-
-ewol::theme::EolElement::EolElement(void)
-{
-	//EWOL_DEBUG("new...");
-}
-
-ewol::theme::EolElement::~EolElement(void)
-{
-	RemoveAll();
-}
-
-void ewol::theme::EolElement::RemoveAll(void)
-{
-	for(int32_t iii=0; iii<m_listColor.Size(); iii++) {
-		if (m_listColor[iii] != NULL) {
-			delete m_listColor[iii];
-			m_listColor[iii] = NULL;
-		}
-	}
-	m_listColor.Clear();
-	for(int32_t iii=0; iii<m_listGroup.Size(); iii++) {
-		if (m_listGroup[iii] != NULL) {
-			delete m_listGroup[iii];
-			m_listGroup[iii] = NULL;
-		}
-	}
-	m_listGroup.Clear();
-	for(int32_t iii=0; iii<m_listElement.Size(); iii++) {
-		if (m_listElement[iii] != NULL) {
-			delete m_listElement[iii];
-			m_listElement[iii] = NULL;
-		}
-	}
-	m_listElement.Clear();
-}
-
-void ewol::theme::EolElement::Parse(TiXmlNode * root)
-{
-	// clean all internal elements ...
-	RemoveAll();
-	// get the name ...
-	m_name = root->ToElement()->Attribute("name");
-	const char * tmp = root->ToElement()->Attribute("ratio");
-	if (NULL == tmp) {
-		m_ratio=1.0;
-	} else {
-		double xxx;
-		// optimize for multiple type input ...
-		sscanf(tmp, "%lf", &xxx);
-		m_ratio=xxx;
-	}
-	etk::String tmpString = root->ToElement()->Attribute("ClipX");
-	if (tmpString == "true") {
-		m_clipX = true;
-	} else {
-		m_clipX = false;
-	}
-	etk::String tmpString2 = root->ToElement()->Attribute("ClipY");
-	if (tmpString2 == "true") {
-		m_clipY = true;
-	} else {
-		m_clipY = false;
-	}
-	
-	tmp = root->ToElement()->Attribute("internalElemStart");
-	if (NULL == tmp) {
-		m_internalElemStart.x=0;
-		m_internalElemStart.y=0;
-	} else {
-		double xxx,yyy;
-		// optimize for multiple type input ...
-		sscanf(tmp, "%lf;%lf", &xxx,&yyy);
-		m_internalElemStart.x=xxx;
-		m_internalElemStart.y=yyy;
-	}
-	tmp = root->ToElement()->Attribute("internalElemStop");
-	if (NULL == tmp) {
-		m_internalElemStop.x=0;
-		m_internalElemStop.y=0;
-	} else {
-		double xxx,yyy;
-		// optimize for multiple type input ...
-		sscanf(tmp, "%lf;%lf", &xxx,&yyy);
-		m_internalElemStop.x=xxx;
-		m_internalElemStop.y=yyy;
-	}
-	EWOL_INFO("(l " << root->Row() << ") ELEMENT name=\"" << m_name << "\" internalStart(" << m_internalElemStart.x << "," << m_internalElemStart.y << ") to internalStop(" << m_internalElemStop.x << "," << m_internalElemStop.y << ") ratio=" << m_ratio );
-	EWOL_INFO("  --------------------- START ---------------------");
-	for(TiXmlNode * pNode=root->FirstChild(); NULL!=pNode; pNode = pNode->NextSibling()) {
-		if (pNode->Type()==TiXmlNode::TINYXML_COMMENT) {
-			continue;
-		}
-		etk::String nodeValue = pNode->Value();
-		if (nodeValue == "group") {
-			//EWOL_INFO("Find group ... ");
-			etk::String groupNameTmp = pNode->ToElement()->Attribute("name");
-			if (groupNameTmp == "") {
-				EWOL_ERROR("(l " << pNode->Row() << ") Group with NO name ... (not parsed)");
-				// not added it
-			} else {
-				bool findASameName = false;
-				// check if existed ...
-				for (int32_t iii=0; iii < m_listGroup.Size(); iii++) {
-					if(NULL!=m_listGroup[iii]) {
-						if(m_listGroup[iii]->HasName(groupNameTmp) == true) {
-							findASameName = true;
-							EWOL_WARNING("(l " << pNode->Row() << ") Find a Group with the same Name : \"" << groupNameTmp <<"\"");
-							m_listGroup[iii]->Parse(pNode);
-							break;
-						}
-					}
-				}
-				if (findASameName == false) {
-					//EWOL_DEBUG("(l " << pNode->Row() << ") Add a new Group : \"" << groupNameTmp <<"\"");
-					ewol::theme::EolElementFrame * myGroupTmp = new ewol::theme::EolElementFrame();
-					if (NULL != myGroupTmp) {
-						myGroupTmp->Parse(pNode);
-						m_listGroup.PushBack(myGroupTmp);
-					} else {
-						EWOL_ERROR("(l " << pNode->Row() << ") Error Allocation : \"" << nodeValue <<"\"");
-					}
-				}
-			}
-		} else if (nodeValue == "frame") {
-			//EWOL_INFO("Find frame ... ");
-			etk::String groupNameTmp = pNode->ToElement()->Attribute("name");
-			if (groupNameTmp == "") {
-				EWOL_ERROR("(l " << pNode->Row() << ") Group with NO name ... (not parsed)");
-				// not added it
-			} else {
-				bool findASameName = false;
-				// check if existed ...
-				for (int32_t iii=0; iii < m_listElement.Size(); iii++) {
-					if(NULL!=m_listElement[iii]) {
-						if(m_listElement[iii]->HasName(groupNameTmp) == true) {
-							findASameName = true;
-							EWOL_WARNING("(l " << pNode->Row() << ") Find a Frame with the same Name : \"" << groupNameTmp <<"\"");
-							m_listGroup[iii]->Parse(pNode);
-							break;
-						}
-					}
-				}
-				if (findASameName == false) {
-					//EWOL_DEBUG("(l " << pNode->Row() << ") Add a new Frame : \"" << groupNameTmp <<"\"");
-					ewol::theme::EolElementFrame * myGroupTmp = new ewol::theme::EolElementFrame();
-					if (NULL != myGroupTmp) {
-						myGroupTmp->Parse(pNode);
-						m_listElement.PushBack(myGroupTmp);
-					} else {
-						EWOL_ERROR("(l " << pNode->Row() << ") Error Allocation : \"" << nodeValue <<"\"");
-					}
-				}
-			}
-		} else if (nodeValue == "color") {
-			etk::String colorNameTmp = pNode->ToElement()->Attribute("name");
-			if (colorNameTmp == "") {
-				EWOL_ERROR("(l " << pNode->Row() << ") Color with NO name ... (not parsed)");
-				// not added it
-			} else {
-				bool findASameName = false;
-				// check if existed ...
-				for (int32_t iii=0; iii < m_listColor.Size(); iii++) {
-					if(NULL!=m_listColor[iii]) {
-						if(m_listColor[iii]->HasName(colorNameTmp) == true) {
-							findASameName = true;
-							EWOL_WARNING("(l " << pNode->Row() << ") Find a color with the same Name : \"" << colorNameTmp <<"\"");
-							m_listColor[iii]->Parse(pNode);
-							break;
-						}
-					}
-				}
-				if (findASameName == false) {
-					//EWOL_DEBUG("(l " << pNode->Row() << ") Add a new COLOR : \"" << colorNameTmp <<"\"");
-					ewol::theme::EolColor * myColorTmp = new ewol::theme::EolColor();
-					if (NULL != myColorTmp) {
-						myColorTmp->Parse(pNode);
-						m_listColor.PushBack(myColorTmp);
-					} else {
-						EWOL_ERROR("(l " << pNode->Row() << ") Error Allocation : \"" << nodeValue <<"\"");
-					}
-				}
-			}
-		} else {
-			EWOL_ERROR("(l " << pNode->Row() << ") node not suported : \"" << nodeValue <<"\" must be [group,color,frame]");
-		}
-	}
-	EWOL_INFO("  --------------------- STOP  ---------------------");
-}
-
-
-
-bool ewol::theme::EolElement::GetColor(etk::String colorName, color_ts & selectedColor) const
-{
-	for (int32_t iii=0; iii < m_listColor.Size(); iii++) {
-		if(NULL!=m_listColor[iii]) {
-			if(m_listColor[iii]->HasName(colorName) == true) {
-				selectedColor = m_listColor[iii]->Get();
-				return true;
-			}
-		}
-	}
-	selectedColor.red = 0.0;
-	selectedColor.green = 0.0;
-	selectedColor.blue = 0.0;
-	selectedColor.alpha = 1.0;
-	return false;
-}
-
-int32_t ewol::theme::EolElement::GetNbFrame(void) const
-{
-	return m_listElement.Size();
-}
-
-
-int32_t ewol::theme::EolElement::GetFrameId(etk::String & frameName) const
-{
-	for (int32_t iii=0; iii < m_listElement.Size(); iii++) {
-		if(NULL!=m_listElement[iii]) {
-			if(m_listElement[iii]->HasName(frameName) == true) {
-				return iii;;
-			}
-		}
-	}
-	return -1;
-}
-
-
-etk::String ewol::theme::EolElement::GetName(void) const
-{
-	return m_name;
-}
-
-
-void ewol::theme::EolElement::SetName(etk::String & newName)
-{
-	m_name = newName;
-}
-
-
-bool ewol::theme::EolElement::HasName(etk::String & newName) const
-{
-	return m_name == newName;
-}
-
-
-void ewol::theme::EolElement::Generate(const ewol::theme::Theme * myTheme, int32_t frameId, ewol::OObject2DColored & newObject, etkFloat_t posX, etkFloat_t posY, etkFloat_t sizeX, etkFloat_t sizeY)
-{
-	if (0 > frameId || frameId > m_listElement.Size()) {
-		EWOL_ERROR("Did not find the frame id=" << frameId);
-		return;
-	}
-	if (NULL != m_listElement[frameId]) {
-		m_listElement[frameId]->Generate(myTheme, this, newObject, posX, posY, sizeX, sizeY);
-	}
-	
-}
-
-
-

Sources/ewol/theme/EolElement.h

@@ -1,81 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/theme/EolElement.h
- * @brief basic ewol theme eol file element (Header)
- * @author Edouard DUPIN
- * @date 23/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-
-#ifndef __EWOL_THEME_EOL_ELEMENT_H__
-#define __EWOL_THEME_EOL_ELEMENT_H__
-
-#include <etk/Types.h>
-#include <etk/String.h>
-#include <etk/File.h>
-#include <ewol/OObject.h>
-#include <ewol/theme/EolColor.h>
-#include <ewol/theme/EolElementFrame.h>
-
-
-namespace ewol {
-	namespace theme {
-		class EolElement {
-			public:
-				EolElement(void);
-				virtual ~EolElement(void);
-				void Parse(TiXmlNode * pNode);
-				etk::String GetName(void) const;
-				void SetName(etk::String & newName);
-				bool HasName(etk::String & newName) const;
-				
-				void Generate(const ewol::theme::Theme * myTheme, int32_t frameId, ewol::OObject2DColored & newObject, etkFloat_t posX, etkFloat_t posY, etkFloat_t sizeX, etkFloat_t sizeY);
-				bool GenerateGroup(const ewol::theme::Theme * myTheme, etk::String groupName, ewol::OObject2DColored & newObject, etkFloat_t posX, etkFloat_t posY, etkFloat_t sizeX, etkFloat_t sizeY);
-				bool GetColor(etk::String colorName, color_ts & selectedColor) const;
-				
-				int32_t GetNbFrame(void) const;
-				int32_t GetFrameId(etk::String & frameName) const;
-			private:
-				void RemoveAll(void);
-				etk::String m_name;
-				/*
-				void Load(etk::File & newFile) { };
-				void Generate(int32_t id, int32_t frameId, OObject2DTextured & newObject, etkFloat_t posX, etkFloat_t posY, etkFloat_t sizeX, etkFloat_t sizeY) {};
-				int32_t GetNbFrame(int32_t id) {return 0;};
-				int32_t GetFrameId(int32_t id, etk::String & frameName) {return 0;};
-				int32_t GetObjectId(etk::String name) { return -1; };
-				*/
-			private:
-				etk::VectorType<ewol::theme::EolColor*>         m_listColor;
-				etk::VectorType<ewol::theme::EolElementFrame*>  m_listGroup;
-				etk::VectorType<ewol::theme::EolElementFrame*>  m_listElement;
-				etkFloat_t    m_ratio;
-				bool          m_clipX;
-				bool          m_clipY;
-				coord2D_ts    m_internalElemStart;
-				coord2D_ts    m_internalElemStop;
-			public:
-				// acces to manage and create object ==> drawing system 
-				
-		};
-	};
-};
-#endif
-

Sources/ewol/theme/EolElementFrame.cpp

@@ -1,133 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/theme/EolElementFrame.cpp
- * @brief basic ewol theme eol file element (specific frame) (Sources)
- * @author Edouard DUPIN
- * @date 23/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-
-#include <ewol/theme/Theme.h>
-#include <ewol/theme/EolElementFrame.h>
-
-#undef __class__
-#define __class__	"ewol::theme::EolElementFrame"
-
-
-
-ewol::theme::EolElementFrame::EolElementFrame(void)
-{
-	//EWOL_DEBUG("new...");
-}
-
-ewol::theme::EolElementFrame::~EolElementFrame(void)
-{
-	RemoveAll();
-}
-
-void ewol::theme::EolElementFrame::RemoveAll(void)
-{
-	for(int32_t iii=0; iii<m_description.Size(); iii++) {
-		if (m_description[iii] != NULL) {
-			delete m_description[iii];
-			m_description[iii] = NULL;
-		}
-	}
-	m_description.Clear();
-}
-
-void ewol::theme::EolElementFrame::Parse(TiXmlNode * root)
-{
-	RemoveAll();
-	m_name = root->ToElement()->Attribute("name");
-	EWOL_INFO("(l " << root->Row() << ") Group name=\"" << m_name << "\" " );
-	for(TiXmlNode * pNode=root->FirstChild(); NULL!=pNode; pNode = pNode->NextSibling()) {
-		if (pNode->Type()==TiXmlNode::TINYXML_COMMENT) {
-			continue;
-		}
-		etk::String nodeValue = pNode->Value();
-		ewol::theme::EolBase * myBaseTmp = NULL;
-		if (nodeValue == "line") {
-			//EWOL_INFO("Find baseElement Line");
-			myBaseTmp = new ewol::theme::EolBaseLine();
-			if (NULL == myBaseTmp) {
-				EWOL_ERROR("(l " << pNode->Row() << ")     Error Allocation : \"" << nodeValue <<"\"");
-			}
-		} else if (nodeValue == "rect") {
-			//EWOL_INFO("Find baseElement Rectangle");
-			myBaseTmp = new ewol::theme::EolBaseRect();
-			if (NULL == myBaseTmp) {
-				EWOL_ERROR("(l " << pNode->Row() << ")     Error Allocation : \"" << nodeValue <<"\"");
-			}
-		} else if (nodeValue == "link") {
-			EWOL_WARNING("(l " << pNode->Row() << ")     Not Parsed now : \"" << nodeValue <<"\"");
-		} else if (nodeValue == "triangle") {
-			EWOL_WARNING("(l " << pNode->Row() << ")     Not Parsed now : \"" << nodeValue <<"\"");
-		} else if (nodeValue == "polygone") {
-			EWOL_WARNING("(l " << pNode->Row() << ")     Not Parsed now : \"" << nodeValue <<"\"");
-		}  else if (nodeValue == "circle") {
-			//EWOL_INFO("Find baseElement Rectangle");
-			myBaseTmp = new ewol::theme::EolBaseCircle();
-			if (NULL == myBaseTmp) {
-				EWOL_ERROR("(l " << pNode->Row() << ")     Error Allocation : \"" << nodeValue <<"\"");
-			}
-		}  else if (nodeValue == "circlePart") {
-			EWOL_WARNING("(l " << pNode->Row() << ")     Not Parsed now : \"" << nodeValue <<"\"");
-		} else {
-			EWOL_ERROR("(l " << pNode->Row() << ")     Node not suported : \"" << nodeValue <<"\" must be [line,rect,link,triangle,polygone,circle,circlePart]");
-		}
-		if (NULL != myBaseTmp) {
-			myBaseTmp->Parse(pNode);
-			m_description.PushBack(myBaseTmp);
-		}
-	}
-	
-}
-
-
-etk::String ewol::theme::EolElementFrame::GetName(void)
-{
-	return m_name;
-}
-
-
-void ewol::theme::EolElementFrame::SetName(etk::String & newName)
-{
-	m_name = newName;
-}
-
-
-bool ewol::theme::EolElementFrame::HasName(etk::String & newName)
-{
-	return m_name == newName;
-}
-
-
-void ewol::theme::EolElementFrame::Generate(const ewol::theme::Theme * myTheme, const ewol::theme::EolElement * myElement, ewol::OObject2DColored & newObject, etkFloat_t posX, etkFloat_t posY, etkFloat_t sizeX, etkFloat_t sizeY)
-{
-	for (int32_t iii=0; iii<m_description.Size(); iii++) {
-		m_description[iii]->Generate(myTheme, myElement, newObject, posX, posY, sizeX, sizeY);
-	}
-}
-
-
-
-
-

Sources/ewol/theme/EolElementFrame.h

@@ -1,70 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/theme/EolElementFrame.h
- * @brief basic ewol theme eol file element (specific frame) (Header)
- * @author Edouard DUPIN
- * @date 23/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-
-#ifndef __EWOL_THEME_EOL_ELEMENT_FRAME_H__
-#define __EWOL_THEME_EOL_ELEMENT_FRAME_H__
-
-#include <etk/Types.h>
-#include <etk/String.h>
-#include <etk/File.h>
-#include <ewol/OObject.h>
-#include <ewol/theme/EolColor.h>
-#include <ewol/theme/EolBase.h>
-#include <ewol/theme/EolBaseLine.h>
-#include <ewol/theme/EolBaseRect.h>
-#include <ewol/theme/EolBaseCircle.h>
-#include <ewol/theme/EolBaseCirclePart.h>
-#include <ewol/theme/EolBaseTriangle.h>
-#include <ewol/theme/EolBasePolygone.h>
-
-
-namespace ewol {
-	namespace theme {
-		class EolElementFrame {
-			public:
-				EolElementFrame(void);
-				virtual ~EolElementFrame(void);
-				
-				void Generate(const ewol::theme::Theme * myTheme, const ewol::theme::EolElement * myElement, ewol::OObject2DColored & newObject, etkFloat_t posX, etkFloat_t posY, etkFloat_t sizeX, etkFloat_t sizeY);
-				
-				void Parse(TiXmlNode * pNode);
-				etk::String GetName(void);
-				void SetName(etk::String & newName);
-				bool HasName(etk::String & newName);
-			private:
-				void RemoveAll(void);
-				etk::String m_name;
-				etk::VectorType<ewol::theme::EolBase*> m_description; // all element to draw the image ...
-			public:
-				// acces to manage and create object ==> drawing system 
-				
-		};
-	};
-};
-
-
-#endif
-

Sources/ewol/theme/Theme.cpp

@@ -1,262 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/theme/Theme.cpp
- * @brief basic ewol Theme basic class (Sources)
- * @author Edouard DUPIN
- * @date 23/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#include <tinyXML/tinyxml.h>
-
-#include <ewol/theme/Theme.h>
-
-#undef __class__
-#define __class__	"ewol::theme::Theme"
-
-#define MAX_LINE_SIZE		(2048)
-
-ewol::theme::Theme::Theme(void)
-{
-	
-}
-
-
-ewol::theme::Theme::~Theme(void)
-{
-	
-}
-
-void ewol::theme::Theme::Load(etk::File & newFile, bool defaultTheme)
-{
-	if (newFile.HasExtention() == false) {
-		EWOL_ERROR("can not load theme with file, has no extention : " << newFile);
-		return;
-	}
-	if (newFile.GetExtention() != "eol") {
-		EWOL_ERROR("can not load theme with file, has not extention .eol : " << newFile);
-		return;
-	}
-	if (false == newFile.Exist()) {
-		EWOL_ERROR("File does not Exist ... " << newFile);
-		return;
-	} else {
-		TiXmlDocument XmlDocument;
-		// open the curent File
-		#ifdef DATA_INTERNAL_BINARY
-			if (etk::FILE_TYPE_DATA == newFile.GetTypeAccess()) {
-				XmlDocument.Parse(newFile.GetDirectPointer());
-			} else {
-				XmlDocument.LoadFile(newFile.GetCompleateName().c_str());
-			}
-		#else
-			XmlDocument.LoadFile(newFile.GetCompleateName().c_str());
-		#endif
-		TiXmlElement* root = XmlDocument.FirstChildElement( "eol" );
-		if (NULL == root ) {
-			EWOL_ERROR("(l ?) main node not find: \"eol\" in \"" << newFile << "\"");
-			return;
-		} else {
-			for(TiXmlNode * pNode=root->FirstChild(); NULL!=pNode; pNode = pNode->NextSibling()) {
-				if (pNode->Type()==TiXmlNode::TINYXML_COMMENT) {
-					continue;
-				}
-				etk::String nodeValue = pNode->Value();
-				if (nodeValue == "element") {
-					//EWOL_INFO("Find ELEMENT ... ");
-					etk::String elementNameTmp = pNode->ToElement()->Attribute("name");
-					if (elementNameTmp == "") {
-						EWOL_ERROR("(l " << pNode->Row() << ") Element with NO name ... (not parsed)");
-						// not added it
-					} else {
-						bool findASameName = false;
-						// check if existed ...
-						for (int32_t iii=0; iii < m_listElement.Size(); iii++) {
-							if(NULL!=m_listElement[iii]) {
-								if(m_listElement[iii]->HasName(elementNameTmp) == true) {
-									findASameName = true;
-									EWOL_WARNING("(l " << pNode->Row() << ") Find a Group with the same Name : \"" << elementNameTmp <<"\"");
-									m_listElement[iii]->Parse(pNode);
-									break;
-								}
-							}
-						}
-						if (findASameName == false) {
-							//EWOL_DEBUG("(l " << pNode->Row() << ") Add a new Element : \"" << elementNameTmp <<"\"");
-							ewol::theme::EolElement * myElementTmp = new ewol::theme::EolElement();
-							if (NULL != myElementTmp) {
-								myElementTmp->Parse(pNode);
-								m_listElement.PushBack(myElementTmp);
-							} else {
-								EWOL_ERROR("(l " << pNode->Row() << ") Error Allocation : \"" << nodeValue <<"\"");
-							}
-						}
-					}
-				} else if (nodeValue == "group") {
-					//EWOL_INFO("Find group ... ");
-					etk::String groupNameTmp = pNode->ToElement()->Attribute("name");
-					if (groupNameTmp == "") {
-						EWOL_ERROR("(l " << pNode->Row() << ") Group with NO name ... (not parsed)");
-						// not added it
-					} else {
-						bool findASameName = false;
-						// check if existed ...
-						for (int32_t iii=0; iii < m_listGroup.Size(); iii++) {
-							if(NULL!=m_listGroup[iii]) {
-								if(m_listGroup[iii]->HasName(groupNameTmp) == true) {
-									findASameName = true;
-									EWOL_WARNING("(l " << pNode->Row() << ") Find a Group with the same Name : \"" << groupNameTmp <<"\"");
-									m_listGroup[iii]->Parse(pNode);
-									break;
-								}
-							}
-						}
-						if (findASameName == false) {
-							//EWOL_DEBUG("(l " << pNode->Row() << ") Add a new Group : \"" << groupNameTmp <<"\"");
-							ewol::theme::EolElementFrame * myGroupTmp = new ewol::theme::EolElementFrame();
-							if (NULL != myGroupTmp) {
-								myGroupTmp->Parse(pNode);
-								m_listGroup.PushBack(myGroupTmp);
-							} else {
-								EWOL_ERROR("(l " << pNode->Row() << ") Error Allocation : \"" << nodeValue <<"\"");
-							}
-						}
-					}
-				} else if (nodeValue == "color") {
-					etk::String colorNameTmp = pNode->ToElement()->Attribute("name");
-					if (colorNameTmp == "") {
-						EWOL_ERROR("(l " << pNode->Row() << ") Color with NO name ... (not parsed)");
-						// not added it
-					} else {
-						bool findASameName = false;
-						// check if existed ...
-						for (int32_t iii=0; iii < m_listColor.Size(); iii++) {
-							if(NULL!=m_listColor[iii]) {
-								if(m_listColor[iii]->HasName(colorNameTmp) == true) {
-									findASameName = true;
-									EWOL_WARNING("(l " << pNode->Row() << ") Find a color with the same Name : \"" << colorNameTmp <<"\"");
-									m_listColor[iii]->Parse(pNode);
-									break;
-								}
-							}
-						}
-						if (findASameName == false) {
-							//EWOL_DEBUG("(l " << pNode->Row() << ") Add a new COLOR : \"" << colorNameTmp <<"\"");
-							ewol::theme::EolColor * myColorTmp = new ewol::theme::EolColor();
-							if (NULL != myColorTmp) {
-								myColorTmp->Parse(pNode);
-								m_listColor.PushBack(myColorTmp);
-							} else {
-								EWOL_ERROR("(l " << pNode->Row() << ") Error Allocation : \"" << nodeValue <<"\"");
-							}
-						}
-					}
-				} else {
-					EWOL_ERROR("(l " << pNode->Row() << ") node not suported : \"" << nodeValue <<"\" must be [group,color,element]");
-				}
-			}
-		}
-	}
-}
-
-
-bool ewol::theme::Theme::GetColor(etk::String colorName, color_ts & selectedColor)
-{
-	for (int32_t iii=0; iii < m_listColor.Size(); iii++) {
-		if(NULL!=m_listColor[iii]) {
-			if(m_listColor[iii]->HasName(colorName) == true) {
-				selectedColor = m_listColor[iii]->Get();
-				return true;
-			}
-		}
-	}
-	selectedColor.red = 0.0;
-	selectedColor.green = 0.0;
-	selectedColor.blue = 0.0;
-	selectedColor.alpha = 1.0;
-	return false;
-}
-
-void ewol::theme::Theme::Generate(int32_t id, int32_t frameId, ewol::OObject2DColored & newObject, etkFloat_t posX, etkFloat_t posY, etkFloat_t sizeX, etkFloat_t sizeY)
-{
-	if (0 > id || id > m_listElement.Size()) {
-		return;
-	}
-	if (NULL != m_listElement[id]) {
-		m_listElement[id]->Generate(this, frameId, newObject, posX, posY, sizeX, sizeY);
-	}
-}
-
-bool ewol::theme::Theme::GenerateGroup(etk::String groupName, ewol::OObject2DColored & newObject, etkFloat_t posX, etkFloat_t posY, etkFloat_t sizeX, etkFloat_t sizeY)
-{
-	if (groupName == "") {
-		EWOL_ERROR("Did not find the group name=" << groupName);
-		return -1;
-	}
-	for (int32_t iii=0; iii < m_listGroup.Size(); iii++) {
-		if(NULL!=m_listGroup[iii]) {
-			if(m_listGroup[iii]->HasName(groupName) == true) {
-				// TODO : Call Group display ...
-				return true;
-			}
-		}
-	}
-	return false;
-}
-
-
-int32_t ewol::theme::Theme::GetNbFrame(int32_t id)
-{
-	if (0 > id || id > m_listElement.Size()) {
-		EWOL_ERROR("Did not find the Element id=" << id);
-		return 0;
-	}
-	if (NULL != m_listElement[id]) {
-		return m_listElement[id]->GetNbFrame();
-	}
-	return 0;
-}
-
-int32_t ewol::theme::Theme::GetFrameId(int32_t id, etk::String & frameName)
-{
-	if (0 > id || id > m_listElement.Size()) {
-		EWOL_ERROR("Did not find the Element named=" << frameName);
-		return -1;
-	}
-	if (NULL != m_listElement[id]) {
-		return m_listElement[id]->GetFrameId(frameName);
-	}
-	return -1;
-}
-
-
-int32_t ewol::theme::Theme::GetObjectId(etk::String name)
-{
-	if (name == "") {
-		return -1;
-	}
-	for (int32_t iii=0; iii < m_listElement.Size(); iii++) {
-		if(NULL!=m_listElement[iii]) {
-			if(m_listElement[iii]->HasName(name) == true) {
-				return iii;
-			}
-		}
-	}
-	EWOL_ERROR("Did not find the Element named=" << name);
-	return -1;
-}

Sources/ewol/theme/Theme.h

@@ -1,71 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/theme/Theme.h
- * @brief basic ewol Theme basic class (Header)
- * @author Edouard DUPIN
- * @date 23/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-
-#ifndef __EWOL_EOL_THEME_H__
-#define __EWOL_EOL_THEME_H__
-namespace ewol {
-	namespace theme {
-		class Theme;
-		class EolElement;
-	}
-}
-
-#include <etk/Types.h>
-#include <etk/String.h>
-#include <etk/File.h>
-#include <etk/VectorType.h>
-#include <ewol/OObject.h>
-#include <ewol/theme/EolColor.h>
-#include <ewol/theme/EolBase.h>
-#include <ewol/theme/EolElement.h>
-#include <ewol/theme/EolElementFrame.h>
-
-namespace ewol {
-	namespace theme {
-		class Theme {
-			public:
-				Theme(void);
-				virtual ~Theme(void);
-				void Load(etk::File & newFile, bool defaultTheme=false);
-				void Generate(int32_t id, int32_t frameId, ewol::OObject2DColored & newObject, etkFloat_t posX, etkFloat_t posY, etkFloat_t sizeX, etkFloat_t sizeY);
-				bool GenerateGroup(etk::String groupName,  ewol::OObject2DColored & newObject, etkFloat_t posX, etkFloat_t posY, etkFloat_t sizeX, etkFloat_t sizeY);
-				bool GetColor(etk::String colorName, color_ts & selectedColor);
-				int32_t GetNbFrame(int32_t id);
-				int32_t GetFrameId(int32_t id, etk::String & frameName);
-				int32_t GetObjectId(etk::String name);
-			private:
-				etk::VectorType<ewol::theme::EolColor*>        m_listColor;
-				etk::VectorType<ewol::theme::EolElementFrame*> m_listGroup;
-				etk::VectorType<ewol::theme::EolElement*>      m_listElement;
-			public:
-				// acces to manage and create object ==> drawing system 
-				
-		};
-	};
-};
-
-#endif
-

Sources/ewol/themeManager.cpp

@@ -1,93 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/themeManager.cpp
- * @brief basic ewol theme Manager (Sources)
- * @author Edouard DUPIN
- * @date 23/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#include <ewol/themeManager.h>
-#include <ewol/theme/Theme.h>
-
-
-#undef __class__
-#define __class__	"ewol::theme"
-
-static ewol::theme::Theme localTheme;
-
-void ewol::theme::Init(void)
-{
-	EWOL_INFO("Init theme system");
-}
-
-
-void ewol::theme::UnInit(void)
-{
-	EWOL_INFO("Un-Init theme system");
-}
-
-
-void ewol::theme::LoadDefault(etk::File filename)
-{
-	EWOL_INFO("Load default Theme : " << filename);
-	localTheme.Load(filename, true);
-}
-
-
-void ewol::theme::Load(etk::File filename)
-{
-	EWOL_INFO("Add personal theme : " << filename);
-	localTheme.Load(filename, false);
-}
-
-
-int32_t ewol::theme::GetObjectId(etk::String name)
-{
-	return localTheme.GetObjectId(name);
-}
-
-// ???? GetObjectType(int32_t id);
-
-
-void ewol::theme::Generate(int32_t id, int32_t frameId, ewol::OObject2DColored & newObject, etkFloat_t posX, etkFloat_t posY, etkFloat_t sizeX, etkFloat_t sizeY)
-{
-	if (id<0) {
-		return;
-	}
-	localTheme.Generate(id, frameId, newObject, posX, posY, sizeX, sizeY);
-}
-
-
-int32_t ewol::theme::GetNbFrame(int32_t id)
-{
-	if (id<0) {
-		return 0;
-	}
-	return localTheme.GetNbFrame(id);
-}
-
-
-int32_t ewol::theme::GetFrameId(int32_t id, etk::String & frameName)
-{
-	if (id<0) {
-		return 0;
-	}
-	return localTheme.GetFrameId(id, frameName);
-}
-

Sources/ewol/themeManager.h

@@ -1,52 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/themeManager.h
- * @brief basic ewol theme Manager (Header)
- * @author Edouard DUPIN
- * @date 23/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-
-#ifndef __EWOL_THEME_MANAGER_H__
-#define __EWOL_THEME_MANAGER_H__
-
-#include <etk/Types.h>
-#include <etk/String.h>
-#include <etk/File.h>
-#include <ewol/OObject.h>
-
-namespace ewol {
-	namespace theme {
-		void Init(void);
-		void UnInit(void);
-		void LoadDefault(etk::File filename); // default system theme ==> when an element in not find in the user theme, it is search in this one ... not needed
-		void Load(etk::File filename); // add a user theme at the list ==> this remove previous declaration by the user...
-		int32_t GetObjectId(etk::String name);
-		// ???? GetObjectType(int32_t id);
-		void Generate(int32_t id, int32_t frameId, ewol::OObject2DColored & newObject, etkFloat_t posX, etkFloat_t posY, etkFloat_t sizeX, etkFloat_t sizeY);
-		int32_t GetNbFrame(int32_t id);
-		int32_t GetFrameId(int32_t id, etk::String & frameName);
-		
-	};
-};
-
-
-#endif
-

Sources/ewol/widget/Button.cpp

@@ -1,208 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/widget/Button.cpp
- * @brief ewol Button widget system (Sources)
- * @author Edouard DUPIN
- * @date 07/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#include <ewol/widget/Button.h>
-
-#include <ewol/OObject.h>
-#include <ewol/WidgetManager.h>
-
-
-const char * const ewolEventButtonPressed    = "ewol Button Pressed";
-const char * const ewolEventButtonEnter      = "ewol Button Enter";
-const char * const ewolEventButtonLeave      = "ewol Button Leave";
-
-
-
-#undef __class__
-#define __class__	"ewol::Button"
-
-
-void ewol::Button::Init(void)
-{
-	m_textColorFg.red   = 0.0;
-	m_textColorFg.green = 0.0;
-	m_textColorFg.blue  = 0.0;
-	m_textColorFg.alpha = 1.0;
-	
-	m_textColorBg.red   = 0.0;
-	m_textColorBg.green = 0.0;
-	m_textColorBg.blue  = 0.0;
-	m_textColorBg.alpha = 0.25;
-	SetCanHaveFocus(true);
-}
-
-ewol::Button::Button(void)
-{
-	m_label = "No Label";
-	Init();
-}
-
-ewol::Button::Button(etk::String newLabel)
-{
-	m_label = newLabel;
-	Init();
-}
-
-
-ewol::Button::~Button(void)
-{
-	
-}
-
-bool ewol::Button::CalculateMinSize(void)
-{
-	int32_t fontId = GetDefaultFontId();
-	int32_t minWidth = ewol::GetWidth(fontId, m_label.c_str());
-	int32_t minHeight = ewol::GetHeight(fontId);
-	m_minSize.x = 10+minWidth;
-	m_minSize.y = 10+minHeight;
-	return true;
-}
-
-
-void ewol::Button::SetLabel(etk::String newLabel)
-{
-	m_label = newLabel;
-}
-
-void ewol::Button::SetValue(bool val)
-{
-	
-}
-
-bool ewol::Button::GetValue(void)
-{
-	return false;
-}
-
-
-void ewol::Button::OnRegenerateDisplay(void)
-{
-	// clean the object list ...
-	ClearOObjectList();
-/*
-	int32_t borderSize = 2;
-	int32_t paddingSize = 3;
-	int32_t tmpSizeX = 0;
-	int32_t tmpSizeY = 0;
-	int32_t tmpOriginX = 0;
-	int32_t tmpOriginX = 0;
-	
-	if (true==m_userFillX) {
-		
-	}
-	if (true==m_userFillY) {
-		
-	}
-*/
-	/*
-	ewol::OObject2DColored * tmpOObjects = new ewol::OObject2DColored;
-	tmpOObjects->SetColor(0.0, 0.0, 0.0, 1.0);
-	tmpOObjects->Rectangle( 2, 2, m_size.x-4, m_size.y-4);
-	tmpOObjects->SetColor(1.0, 1.0, 1.0, 1.0);
-	tmpOObjects->Rectangle( 3, 3, m_size.x-6, m_size.y-6);
-	AddOObject(tmpOObjects, "BouttonDecoration");
-	
-	*/
-#if 1
-	int32_t borderWidth = 2;
-	ewol::OObject2DText * tmpText = new ewol::OObject2DText("", -1, m_textColorFg);
-	
-	int32_t fontId = GetDefaultFontId();
-	int32_t fontHeight = ewol::GetHeight(fontId);
-	int32_t fontWidth = ewol::GetWidth(fontId, m_label.c_str());
-	int32_t posy = (m_size.y - fontHeight - 6)/2 + 3;
-	int32_t posx = (m_size.x - fontWidth - 6)/2 + 3;
-	tmpText->Text(posx+2, posy, m_label.c_str());
-	
-	ewol::OObject2DColored * tmpOObjects = new ewol::OObject2DColored;
-	int32_t radius = fontHeight / 2;
-	tmpOObjects->SetColor(m_textColorBg);
-	tmpOObjects->Rectangle( ((m_size.x-fontWidth-10)/2)+radius, posy, fontWidth-radius, radius*2);
-	tmpOObjects->SetColor(m_textColorFg);
-	//EWOL_DEBUG("m_textColorFg=(" << m_textColorFg.red << " " << m_textColorFg.green << " " << m_textColorFg.blue << " " << m_textColorFg.alpha << ")" );
-	tmpOObjects->Line( ((m_size.x-fontWidth-10)/2)+radius, posy, ((m_size.x-fontWidth-10)/2)+fontWidth, posy, borderWidth);
-	tmpOObjects->Line( ((m_size.x-fontWidth-10)/2)+radius, posy+fontHeight, ((m_size.x-fontWidth-10)/2)+fontWidth, posy+fontHeight, borderWidth);
-	posy += fontHeight/2;
-	tmpOObjects->SetColor(m_textColorBg);
-	tmpOObjects->DiscPart(((m_size.x-fontWidth-10)/2)+radius, posy, radius, 180, 360);
-	tmpOObjects->SetColor(m_textColorFg);
-	tmpOObjects->CirclePart(((m_size.x-fontWidth-10)/2)+radius, posy, radius, borderWidth, 180, 360);
-	tmpOObjects->SetColor(m_textColorBg);
-	tmpOObjects->DiscPart(((m_size.x-fontWidth-10)/2)+fontWidth, posy, radius, 0, 180);
-	tmpOObjects->SetColor(m_textColorFg);
-	tmpOObjects->CirclePart(((m_size.x-fontWidth-10)/2)+fontWidth, posy, radius, borderWidth, 0, 180);
-	
-	AddOObject(tmpOObjects, "BouttonDecoration");
-	AddOObject(tmpText, "BouttonText");
-
-	// Regenerate the event Area:
-	EventAreaRemoveAll();
-	coord origin;
-	coord size;
-	origin.x = 3.0;
-	origin.y = 3.0;
-	size.x = m_size.x-6;
-	size.y = m_size.y-6;
-	AddEventArea(origin, size, FLAG_EVENT_INPUT_1 | FLAG_EVENT_INPUT_CLICKED_ALL, ewolEventButtonPressed);
-	AddEventArea(origin, size, FLAG_EVENT_INPUT_ENTER, ewolEventButtonEnter);
-	AddEventArea(origin, size, FLAG_EVENT_INPUT_LEAVE, ewolEventButtonLeave);
-#endif
-}
-
-/*
-bool ewol::Button::OnEventInput(int32_t IdInput, eventInputType_te typeEvent, etkFloat_t x, etkFloat_t y)
-{
-	EWOL_DEBUG("Event on BT ...");
-	return true;
-}
-*/
-
-bool ewol::Button::OnEventArea(const char * generateEventId, etkFloat_t x, etkFloat_t y)
-{
-	bool eventIsOK = false;
-	//EWOL_DEBUG("Receive event : \"" << generateEventId << "\"");
-	if(ewolEventButtonPressed == generateEventId) {
-		EWOL_INFO("BT pressed ... " << m_label);
-		eventIsOK = true;
-		ewol::widgetManager::FocusKeep(this);
-	} else if(ewolEventButtonEnter == generateEventId) {
-		OnRegenerateDisplay();
-	}
-	return eventIsOK;
-}
-
-
-bool ewol::Button::OnEventKb(eventKbType_te typeEvent, char UTF8_data[UTF8_MAX_SIZE])
-{
-	//EWOL_DEBUG("BT PRESSED : \"" << UTF8_data << "\" size=" << strlen(UTF8_data));
-	if(    UTF8_data != NULL
-	    && typeEvent == ewol::EVENT_KB_TYPE_DOWN
-	    && UTF8_data[0] == '\r') {
-		return OnEventArea(ewolEventButtonPressed, -1, -1);
-	}
-	return false;
-}
-
-

Sources/ewol/widget/Button.h

@@ -1,61 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/widget/Button.h
- * @brief ewol Button widget system (header)
- * @author Edouard DUPIN
- * @date 07/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#ifndef __EWOL_BUTTON_H__
-#define __EWOL_BUTTON_H__
-
-#include <etk/Types.h>
-#include <ewol/Debug.h>
-#include <ewol/Widget.h>
-
-namespace ewol {
-	class Button :public ewol::Widget
-	{
-		public:
-			Button(void);
-			Button(etk::String newLabel);
-			void Init(void);
-			virtual ~Button(void);
-			virtual bool   CalculateMinSize(void);
-			void           SetLabel(etk::String newLabel);
-			// TODO : 
-			//void           SetSize(int32_t size);
-			//void           SetFont(etk::String fontName);
-			//void           ResetDefaultParameters(void);
-			void           SetValue(bool val);
-			bool           GetValue(void);
-		private:
-			etk::String    m_label;
-			color_ts       m_textColorFg;  //!< Text color
-			color_ts       m_textColorBg;  //!< Background color
-		public:
-			virtual void   OnRegenerateDisplay(void);
-		public:
-			//virtual bool OnEventInput(int32_t IdInput, eventInputType_te typeEvent, etkFloat_t x, etkFloat_t y);
-			virtual bool OnEventArea(const char * generateEventId, etkFloat_t x, etkFloat_t y);
-			virtual bool OnEventKb(eventKbType_te typeEvent, char UTF8_data[UTF8_MAX_SIZE]);
-	};
-};
-
-#endif

Sources/ewol/widget/CheckBox.cpp

@@ -1,184 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/widget/CheckBox.cpp
- * @brief ewol check-box widget system (Sources)
- * @author Edouard DUPIN
- * @date 07/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-#include <ewol/widget/CheckBox.h>
-
-#include <ewol/OObject.h>
-#include <ewol/WidgetManager.h>
-
-
-const char * ewolEventCheckBoxClicked    = "ewol CheckBox Clicked";
-
-#undef __class__
-#define __class__	"ewol::CheckBox"
-
-
-void ewol::CheckBox::Init(void)
-{
-	m_textColorFg.red   = 0.0;
-	m_textColorFg.green = 0.0;
-	m_textColorFg.blue  = 0.0;
-	m_textColorFg.alpha = 1.0;
-	
-	m_textColorBg.red   = 1.0;
-	m_textColorBg.green = 1.0;
-	m_textColorBg.blue  = 1.0;
-	m_textColorBg.alpha = 1.0;
-	m_value = false;
-	SetCanHaveFocus(true);
-}
-
-ewol::CheckBox::CheckBox(void)
-{
-	m_label = "No Label";
-	Init();
-}
-
-ewol::CheckBox::CheckBox(etk::String newLabel)
-{
-	m_label = newLabel;
-	Init();
-}
-
-
-ewol::CheckBox::~CheckBox(void)
-{
-	
-}
-
-bool ewol::CheckBox::CalculateMinSize(void)
-{
-	int32_t fontId = GetDefaultFontId();
-	int32_t minWidth = ewol::GetWidth(fontId, m_label.c_str());
-	int32_t minHeight = ewol::GetHeight(fontId);
-	etkFloat_t boxSize = etk_max(20, minHeight) + 5;
-	m_minSize.x = boxSize+minWidth;
-	m_minSize.y = etk_max(boxSize, minHeight)+3;
-	return true;
-}
-
-
-void ewol::CheckBox::SetLabel(etk::String newLabel)
-{
-	m_label = newLabel;
-}
-
-void ewol::CheckBox::SetValue(bool val)
-{
-	if (m_value == val) {
-		return;
-	}
-	m_value = val;
-	OnRegenerateDisplay();
-}
-
-bool ewol::CheckBox::GetValue(void)
-{
-	return m_value;
-}
-
-
-void ewol::CheckBox::OnRegenerateDisplay(void)
-{
-	// clean the object list ...
-	ClearOObjectList();
-	
-	int32_t borderWidth = 2;
-	
-	
-	ewol::OObject2DText * tmpText = new ewol::OObject2DText("", -1, m_textColorFg);
-	int32_t fontId = GetDefaultFontId();
-	int32_t fontHeight = ewol::GetHeight(fontId);
-	etkFloat_t boxSize = etk_max(20, fontHeight);
-	//int32_t fontWidth = ewol::GetWidth(fontId, m_label.c_str());
-	int32_t posy = (m_size.y - fontHeight - 6)/2 + 3;
-	//int32_t posx = (m_size.x - fontWidth - 6)/2 + 25;
-	tmpText->Text(boxSize+5, posy, m_label.c_str());
-	
-	
-	ewol::OObject2DColored * tmpOObjects = new ewol::OObject2DColored;
-	tmpOObjects->SetColor(m_textColorBg);
-	tmpOObjects->Rectangle( 2.5, 2.5, boxSize, boxSize);
-	tmpOObjects->SetColor(m_textColorFg);
-	tmpOObjects->RectangleBorder( 2.5, 2.5, boxSize, boxSize, borderWidth);
-	if (m_value) {
-		tmpOObjects->Line( 2.5, 2.5, boxSize+2.5, boxSize+2.5, borderWidth);
-		tmpOObjects->Line( 2.5, boxSize+2.5, boxSize+2.5, 2.5, borderWidth);
-	}
-	
-	AddOObject(tmpOObjects, "Decoration");
-	AddOObject(tmpText, "Text");
-
-	// Regenerate the event Area:
-	EventAreaRemoveAll();
-	coord origin;
-	coord size;
-	origin.x = 3.0;
-	origin.y = 3.0;
-	size.x = m_size.x-6;
-	size.y = m_size.y-6;
-	AddEventArea(origin, size, FLAG_EVENT_INPUT_1 | FLAG_EVENT_INPUT_CLICKED_ALL, ewolEventCheckBoxClicked);
-
-}
-
-/*
-bool ewol::CheckBox::OnEventInput(int32_t IdInput, eventInputType_te typeEvent, etkFloat_t x, etkFloat_t y)
-{
-	EWOL_DEBUG("Event on BT ...");
-	return true;
-}
-*/
-
-bool ewol::CheckBox::OnEventArea(const char * generateEventId, etkFloat_t x, etkFloat_t y)
-{
-	bool eventIsOK = false;
-	//EWOL_DEBUG("Receive event : \"" << generateEventId << "\"");
-	if(ewolEventCheckBoxClicked == generateEventId) {
-		ewol::widgetManager::FocusKeep(this);
-		EWOL_INFO("CB pressed ... " << m_label);
-		if(true == m_value) {
-			m_value = false;
-		} else {
-			m_value = true;
-		}
-		OnRegenerateDisplay();
-		eventIsOK = true;
-	}
-	return eventIsOK;
-}
-
-bool ewol::CheckBox::OnEventKb(eventKbType_te typeEvent, char UTF8_data[UTF8_MAX_SIZE])
-{
-	//EWOL_DEBUG("BT PRESSED : \"" << UTF8_data << "\" size=" << strlen(UTF8_data));
-	if(    UTF8_data != NULL
-	    && typeEvent == ewol::EVENT_KB_TYPE_DOWN
-	    && (    UTF8_data[0] == '\r'
-	         || UTF8_data[0] == ' ')
-	       ) {
-		return OnEventArea(ewolEventCheckBoxClicked, -1, -1);
-	}
-	return false;
-}
-

Sources/ewol/widget/CheckBox.h

@@ -1,62 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/widget/CheckBox.h
- * @brief ewol check-box widget system (header)
- * @author Edouard DUPIN
- * @date 07/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#ifndef __EWOL_CHECK_BOX_H__
-#define __EWOL_CHECK_BOX_H__
-
-#include <etk/Types.h>
-#include <ewol/Debug.h>
-#include <ewol/Widget.h>
-
-namespace ewol {
-	class CheckBox :public ewol::Widget
-	{
-		public:
-			CheckBox(void);
-			CheckBox(etk::String newLabel);
-			void Init(void);
-			virtual ~CheckBox(void);
-			virtual bool   CalculateMinSize(void);
-			void           SetLabel(etk::String newLabel);
-			// TODO : 
-			//void           SetSize(int32_t size);
-			//void           SetFont(etk::String fontName);
-			//void           ResetDefaultParameters(void);
-			void           SetValue(bool val);
-			bool           GetValue(void);
-		private:
-			etk::String    m_label;
-			bool           m_value;
-			color_ts       m_textColorFg;  //!< Text color
-			color_ts       m_textColorBg;  //!< Background color
-		public:
-			virtual void   OnRegenerateDisplay(void);
-		public:
-			//virtual bool OnEventInput(int32_t IdInput, eventInputType_te typeEvent, etkFloat_t x, etkFloat_t y);
-			virtual bool OnEventArea(const char * generateEventId, etkFloat_t x, etkFloat_t y);
-			virtual bool OnEventKb(eventKbType_te typeEvent, char UTF8_data[UTF8_MAX_SIZE]);
-	};
-};
-
-#endif

Sources/ewol/widget/Entry.cpp

@@ -1,29 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/widget/Entry.cpp
- * @brief ewol entry widget system (Sources)
- * @author Edouard DUPIN
- * @date 07/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-#include <ewol/widget/Entry.h>
-
-#undef __class__
-#define __class__	"ewol::Entry"

Sources/ewol/widget/Entry.h

@@ -1,41 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/widget/Entry.h
- * @brief ewol entry widget system (header)
- * @author Edouard DUPIN
- * @date 07/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#ifndef __EWOL_ENTRY_H__
-#define __EWOL_ENTRY_H__
-
-#include <etk/Types.h>
-#include <ewol/Debug.h>
-#include <ewol/Widget.h>
-
-namespace ewol {
-	class Entry :public ewol::Widget
-	{
-		public:
-			Entry(void) { };
-			virtual ~Entry(void) { };
-	};
-};
-
-#endif

Sources/ewol/widget/List.cpp

@@ -1,30 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/widget/List.cpp
- * @brief ewol list widget system (Sources)
- * @author Edouard DUPIN
- * @date 07/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-#include <ewol/widget/List.h>
-
-#undef __class__
-#define __class__	"ewol::List"
-

Sources/ewol/widget/List.h

@@ -1,41 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/widget/List.h
- * @brief ewol list widget system (header)
- * @author Edouard DUPIN
- * @date 07/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#ifndef __EWOL_LIST_H__
-#define __EWOL_LIST_H__
-
-#include <etk/Types.h>
-#include <ewol/Debug.h>
-#include <ewol/Widget.h>
-
-namespace ewol {
-	class List :public ewol::Widget
-	{
-		public:
-			List(void) { };
-			virtual ~List(void) { };
-	};
-};
-
-#endif

Sources/ewol/widget/SizerHori.cpp

@@ -1,232 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/widget/SizerHori.cpp
- * @brief ewol hirisantal sizer widget system (Sources)
- * @author Edouard DUPIN
- * @date 07/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-
-#include <ewol/widget/SizerHori.h>
-
-#undef __class__
-#define __class__	"ewol::SizerHori"
-
-ewol::SizerHori::SizerHori(void)
-{
-	GenericDrawDisable();
-	SpecificDrawEnable();
-}
-
-ewol::SizerHori::~SizerHori(void)
-{
-	SubWidgetRemoveAll();
-}
-
-
-bool ewol::SizerHori::CalculateSize(etkFloat_t availlableX, etkFloat_t availlableY)
-{
-	//EWOL_DEBUG("Update Size");
-	m_size.x = availlableX;
-	m_size.y = availlableY;
-	// calculate unExpendable Size :
-	etkFloat_t unexpendableSize=0.0;
-	int32_t nbWidgetFixedSize=0;
-	int32_t nbWidgetNotFixedSize=0;
-	for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
-		if (NULL != m_subWidget[iii]) {
-			coord tmpSize = m_subWidget[iii]->GetMinSize();
-			unexpendableSize += tmpSize.x;
-			if (false == m_subWidget[iii]->CanExpentX()) {
-				nbWidgetFixedSize++;
-			} else {
-				nbWidgetNotFixedSize++;
-			}
-		}
-	}
-	etkFloat_t sizeToAddAtEveryOne = 0;
-	// 2 cases : 1 or more can Expend, or all is done ...
-	if (0 != nbWidgetNotFixedSize) {
-		sizeToAddAtEveryOne = (m_size.x - unexpendableSize) / nbWidgetNotFixedSize;
-		if (sizeToAddAtEveryOne<0.0) {
-			sizeToAddAtEveryOne=0;
-		}
-	}
-	coord tmpOrigin;
-	tmpOrigin.x = m_origin.x;
-	tmpOrigin.y = m_origin.y;
-	for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
-		if (NULL != m_subWidget[iii]) {
-			coord tmpSize = m_subWidget[iii]->GetMinSize();
-			// Set the origin :
-			//EWOL_DEBUG("Set ORIGIN : " << tmpOrigin.x << "," << tmpOrigin.y << ")");
-			m_subWidget[iii]->SetOrigin(tmpOrigin.x, tmpOrigin.y);
-			// Now Update his Size  his size in X and the curent sizer size in Y:
-			if (true == m_subWidget[iii]->CanExpentX()) {
-				m_subWidget[iii]->CalculateSize(tmpSize.x+sizeToAddAtEveryOne, m_size.y);
-				tmpOrigin.x += tmpSize.x+sizeToAddAtEveryOne;
-			} else {
-				m_subWidget[iii]->CalculateSize(tmpSize.x, m_size.y);
-				tmpOrigin.x += tmpSize.x;
-			}
-		}
-	}
-	return true;
-}
-
-
-bool ewol::SizerHori::CalculateMinSize(void)
-{
-	//EWOL_DEBUG("Update minimum Size");
-	m_userExpendX=false;
-	m_userExpendY=false;
-	m_minSize.x = 0.0;
-	m_minSize.y = 0.0;
-	for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
-		if (NULL != m_subWidget[iii]) {
-			m_subWidget[iii]->CalculateMinSize();
-			if (true == m_subWidget[iii]->CanExpentX()) {
-				m_userExpendX = true;
-			}
-			if (true == m_subWidget[iii]->CanExpentY()) {
-				m_userExpendY = true;
-			}
-			coord tmpSize = m_subWidget[iii]->GetMinSize();
-			m_minSize.x += tmpSize.x;
-			if (tmpSize.y>m_minSize.y) {
-				m_minSize.y = tmpSize.y;
-			}
-		}
-	}
-	//EWOL_DEBUG("Result : expend  X="<< m_userExpendX << " Y=" << m_userExpendY);
-	//EWOL_DEBUG("         minSize ("<< m_minSize.x << "," << m_minSize.y << ")");
-	return true;
-}
-
-void ewol::SizerHori::SetMinSise(etkFloat_t x, etkFloat_t y)
-{
-	EWOL_ERROR("Sizer can not have a user Minimum size (herited from under elements)");
-}
-
-void ewol::SizerHori::SetExpendX(bool newExpend)
-{
-	EWOL_ERROR("Sizer can not have a user expend settings X (herited from under elements)");
-}
-
-void ewol::SizerHori::SetExpendY(bool newExpend)
-{
-	EWOL_ERROR("Sizer can not have a user expend settings Y (herited from under elements)");
-}
-
-
-//etk::VectorType<ewol::Widget*> m_SubWidget;
-
-void ewol::SizerHori::SubWidgetRemoveAll(void)
-{
-	for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
-		if (NULL != m_subWidget[iii]) {
-			delete(m_subWidget[iii]);
-			m_subWidget[iii] = NULL;
-		}
-	}
-	m_subWidget.Clear();
-}
-
-
-void ewol::SizerHori::SubWidgetAdd(ewol::Widget* newWidget)
-{
-	if (NULL == newWidget) {
-		return;
-	}
-	m_subWidget.PushBack(newWidget);
-	newWidget->SetParrent(this);
-}
-
-
-void ewol::SizerHori::SubWidgetRemove(ewol::Widget* newWidget)
-{
-	if (NULL == newWidget) {
-		return;
-	}
-	for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
-		if (newWidget == m_subWidget[iii]) {
-			if (NULL != m_subWidget[iii]) {
-				delete(m_subWidget[iii]);
-				m_subWidget[iii] = NULL;
-			}
-			m_subWidget.Erase(iii);
-			return;
-		}
-	}
-}
-
-void ewol::SizerHori::SubWidgetUnLink(ewol::Widget* newWidget)
-{
-	if (NULL == newWidget) {
-		return;
-	}
-	for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
-		if (newWidget == m_subWidget[iii]) {
-			m_subWidget[iii] = NULL;
-			m_subWidget.Erase(iii);
-			return;
-		}
-	}
-}
-
-
-bool ewol::SizerHori::OnDraw(void)
-{
-	for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
-		if (NULL != m_subWidget[iii]) {
-			m_subWidget[iii]->GenDraw();
-		}
-	}
-	return true;
-}
-
-
-void ewol::SizerHori::OnRegenerateDisplay(void)
-{
-	for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
-		if (NULL != m_subWidget[iii]) {
-			m_subWidget[iii]->OnRegenerateDisplay();
-		}
-	}
-}
-
-
-bool ewol::SizerHori::OnEventInput(int32_t IdInput, eventInputType_te typeEvent, etkFloat_t x, etkFloat_t y)
-{
-	for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
-		if (NULL != m_subWidget[iii]) {
-			coord tmpSize = m_subWidget[iii]->GetSize();
-			coord tmpOrigin = m_subWidget[iii]->GetOrigin();
-			if(    (tmpOrigin.x <= x && tmpOrigin.x + tmpSize.x >= x)
-			    && (tmpOrigin.y <= y && tmpOrigin.y + tmpSize.y >= y) )
-			{
-				return m_subWidget[iii]->GenEventInput(IdInput, typeEvent, x, y);
-			}
-		}
-	}
-	return true;
-}
-
-

Sources/ewol/widget/SizerHori.h

@@ -1,60 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/widget/SizerHori.h
- * @brief ewol hirisantal sizer widget system (header)
- * @author Edouard DUPIN
- * @date 07/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#ifndef __EWOL_SIZER_HORI_H__
-#define __EWOL_SIZER_HORI_H__
-
-#include <etk/Types.h>
-#include <ewol/Debug.h>
-#include <ewol/Widget.h>
-
-namespace ewol {
-	class SizerHori :public ewol::Widget
-	{
-		public:
-			SizerHori(void);
-			virtual ~SizerHori(void);
-		public:
-			virtual bool   CalculateSize(etkFloat_t availlableX, etkFloat_t availlableY); // this generate the current size ...
-			virtual bool   CalculateMinSize(void); //update the min Size ... and the expend parameters for the sizer
-			virtual void   SetMinSise(etkFloat_t x=-1, etkFloat_t y=-1);
-			virtual void   SetExpendX(bool newExpend=false);
-			virtual void   SetExpendY(bool newExpend=false);
-		private:
-			etk::VectorType<ewol::Widget*> m_subWidget;
-		public:
-			void           SubWidgetRemoveAll(void);
-			void           SubWidgetAdd(ewol::Widget* newWidget);
-			void           SubWidgetRemove(ewol::Widget* newWidget);
-			void           SubWidgetUnLink(ewol::Widget* newWidget);
-		protected:
-			virtual bool   OnDraw(void);
-		public:
-			virtual void   OnRegenerateDisplay(void);
-		public:
-			virtual bool   OnEventInput(int32_t IdInput, eventInputType_te typeEvent, etkFloat_t x, etkFloat_t y);
-	};
-};
-
-#endif

Sources/ewol/widget/SizerVert.cpp

@@ -1,230 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/widget/SizerVert.cpp
- * @brief ewol vertical sizer widget system (Sources)
- * @author Edouard DUPIN
- * @date 07/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-
-#include <ewol/widget/SizerVert.h>
-
-
-#undef __class__
-#define __class__	"ewol::SizerVert"
-
-
-ewol::SizerVert::SizerVert(void)
-{
-	GenericDrawDisable();
-	SpecificDrawEnable();
-}
-
-ewol::SizerVert::~SizerVert(void)
-{
-	SubWidgetRemoveAll();
-}
-
-
-bool ewol::SizerVert::CalculateSize(etkFloat_t availlableX, etkFloat_t availlableY)
-{
-	//EWOL_DEBUG("Update Size");
-	m_size.x = availlableX;
-	m_size.y = availlableY;
-	// calculate unExpendable Size :
-	etkFloat_t unexpendableSize=0.0;
-	int32_t nbWidgetFixedSize=0;
-	int32_t nbWidgetNotFixedSize=0;
-	for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
-		if (NULL != m_subWidget[iii]) {
-			coord tmpSize = m_subWidget[iii]->GetMinSize();
-			unexpendableSize += tmpSize.y;
-			if (false == m_subWidget[iii]->CanExpentY()) {
-				nbWidgetFixedSize++;
-			} else {
-				nbWidgetNotFixedSize++;
-			}
-		}
-	}
-	// 2 cases : 1 or more can Expend, or all is done ...
-	etkFloat_t sizeToAddAtEveryOne = 0;
-	// 2 cases : 1 or more can Expend, or all is done ...
-	if (0 != nbWidgetNotFixedSize) {
-		sizeToAddAtEveryOne = (m_size.y - unexpendableSize) / nbWidgetNotFixedSize;
-		if (sizeToAddAtEveryOne<0.0) {
-			sizeToAddAtEveryOne=0;
-		}
-	}
-	coord tmpOrigin;
-	tmpOrigin.x = m_origin.x;
-	tmpOrigin.y = m_origin.y;
-	for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
-		if (NULL != m_subWidget[iii]) {
-			coord tmpSize = m_subWidget[iii]->GetMinSize();
-			// Set the origin :
-			//EWOL_DEBUG("Set ORIGIN : " << tmpOrigin.x << "," << tmpOrigin.y << ")");
-			m_subWidget[iii]->SetOrigin(tmpOrigin.x, tmpOrigin.y);
-			// Now Update his Size  his size in X and the curent sizer size in Y:
-			if (true == m_subWidget[iii]->CanExpentY()) {
-				m_subWidget[iii]->CalculateSize(m_size.x, tmpSize.y+sizeToAddAtEveryOne);
-				tmpOrigin.y += tmpSize.y+sizeToAddAtEveryOne;
-			} else {
-				m_subWidget[iii]->CalculateSize(m_size.x, tmpSize.y);
-				tmpOrigin.y += tmpSize.y;
-			}
-		}
-	}
-	return true;
-}
-
-
-bool ewol::SizerVert::CalculateMinSize(void)
-{
-	//EWOL_DEBUG("Update minimum Size");
-	m_userExpendX=false;
-	m_userExpendY=false;
-	m_minSize.x = 0.0;
-	m_minSize.y = 0.0;
-	for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
-		if (NULL != m_subWidget[iii]) {
-			m_subWidget[iii]->CalculateMinSize();
-			if (true == m_subWidget[iii]->CanExpentX()) {
-				m_userExpendX = true;
-			}
-			if (true == m_subWidget[iii]->CanExpentY()) {
-				m_userExpendY = true;
-			}
-			coord tmpSize = m_subWidget[iii]->GetMinSize();
-			m_minSize.y += tmpSize.y;
-			if (tmpSize.x>m_minSize.x) {
-				m_minSize.x = tmpSize.x;
-			}
-		}
-	}
-	//EWOL_DEBUG("Result : expend  X="<< m_userExpendX << " Y=" << m_userExpendY);
-	//EWOL_DEBUG("         minSize ("<< m_minSize.x << "," << m_minSize.y << ")");
-	return true;
-}
-
-void ewol::SizerVert::SetMinSise(etkFloat_t x, etkFloat_t y)
-{
-	EWOL_ERROR("Sizer can not have a user Minimum size (herited from under elements)");
-}
-
-void ewol::SizerVert::SetExpendX(bool newExpend)
-{
-	EWOL_ERROR("Sizer can not have a user expend settings X (herited from under elements)");
-}
-
-void ewol::SizerVert::SetExpendY(bool newExpend)
-{
-	EWOL_ERROR("Sizer can not have a user expend settings Y (herited from under elements)");
-}
-
-
-//etk::VectorType<ewol::Widget*> m_SubWidget;
-
-void ewol::SizerVert::SubWidgetRemoveAll(void)
-{
-	for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
-		delete(m_subWidget[iii]);
-		m_subWidget[iii] = NULL;
-	}
-	m_subWidget.Clear();
-}
-
-
-void ewol::SizerVert::SubWidgetAdd(ewol::Widget* newWidget)
-{
-	if (NULL == newWidget) {
-		return;
-	}
-	m_subWidget.PushBack(newWidget);
-	newWidget->SetParrent(this);
-}
-
-
-void ewol::SizerVert::SubWidgetRemove(ewol::Widget* newWidget)
-{
-	if (NULL == newWidget) {
-		return;
-	}
-	for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
-		if (newWidget == m_subWidget[iii]) {
-			delete(m_subWidget[iii]);
-			m_subWidget[iii] = NULL;
-			m_subWidget.Erase(iii);
-			return;
-		}
-	}
-}
-
-void ewol::SizerVert::SubWidgetUnLink(ewol::Widget* newWidget)
-{
-	if (NULL == newWidget) {
-		return;
-	}
-	for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
-		if (newWidget == m_subWidget[iii]) {
-			m_subWidget[iii] = NULL;
-			m_subWidget.Erase(iii);
-			return;
-		}
-	}
-}
-
-
-bool ewol::SizerVert::OnDraw(void)
-{
-	for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
-		if (NULL != m_subWidget[iii]) {
-			m_subWidget[iii]->GenDraw();
-		}
-	}
-	return true;
-}
-
-
-
-void ewol::SizerVert::OnRegenerateDisplay(void)
-{
-	for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
-		if (NULL != m_subWidget[iii]) {
-			m_subWidget[iii]->OnRegenerateDisplay();
-		}
-	}
-}
-
-
-bool ewol::SizerVert::OnEventInput(int32_t IdInput, eventInputType_te typeEvent, etkFloat_t x, etkFloat_t y)
-{
-	for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
-		if (NULL != m_subWidget[iii]) {
-			coord tmpSize = m_subWidget[iii]->GetSize();
-			coord tmpOrigin = m_subWidget[iii]->GetOrigin();
-			if(    (tmpOrigin.x <= x && tmpOrigin.x + tmpSize.x >= x)
-			    && (tmpOrigin.y <= y && tmpOrigin.y + tmpSize.y >= y) )
-			{
-				return m_subWidget[iii]->GenEventInput(IdInput, typeEvent, x, y);
-			}
-		}
-	}
-	return true;
-}
-

Sources/ewol/widget/SizerVert.h

@@ -1,60 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/widget/SizerVert.h
- * @brief ewol vertical sizer widget system (header)
- * @author Edouard DUPIN
- * @date 07/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#ifndef __EWOL_SIZER_VERT_H__
-#define __EWOL_SIZER_VERT_H__
-
-#include <etk/Types.h>
-#include <ewol/Debug.h>
-#include <ewol/Widget.h>
-
-namespace ewol {
-	class SizerVert :public ewol::Widget
-	{
-		public:
-			SizerVert(void);
-			virtual ~SizerVert(void);
-		public:
-			virtual bool   CalculateSize(etkFloat_t availlableX, etkFloat_t availlableY); // this generate the current size ...
-			virtual bool   CalculateMinSize(void); //update the min Size ... and the expend parameters for the sizer
-			virtual void   SetMinSise(etkFloat_t x=-1, etkFloat_t y=-1);
-			virtual void   SetExpendX(bool newExpend=false);
-			virtual void   SetExpendY(bool newExpend=false);
-		private:
-			etk::VectorType<ewol::Widget*> m_subWidget;
-		public:
-			void           SubWidgetRemoveAll(void);
-			void           SubWidgetAdd(ewol::Widget* newWidget);
-			void           SubWidgetRemove(ewol::Widget* newWidget);
-			void           SubWidgetUnLink(ewol::Widget* newWidget);
-		protected:
-			virtual bool   OnDraw(void);
-		public:
-			virtual void   OnRegenerateDisplay(void);
-		public:
-			virtual bool   OnEventInput(int32_t IdInput, eventInputType_te typeEvent, etkFloat_t x, etkFloat_t y);
-	};
-};
-
-#endif

Sources/ewol/widget/Test.cpp

@@ -1,169 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/widget/Test.cpp
- * @brief ewol Test widget system (Sources)
- * @author Edouard DUPIN
- * @date 07/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#include <ewol/widget/Test.h>
-
-#include <ewol/OObject.h>
-#include <ewol/themeManager.h>
-
-
-
-const char * ewolEventTestPressed    = "ewol Test Pressed";
-
-
-
-#undef __class__
-#define __class__	"ewol::Test"
-
-ewol::Test::Test(void)
-{
-	m_elementID = 0;
-}
-
-
-ewol::Test::~Test(void)
-{
-	
-}
-
-bool ewol::Test::CalculateMinSize(void)
-{
-	m_minSize.x = 150;
-	m_minSize.y = 150;
-	return true;
-}
-
-void ewol::Test::OnRegenerateDisplay(void)
-{
-	// clean the object list ...
-	ClearOObjectList();
-	ewol::OObject2DColored * tmpOObjects = NULL;
-	
-	tmpOObjects = new ewol::OObject2DColored;
-	
-	tmpOObjects->SetColor(1.0, 0.0, 0.0, 1.0);
-	tmpOObjects->Rectangle( 0, 0, m_size.x, m_size.y);
-	tmpOObjects->SetColor(1.0, 1.0, 1.0, 1.0);
-	tmpOObjects->Rectangle( 3, 3, m_size.x-6, m_size.y-6);
-	
-	tmpOObjects->SetColor(0.0, 0.0, 1.0, 1.0);
-	
-	if (0 == m_elementID) {
-		tmpOObjects->Line(50, 50, 100,  50, 10); // 0°
-	} else if (1 == m_elementID) {
-		tmpOObjects->Line(50, 50, 100, 100, 15); // 45°
-	} else if (2 == m_elementID) {
-		tmpOObjects->Line(50, 50,  50, 100, 20); // 90°
-	} else if (3 == m_elementID) {
-		tmpOObjects->Line(50, 50,   0, 100, 5); // 135°
-	} else if (4 == m_elementID) {
-		tmpOObjects->Line(50, 50,   0,  50, 3); // 180°
-	} else if (5 == m_elementID) {
-		tmpOObjects->Line(50, 50,   0,   0, 2); // 225°
-	} else if (6 == m_elementID) {
-		tmpOObjects->Line(50, 50,  50,   0, 1); // °
-	} else {
-		tmpOObjects->Line(50, 50, 100,   0, 0.5); // °
-	}
-	
-	if (0 == m_elementID) {
-		tmpOObjects->SetColor(0.0, 1.0, 0.0, 1.0);
-		tmpOObjects->Disc(200, 100, 5);
-	} else if (1 == m_elementID) {
-		tmpOObjects->SetColor(0.0, 1.0, 0.0, 1.0);
-		tmpOObjects->Disc(200, 100, 10);
-	} else if (2 == m_elementID) {
-		tmpOObjects->SetColor(0.0, 1.0, 0.0, 1.0);
-		tmpOObjects->Disc(200, 100, 15);
-	} else if (3 == m_elementID) {
-		tmpOObjects->SetColor(0.0, 1.0, 0.0, 1.0);
-		tmpOObjects->Disc(200, 100, 20);
-	} else if (4 == m_elementID) {
-		tmpOObjects->SetColor(0.0, 1.0, 0.0, 1.0);
-		tmpOObjects->Disc(200, 100, 25);
-	} else if (5 == m_elementID) {
-		tmpOObjects->SetColor(0.0, 1.0, 0.0, 0.75);
-		tmpOObjects->Disc(200, 100, 100);
-	} else if (6 == m_elementID) {
-		tmpOObjects->SetColor(0.0, 1.0, 0.0, 0.75);
-		tmpOObjects->Disc(200, 100, 200);
-	} else {
-		tmpOObjects->SetColor(0.0, 1.0, 0.0, 0.5);
-		tmpOObjects->Disc(200, 100, 300);
-	}
-	tmpOObjects->SetColor(0.0, 0.0, 0.0, 1.0);
-	if (0 == m_elementID) {
-		tmpOObjects->Circle(100, 100, 10, 3);
-	} else if (1 == m_elementID) {
-		tmpOObjects->Circle(100, 100, 20, 3);
-	} else if (2 == m_elementID) {
-		tmpOObjects->Circle(100, 100, 30, 2);
-	} else if (3 == m_elementID) {
-		tmpOObjects->Circle(100, 100, 40, 1);
-	} else if (4 == m_elementID) {
-		tmpOObjects->Circle(100, 100, 50, 0.5);
-	} else if (5 == m_elementID) {
-		tmpOObjects->Circle(100, 100, 100, 25);
-	} else if (6 == m_elementID) {
-		tmpOObjects->Circle(100, 100, 100, 35);
-	} else {
-		tmpOObjects->Circle(100, 100, 100, 50);
-	}
-	tmpOObjects->SetColor(1.0, 1.0, 0.0, 1.0);
-	tmpOObjects->DiscPart(150, 60, 60, 45, 180);
-	tmpOObjects->SetColor(0.0, 0.0, 0.0, 1.0);
-	tmpOObjects->CirclePart(150, 60, 60, 2, 45, 180);
-	
-	AddOObject(tmpOObjects, "BouttonDecoration");
-	/*
-	tmpOObjects = new ewol::OObject2DColored;
-	ewol::theme::Generate(0, 0, *tmpOObjects, 50, 50, m_size.x*0.75, m_size.y*0.75);
-	AddOObject(tmpOObjects, "themeObject");
-	*/
-	
-	// Regenerate the event Area:
-	EventAreaRemoveAll();
-	coord origin;
-	coord size;
-	origin.x = 3.0;
-	origin.y = 3.0;
-	size.x = m_size.x-6;
-	size.y = m_size.y-6;
-	AddEventArea(origin, size, FLAG_EVENT_INPUT_1 | FLAG_EVENT_INPUT_CLICKED_ALL, ewolEventTestPressed);
-}
-
-bool ewol::Test::OnEventArea(const char * generateEventId, etkFloat_t x, etkFloat_t y)
-{
-	bool eventIsOK = false;
-	//EWOL_DEBUG("Receive event : \"" << generateEventId << "\"");
-	if(ewolEventTestPressed == generateEventId) {
-		m_elementID++;
-		if (m_elementID > 7 ) {
-			m_elementID = 0;
-		}
-		OnRegenerateDisplay();
-		eventIsOK = true;
-	}
-	return eventIsOK;
-}

Sources/ewol/widget/Test.h

@@ -1,48 +0,0 @@
-/**
- *******************************************************************************
- * @file ewol/widget/Test.h
- * @brief ewol test widget system (header)
- * @author Edouard DUPIN
- * @date 07/11/2011
- * @par Project
- * ewol
- *
- * @par Copyright
- * Copyright 2011 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
- *
- * Term of the licence in in the file licence.txt.
- *
- *******************************************************************************
- */
-
-#ifndef __EWOL_TEST_H__
-#define __EWOL_TEST_H__
-
-#include <etk/Types.h>
-#include <ewol/Debug.h>
-#include <ewol/Widget.h>
-
-namespace ewol {
-	class Test :public ewol::Widget
-	{
-		public:
-			Test(void);
-			virtual ~Test(void);
-			virtual bool   CalculateMinSize(void);
-		public:
-			virtual void   OnRegenerateDisplay(void);
-		public:
-			virtual bool OnEventArea(const char * generateEventId, etkFloat_t x, etkFloat_t y);
-		private:
-			int32_t m_elementID;
-	};
-};
-
-#endif

Sources/importgl.h

@@ -1,34 +0,0 @@
-
-#ifndef __IMPORTGL_H__
-#define __IMPORTGL_H__
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#if defined(__PLATFORM__Linux)
-	#include <GL/gl.h>
-	#include <GL/glu.h>
-#elif defined(__PLATFORM__DoubleBuffer)
-	
-#elif defined(__PLATFORM__Android)
-	#include <GLES/gl.h>
-	void glOrtho(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat nearVal, GLfloat farVal);
-#elif defined(__PLATFORM__AndroidTablet)
-	#include <GLES/gl.h>
-	void glOrtho(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat nearVal, GLfloat farVal);
-#elif defined(__PLATFORM__IPhone)
-	
-#elif defined(__PLATFORM__IPad)
-	
-#else
-	#error you need to specify a platform ...
-#endif
-
-
-#ifdef __cplusplus
-}
-#endif
-
-
-#endif

Sources/tinyXML/tinystr.cpp

@@ -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

Sources/tinyXML/tinystr.h

@@ -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