atria-soft/ewol
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Compare commits

base: atria-soft:main
Branches Tags
atria-soft:main
atria-soft:dev
atria-soft:gh-pages
atria-soft:android-rework
atria-soft:v1.0.0
atria-soft:0.10.0
atria-soft:0.9.9
atria-soft:0.9.8
atria-soft:0.9.7
atria-soft:0.9.6
atria-soft:0.9.5
atria-soft:0.9.4
atria-soft:0.9.3
atria-soft:0.9.2
atria-soft:0.9.1
atria-soft:0.9.0
atria-soft:0.8.4
atria-soft:0.8.3
atria-soft:0.8.2
atria-soft:0.8.1
atria-soft:0.8.0
atria-soft:0.5.0
atria-soft:0.4.4
atria-soft:0.4.3
atria-soft:0.4.1
atria-soft:0.4.0
atria-soft:0.3.5
atria-soft:0.3.4
atria-soft:0.3.3
atria-soft:0.3.2
atria-soft:0.3.1
atria-soft:0.3.0
atria-soft:0.2.5
atria-soft:0.2.4
atria-soft:0.2.3
atria-soft:0.2.2
atria-soft:0.2.1
atria-soft:0.2.0
atria-soft:0.1.7
atria-soft:0.1.6
atria-soft:0.1.5
atria-soft:0.1.4
atria-soft:0.1.3
atria-soft:0.1.2
atria-soft:0.1.1
atria-soft:0.1.0
atria-soft:0.0.4
atria-soft:0.0.3
atria-soft:0.0.2
atria-soft:0.0.1
atria-soft:0.0.0
..
compare: atria-soft:0.1.1
Branches Tags
atria-soft:dev
atria-soft:main
atria-soft:gh-pages
atria-soft:android-rework
atria-soft:v1.0.0
atria-soft:0.10.0
atria-soft:0.9.9
atria-soft:0.9.8
atria-soft:0.9.7
atria-soft:0.9.6
atria-soft:0.9.5
atria-soft:0.9.4
atria-soft:0.9.3
atria-soft:0.9.2
atria-soft:0.9.1
atria-soft:0.9.0
atria-soft:0.8.4
atria-soft:0.8.3
atria-soft:0.8.2
atria-soft:0.8.1
atria-soft:0.8.0
atria-soft:0.5.0
atria-soft:0.4.4
atria-soft:0.4.3
atria-soft:0.4.1
atria-soft:0.4.0
atria-soft:0.3.5
atria-soft:0.3.4
atria-soft:0.3.3
atria-soft:0.3.2
atria-soft:0.3.1
atria-soft:0.3.0
atria-soft:0.2.5
atria-soft:0.2.4
atria-soft:0.2.3
atria-soft:0.2.2
atria-soft:0.2.1
atria-soft:0.2.0
atria-soft:0.1.7
atria-soft:0.1.6
atria-soft:0.1.5
atria-soft:0.1.4
atria-soft:0.1.3
atria-soft:0.1.2
atria-soft:0.1.1
atria-soft:0.1.0
atria-soft:0.0.4
atria-soft:0.0.3
atria-soft:0.0.2
atria-soft:0.0.1
atria-soft:0.0.0

No commits in common. "main" and "0.1.1" have entirely different histories.
main ... 0.1.1

710 changed files with 61881 additions and 36844 deletions
Show Stats Expand all files Collapse all files

2
.gitignore vendored
View File

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

95
.travis.yml
View File

@ -1,95 +0,0 @@
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

59
Build/Makefile.Android.mk Normal file
View File

@ -0,0 +1,59 @@
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

194
Build/Makefile.Linux.mk Normal file
View File

@ -0,0 +1,194 @@
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)

56
Build/Makefile.common.mk Normal file
View File

@ -0,0 +1,56 @@
##################################################################################################################
# #
# 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)

79
Build/ewol.mk Normal file
View File

@ -0,0 +1,79 @@
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

373
LICENSE
View File

@ -1,373 +0,0 @@
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.

289
Makefile Normal file
View File

@ -0,0 +1,289 @@
##################################################################################################################
# #
# 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"`

137
README.md
View File

@ -1,128 +1,41 @@
Ewol
Edn
====
`Ewol` (Edn Widget OpenGl Layer) is a FREE software.
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)
This software is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY.
Instructions
============
download Build system:
----------------------
download the software :
sudo pip install lutin
sudo pip install pillow
git clone git://github.com/HeeroYui/ewol.git
cd edn
need google repo:
-----------------
Compile software and install :
see: http://source.android.com/source/downloading.html#installing-repo
sudo make DEBUG=0 install
mkdir ~/.bin
PATH=~/.bin:$PATH
curl https://storage.googleapis.com/git-repo-downloads/repo > ~/.bin/repo
chmod a+x ~/.bin/repo
Run Software :
???
download the software:
----------------------
License
=======
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
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.
# 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

55
Sources/base/gui.h Normal file
View File

@ -0,0 +1,55 @@
/**
*******************************************************************************
* @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

593
Sources/base/guiAndroid.cpp Normal file
View File

@ -0,0 +1,593 @@
/**
*******************************************************************************
* @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);
}

46
Sources/base/guiDoubleBuffer.cpp Normal file
View File

@ -0,0 +1,46 @@
/**
*******************************************************************************
* @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");
}

46
Sources/base/guiIPhone.cpp Normal file
View File

@ -0,0 +1,46 @@
/**
*******************************************************************************
* @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");
}

932
Sources/base/guiX11.cpp Normal file
View File

@ -0,0 +1,932 @@
/**
*******************************************************************************
* @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;
}

71
Sources/etk/Debug.cpp Normal file
View File

@ -0,0 +1,71 @@
/**
*******************************************************************************
* @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 ;
}

97
Sources/etk/Debug.h Normal file
View File

@ -0,0 +1,97 @@
/**
*******************************************************************************
* @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

25
Sources/etk/DebugInternal.cpp Normal file
View File

@ -0,0 +1,25 @@
/**
*******************************************************************************
* @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 ";

71
Sources/etk/DebugInternal.h Normal file
View File

@ -0,0 +1,71 @@
/**
*******************************************************************************
* @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

819
Sources/etk/File.cpp Normal file
View File

@ -0,0 +1,819 @@
/**
*******************************************************************************
* @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;
}

121
Sources/etk/File.h Normal file
View File

@ -0,0 +1,121 @@
/**
*******************************************************************************
* @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

51
Sources/etk/Memory.cpp Normal file
View File

@ -0,0 +1,51 @@
/**
*******************************************************************************
* @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

94
Sources/etk/Memory.h Normal file
View File

@ -0,0 +1,94 @@
/**
*******************************************************************************
* @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

484
Sources/etk/RegExp.cpp Normal file
View File

@ -0,0 +1,484 @@
/**
*******************************************************************************
* @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;
}

2120
Sources/etk/RegExp.h Normal file
View File

File diff suppressed because it is too large Load Diff

70
Sources/etk/Singleton.h Normal file
View File

@ -0,0 +1,70 @@
/**
*******************************************************************************
* @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

31
Sources/etk/Stream.cpp Normal file
View File

@ -0,0 +1,31 @@
/**
*******************************************************************************
* @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;

159
Sources/etk/Stream.h Normal file
View File

@ -0,0 +1,159 @@
/**
*******************************************************************************
* @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

724
Sources/etk/String.cpp Normal file
View File

@ -0,0 +1,724 @@
/**
*******************************************************************************
* @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("*********************************************************");
}

93
Sources/etk/String.h Normal file
View File

@ -0,0 +1,93 @@
/**
*******************************************************************************
* @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

115
Sources/etk/Types.h Normal file
View File

@ -0,0 +1,115 @@
/**
*******************************************************************************
* @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

509
Sources/etk/Vector.h Normal file
View File

@ -0,0 +1,509 @@
/**
*******************************************************************************
* @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

672
Sources/etk/VectorType.h Normal file
View File

@ -0,0 +1,672 @@
/**
*******************************************************************************
* @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

35
Sources/ewol/Android.mk Normal file
View File

@ -0,0 +1,35 @@
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)

28
Sources/ewol/Debug.cpp Normal file
View File

@ -0,0 +1,28 @@
/**
*******************************************************************************
* @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 ";

74
Sources/ewol/Debug.h Normal file
View File

@ -0,0 +1,74 @@
/**
*******************************************************************************
* @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

109
Sources/ewol/Font.h Normal file
View File

@ -0,0 +1,109 @@
/**
*******************************************************************************
* @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

543
Sources/ewol/FontBitmap.cpp Normal file
View File

@ -0,0 +1,543 @@
/**
*******************************************************************************
* @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();
}

664
Sources/ewol/FontFreeType.cpp Normal file
View File

@ -0,0 +1,664 @@
/**
*******************************************************************************
* @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();
}

36
Sources/ewol/Linux.mk Normal file
View File

@ -0,0 +1,36 @@
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)

63
Sources/ewol/OObject.cpp Normal file
View File

@ -0,0 +1,63 @@
/**
*******************************************************************************
* @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;
}

84
Sources/ewol/OObject.h Normal file
View File

@ -0,0 +1,84 @@
/**
*******************************************************************************
* @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>

610
Sources/ewol/OObject/2DColored.cpp Normal file
View File

@ -0,0 +1,610 @@
/**
*******************************************************************************
* @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);
}
}

69
Sources/ewol/OObject/2DColored.h Normal file
View File

@ -0,0 +1,69 @@
/**
*******************************************************************************
* @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

108
Sources/ewol/OObject/2DText.cpp Normal file
View File

@ -0,0 +1,108 @@
/**
*******************************************************************************
* @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;
}
}

53
Sources/ewol/OObject/2DText.h Normal file
View File

@ -0,0 +1,53 @@
/**
*******************************************************************************
* @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

120
Sources/ewol/OObject/2DTextured.cpp Normal file
View File

@ -0,0 +1,120 @@
/**
*******************************************************************************
* @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;
}
}

49
Sources/ewol/OObject/2DTextured.h Normal file
View File

@ -0,0 +1,49 @@
/**
*******************************************************************************
* @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

477
Sources/ewol/Texture.cpp Normal file
View File

@ -0,0 +1,477 @@
/**
*******************************************************************************
* @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;
}

50
Sources/ewol/Texture.h Normal file
View File

@ -0,0 +1,50 @@
/**
*******************************************************************************
* @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

242
Sources/ewol/Widget.cpp Normal file
View File

@ -0,0 +1,242 @@
/**
*******************************************************************************
* @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;
}
//} // ???

281
Sources/ewol/Widget.h Normal file
View File

@ -0,0 +1,281 @@
/**
*******************************************************************************
* @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

189
Sources/ewol/WidgetManager.cpp Normal file
View File

@ -0,0 +1,189 @@
/**
*******************************************************************************
* @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;
}

52
Sources/ewol/WidgetManager.h Normal file
View File

@ -0,0 +1,52 @@
/**
*******************************************************************************
* @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

220
Sources/ewol/Windows.cpp Normal file
View File

@ -0,0 +1,220 @@
/**
*******************************************************************************
* @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);
}

83
Sources/ewol/Windows.h Normal file
View File

@ -0,0 +1,83 @@
/**
*******************************************************************************
* @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

118
Sources/ewol/ewol.cpp Normal file
View File

@ -0,0 +1,118 @@
/**
*******************************************************************************
* @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();
}

51
Sources/ewol/ewol.h Normal file
View File

@ -0,0 +1,51 @@
/**
*******************************************************************************
* @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

46
Sources/ewol/file.mk Normal file
View File

@ -0,0 +1,46 @@
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

47
Sources/ewol/theme/EolBase.cpp Normal file
View File

@ -0,0 +1,47 @@
/**
*******************************************************************************
* @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..." );
}
*/

50
Sources/ewol/theme/EolBase.h Normal file
View File

@ -0,0 +1,50 @@
/**
*******************************************************************************
* @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

119
Sources/ewol/theme/EolBaseCircle.cpp Normal file
View File

@ -0,0 +1,119 @@
/**
*******************************************************************************
* @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);
}
}

57
Sources/ewol/theme/EolBaseCircle.h Normal file
View File

@ -0,0 +1,57 @@
/**
*******************************************************************************
* @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

28
Sources/ewol/theme/EolBaseCirclePart.cpp Normal file
View File

@ -0,0 +1,28 @@
/**
*******************************************************************************
* @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"

32
Sources/ewol/theme/EolBaseCirclePart.h Normal file
View File

@ -0,0 +1,32 @@
/**
*******************************************************************************
* @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

101
Sources/ewol/theme/EolBaseLine.cpp Normal file
View File

@ -0,0 +1,101 @@
/**
*******************************************************************************
* @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);
}

58
Sources/ewol/theme/EolBaseLine.h Normal file
View File

@ -0,0 +1,58 @@
/**
*******************************************************************************
* @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

28
Sources/ewol/theme/EolBasePolygone.cpp Normal file
View File

@ -0,0 +1,28 @@
/**
*******************************************************************************
* @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"

32
Sources/ewol/theme/EolBasePolygone.h Normal file
View File

@ -0,0 +1,32 @@
/**
*******************************************************************************
* @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

117
Sources/ewol/theme/EolBaseRect.cpp Normal file
View File

@ -0,0 +1,117 @@
/**
*******************************************************************************
* @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);
}
}

59
Sources/ewol/theme/EolBaseRect.h Normal file
View File

@ -0,0 +1,59 @@
/**
*******************************************************************************
* @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

28
Sources/ewol/theme/EolBaseTriangle.cpp Normal file
View File

@ -0,0 +1,28 @@
/**
*******************************************************************************
* @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"

32
Sources/ewol/theme/EolBaseTriangle.h Normal file
View File

@ -0,0 +1,32 @@
/**
*******************************************************************************
* @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

127
Sources/ewol/theme/EolColor.cpp Normal file
View File

@ -0,0 +1,127 @@
/**
*******************************************************************************
* @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;
}

60
Sources/ewol/theme/EolColor.h Normal file
View File

@ -0,0 +1,60 @@
/**
*******************************************************************************
* @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

288
Sources/ewol/theme/EolElement.cpp Normal file
View File

@ -0,0 +1,288 @@
/**
*******************************************************************************
* @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);
}
}

81
Sources/ewol/theme/EolElement.h Normal file
View File

@ -0,0 +1,81 @@
/**
*******************************************************************************
* @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

133
Sources/ewol/theme/EolElementFrame.cpp Normal file
View File

@ -0,0 +1,133 @@
/**
*******************************************************************************
* @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);
}
}

70
Sources/ewol/theme/EolElementFrame.h Normal file
View File

@ -0,0 +1,70 @@
/**
*******************************************************************************
* @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

262
Sources/ewol/theme/Theme.cpp Normal file
View File

@ -0,0 +1,262 @@
/**
*******************************************************************************
* @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;
}

71
Sources/ewol/theme/Theme.h Normal file
View File

@ -0,0 +1,71 @@
/**
*******************************************************************************
* @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

93
Sources/ewol/themeManager.cpp Normal file
View File

@ -0,0 +1,93 @@
/**
*******************************************************************************
* @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);
}

52
Sources/ewol/themeManager.h Normal file
View File

@ -0,0 +1,52 @@
/**
*******************************************************************************
* @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

208
Sources/ewol/widget/Button.cpp Normal file
View File

@ -0,0 +1,208 @@
/**
*******************************************************************************
* @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;
}

61
Sources/ewol/widget/Button.h Normal file
View File

@ -0,0 +1,61 @@
/**
*******************************************************************************
* @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

184
Sources/ewol/widget/CheckBox.cpp Normal file
View File

@ -0,0 +1,184 @@
/**
*******************************************************************************
* @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;
}

62
Sources/ewol/widget/CheckBox.h Normal file
View File

@ -0,0 +1,62 @@
/**
*******************************************************************************
* @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

29
Sources/ewol/widget/Entry.cpp Normal file
View File

@ -0,0 +1,29 @@
/**
*******************************************************************************
* @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"

41
Sources/ewol/widget/Entry.h Normal file
View File

@ -0,0 +1,41 @@
/**
*******************************************************************************
* @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

30
Sources/ewol/widget/List.cpp Normal file
View File

@ -0,0 +1,30 @@
/**
*******************************************************************************
* @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"

41
Sources/ewol/widget/List.h Normal file
View File

@ -0,0 +1,41 @@
/**
*******************************************************************************
* @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

232
Sources/ewol/widget/SizerHori.cpp Normal file
View File

@ -0,0 +1,232 @@
/**
*******************************************************************************
* @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;
}

60
Sources/ewol/widget/SizerHori.h Normal file
View File

@ -0,0 +1,60 @@
/**
*******************************************************************************
* @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

230
Sources/ewol/widget/SizerVert.cpp Normal file
View File

@ -0,0 +1,230 @@
/**
*******************************************************************************
* @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;
}

60
Sources/ewol/widget/SizerVert.h Normal file
View File

@ -0,0 +1,60 @@
/**
*******************************************************************************
* @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

169
Sources/ewol/widget/Test.cpp Normal file
View File

@ -0,0 +1,169 @@
/**
*******************************************************************************
* @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;
}

48
Sources/ewol/widget/Test.h Normal file
View File

@ -0,0 +1,48 @@
/**
*******************************************************************************
* @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

34
Sources/importgl.h Normal file
View File

@ -0,0 +1,34 @@
#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

116
Sources/tinyXML/tinystr.cpp Normal file
View File

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

319
Sources/tinyXML/tinystr.h Normal file
View File

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

1839
Sources/tinyXML/tinyxml.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

Some files were not shown because too many files have changed in this diff Show More