Compare commits
No commits in common. "main" and "0.1.4" have entirely different histories.
2
.gitignore
vendored
2
.gitignore
vendored
@ -60,5 +60,3 @@ ewol_release
|
||||
ehthumbs.db
|
||||
Icon?
|
||||
Thumbs.db
|
||||
Sources/libewol/ewol/os/AndroidAbstraction.cpp
|
||||
org_ewol_EwolConstants.h
|
||||
|
||||
95
.travis.yml
95
.travis.yml
@ -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
59
Build/Makefile.Android.mk
Normal 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)/Java/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)/Java/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
|
||||
39
Build/Makefile.Linux.mk
Normal file
39
Build/Makefile.Linux.mk
Normal file
@ -0,0 +1,39 @@
|
||||
|
||||
|
||||
|
||||
include $(EWOL_FOLDER)/Build/coreLinux/main.mk
|
||||
|
||||
|
||||
|
||||
|
||||
#include $(EWOL_FOLDER)/Build/Makefile.common.mk
|
||||
|
||||
|
||||
|
||||
|
||||
#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)"
(ndk-build) build native code"$(F_NORMALE)
|
||||
# cd $(PROJECT_NDK) ; NDK_PROJECT_PATH=$(PROJECT_PATH) NDK_MODULE_PATH=$(PROJECT_MODULE) ./ndk-build
|
||||
# #cd $(PROJECT_NDK) ; NDK_PROJECT_PATH=$(PROJECT_PATH) NDK_MODULE_PATH=$(PROJECT_MODULE) NDK_LOG=~/.ndklog.txt make -f $(EWOL_FOLDER)/Build/coreLinux/build-local.mk
|
||||
|
||||
#install: all
|
||||
# @echo $(CADRE_HAUT_BAS)
|
||||
# @echo ' INSTALL : $(F_VIOLET)./bin/$(PROJECT_NAME)-debug.apk$(F_NORMALE)'$(CADRE_COTERS)
|
||||
# @echo $(CADRE_HAUT_BAS)
|
||||
# # TODO : Later ....
|
||||
|
||||
#clean:
|
||||
# @echo $(CADRE_HAUT_BAS)
|
||||
# @echo ' CLEANING : bin libs gen obj'$(CADRE_COTERS)
|
||||
# @echo $(CADRE_HAUT_BAS)
|
||||
# # TODO : Later ....
|
||||
194
Build/Makefile.Linux_old.mk
Normal file
194
Build/Makefile.Linux_old.mk
Normal 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
56
Build/Makefile.common.mk
Normal 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=[1m
|
||||
export F_INVERSER=[7m
|
||||
export F_SOUSLIGNER=[4m
|
||||
export F_NORMALE=[m
|
||||
export F_NOIR=[31m
|
||||
export F_ROUGE=[31m
|
||||
export F_VERT=[32m
|
||||
export F_MARRON=[33m
|
||||
export F_BLUE=[34m
|
||||
export F_VIOLET=[35m
|
||||
export F_CYAN=[36m
|
||||
export F_GRIS=[37m
|
||||
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)
|
||||
|
||||
|
||||
76
Build/coreLinux/clearvars.mk
Normal file
76
Build/coreLinux/clearvars.mk
Normal file
@ -0,0 +1,76 @@
|
||||
###############################################################################
|
||||
## @file clearvars.mk
|
||||
## @author Y.M. Morgan
|
||||
## @date 2011/05/14
|
||||
##
|
||||
## Clear out values of all variables used by rule templates.
|
||||
###############################################################################
|
||||
|
||||
# Do NOT clear LOCAL_PATH, it is set BEFORE including this makefile
|
||||
|
||||
# Name of what's supposed to be generated
|
||||
LOCAL_MODULE :=
|
||||
|
||||
# Source files to compile
|
||||
LOCAL_SRC_FILES :=
|
||||
|
||||
# Files to copy verbatim
|
||||
LOCAL_COPY_FILES :=
|
||||
|
||||
# Static libraries that you want to include in your module
|
||||
LOCAL_STATIC_LIBRARIES :=
|
||||
|
||||
# Libraries you directly link against
|
||||
# Specify the name without the suffix
|
||||
LOCAL_SHARED_LIBRARIES :=
|
||||
|
||||
# Additional directories to instruct the C/C++ compilers to look for header files in.
|
||||
# Format : -I<fullpath>
|
||||
LOCAL_C_INCLUDES :=
|
||||
|
||||
# Additional flags to pass into the C or C++ compiler
|
||||
LOCAL_CFLAGS :=
|
||||
|
||||
# Additional flags to pass into only the C++ compiler
|
||||
LOCAL_CPPFLAGS :=
|
||||
|
||||
# Additional flags to pass into the static library generator
|
||||
LOCAL_ARFLAGS :=
|
||||
|
||||
# Additional flags to pass into the resource compiler (Windows only)
|
||||
LOCAL_RCFLAGS :=
|
||||
|
||||
# Additional flags to pass into the linker
|
||||
LOCAL_LDFLAGS :=
|
||||
|
||||
# Additional libraries to pass into the linker
|
||||
# Format : -l<name>
|
||||
LOCAL_LDLIBS :=
|
||||
|
||||
# Resource list file
|
||||
LOCAL_RESLIST :=
|
||||
|
||||
# Xrc file
|
||||
LOCAL_XRC :=
|
||||
|
||||
# Additionnal dependecies for rc files
|
||||
LOCAL_RC_DEPS :=
|
||||
|
||||
# Precompiled file
|
||||
LOCAL_PRECOMPILED_FILE :=
|
||||
|
||||
# Other variables used internally
|
||||
LOCAL_BUILT_MODULE :=
|
||||
LOCAL_INSTALLED_MODULE :=
|
||||
LOCAL_INTERMEDIATE_TARGETS :=
|
||||
LOCAL_MODULE_SUFFIX :=
|
||||
LOCAL_BUILDING_STATIC_LIBRARY :=
|
||||
LOCAL_BUILDING_SHARED_LIBRARY :=
|
||||
LOCAL_BUILDING_EXECUTABLE :=
|
||||
|
||||
# Trim MAKEFILE_LIST so that $(call my-dir) doesn't need to
|
||||
# iterate over thousands of entries every time.
|
||||
# Leave the current makefile to make sure we don't break anything
|
||||
# that expects to be able to find the name of the current makefile.
|
||||
MAKEFILE_LIST := $(lastword $(MAKEFILE_LIST))
|
||||
|
||||
15
Build/coreLinux/common-vc10.props
Normal file
15
Build/coreLinux/common-vc10.props
Normal file
@ -0,0 +1,15 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<ImportGroup Label="PropertySheets" />
|
||||
<PropertyGroup Label="UserMacros" />
|
||||
<PropertyGroup>
|
||||
<OutDir>$(SolutionDir)out_vc10\$(Configuration)\</OutDir>
|
||||
<IntDir>$(SolutionDir)build_vc10\$(Configuration)\$(ProjectName)\</IntDir>
|
||||
</PropertyGroup>
|
||||
<ItemDefinitionGroup>
|
||||
<ClCompile>
|
||||
<WarningLevel>Level4</WarningLevel>
|
||||
</ClCompile>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemGroup />
|
||||
</Project>
|
||||
109
Build/coreLinux/config.mk
Normal file
109
Build/coreLinux/config.mk
Normal file
@ -0,0 +1,109 @@
|
||||
###############################################################################
|
||||
## @file config.mk
|
||||
## @author Y.M. Morgan
|
||||
## @date 2011/05/14
|
||||
###############################################################################
|
||||
|
||||
###############################################################################
|
||||
## Make sure that there are no spaces in the absolute path; the build system
|
||||
## can't deal with them.
|
||||
###############################################################################
|
||||
|
||||
ifneq ("$(words $(shell pwd))","1")
|
||||
$(error Top directory contains space characters)
|
||||
endif
|
||||
|
||||
###############################################################################
|
||||
## OS type.
|
||||
###############################################################################
|
||||
|
||||
# set MingW32 flags
|
||||
ifneq ("$(shell echo $$OSTYPE | grep msys)","")
|
||||
OS_MINGW32 := 1
|
||||
DIR_SUFFIX := _mingw
|
||||
else
|
||||
OS_MINGW32 := 0
|
||||
DIR_SUFFIX :=
|
||||
endif
|
||||
|
||||
# Exe/dll suffix under mingw
|
||||
TARGET_STATIC_LIB_SUFFIX := .a
|
||||
ifeq ("$(OS_MINGW32)","1")
|
||||
TARGET_EXE_SUFFIX := .exe
|
||||
TARGET_SHARED_LIB_SUFFIX := .dll
|
||||
else
|
||||
TARGET_EXE_SUFFIX :=
|
||||
TARGET_SHARED_LIB_SUFFIX := .so
|
||||
endif
|
||||
|
||||
ifeq ("$(OS_MINGW32)","1")
|
||||
TARGET_GLOBAL_CFLAGS += -D__MINGW_FEATURES__=0
|
||||
endif
|
||||
|
||||
###############################################################################
|
||||
## Variables based on DEBUG/STATIC.
|
||||
###############################################################################
|
||||
|
||||
ifeq ("$(DEBUG)","0")
|
||||
TARGET_GLOBAL_CFLAGS += -O2 -g0 -DNDEBUG -DUNICODE -D_UNICODE
|
||||
TARGET_GLOBAL_LDFLAGS += -Wl,--strip-all
|
||||
TARGET_OUT_INTERMEDIATES := $(TOP_DIR)/linux/obj$(DIR_SUFFIX)/release
|
||||
TARGET_OUT := $(TOP_DIR)/linux/bin$(DIR_SUFFIX)/release
|
||||
else
|
||||
TARGET_GLOBAL_CFLAGS += -O0 -g2 -DDEBUG -D_DEBUG -DUNICODE -D_UNICODE
|
||||
TARGET_GLOBAL_LDFLAGS +=
|
||||
TARGET_OUT_INTERMEDIATES := $(TOP_DIR)/linux/obj$(DIR_SUFFIX)/debug
|
||||
TARGET_OUT := $(TOP_DIR)/linux/bin$(DIR_SUFFIX)/debug
|
||||
endif
|
||||
|
||||
###############################################################################
|
||||
## wxWidgets configuration.
|
||||
###############################################################################
|
||||
|
||||
# wx-config script
|
||||
WX_CONFIG := wx-config
|
||||
ifeq ("$(shell which $(WX_CONFIG))","")
|
||||
$(warning Unable to find $(WX_CONFIG))
|
||||
$(error Please make sure wxWidgets development package is installed)
|
||||
endif
|
||||
|
||||
# Argument for debug
|
||||
ifeq ("$(DEBUG)","0")
|
||||
WX_CONFIG_ARGS += --debug=no
|
||||
else
|
||||
WX_CONFIG_ARGS += --debug=yes
|
||||
endif
|
||||
|
||||
# Argument for unicode
|
||||
WX_CONFIG_ARGS += --unicode=yes
|
||||
|
||||
# Argument for static
|
||||
ifeq ("$(STATIC)","0")
|
||||
WX_CONFIG_ARGS += --static=no
|
||||
else
|
||||
WX_CONFIG_ARGS += --static=yes
|
||||
endif
|
||||
|
||||
# Get wxWidgets configuration
|
||||
WX_LIBS := $(shell $(WX_CONFIG) --libs $(WX_CONFIG_ARGS))
|
||||
WX_FLAGS := $(shell $(WX_CONFIG) --cppflags $(WX_CONFIG_ARGS))
|
||||
WX_VERSION := $(shell $(WX_CONFIG) --version $(WX_CONFIG_ARGS))
|
||||
|
||||
# Check that the configuration exists
|
||||
ifeq ("$(WX_LIBS)","")
|
||||
$(error wxWidgets configuration not supported: $(WX_CONFIG_ARGS))
|
||||
endif
|
||||
|
||||
# wxWidgets >= 2.8.10 required
|
||||
ifeq (0,$(shell expr $(WX_VERSION) \>= 2.8.10))
|
||||
$(error Unsupported version of wxWidgets: $(WX_VERSION))
|
||||
endif
|
||||
|
||||
###############################################################################
|
||||
## Determine gcc path and version.
|
||||
###############################################################################
|
||||
|
||||
GCC_PATH := $(shell which $(GCC))
|
||||
GCC_VERSION := $(shell $(GCC) --version | head -1 \
|
||||
| sed "s/.*\([0-9]\.[0-9]\.[0-9]\).*/\1/")
|
||||
|
||||
176
Build/coreLinux/defs.mk
Normal file
176
Build/coreLinux/defs.mk
Normal file
@ -0,0 +1,176 @@
|
||||
###############################################################################
|
||||
## @file defs.mk
|
||||
## @author Y.M. Morgan
|
||||
## @date 2011/05/14
|
||||
##
|
||||
## This file contains macros used by other makefiles.
|
||||
###############################################################################
|
||||
|
||||
###############################################################################
|
||||
## Figure out where we are.
|
||||
###############################################################################
|
||||
|
||||
define my-dir
|
||||
$(patsubst %/,%,$(dir $(lastword $(MAKEFILE_LIST),$(MAKEFILE_LIST))))
|
||||
endef
|
||||
|
||||
###############################################################################
|
||||
## Commands for running gcc to generate a precompiled file.
|
||||
###############################################################################
|
||||
|
||||
define transform-h-to-gch
|
||||
@mkdir -p $(dir $@)
|
||||
@echo "Precompile: $(PRIVATE_MODULE) <= $<"
|
||||
$(Q)$(GXX) \
|
||||
$(TARGET_PROJECT_INCLUDES) $(TARGET_C_INCLUDES) $(PRIVATE_C_INCLUDES) \
|
||||
$(TARGET_GLOBAL_CFLAGS) $(TARGET_GLOBAL_CPPFLAGS) $(GXX_FLAGS_WARNINGS) \
|
||||
$(PRIVATE_CFLAGS) $(PRIVATE_CPPFLAGS) \
|
||||
-c -MMD -MP -o $@ $<
|
||||
endef
|
||||
|
||||
###############################################################################
|
||||
## Commands for running gcc to compile a C++ file.
|
||||
###############################################################################
|
||||
|
||||
define transform-cpp-to-o
|
||||
@mkdir -p $(dir $@)
|
||||
@echo "C++: $(PRIVATE_MODULE) <= $<"
|
||||
$(Q)$(GXX) \
|
||||
$(TARGET_PROJECT_INCLUDES) $(TARGET_C_INCLUDES) $(PRIVATE_C_INCLUDES) \
|
||||
$(TARGET_GLOBAL_CFLAGS) $(TARGET_GLOBAL_CPPFLAGS) $(GXX_FLAGS_WARNINGS) \
|
||||
$(PRIVATE_CFLAGS) $(PRIVATE_CPPFLAGS) \
|
||||
-c -MMD -MP -o $@ $<
|
||||
endef
|
||||
|
||||
###############################################################################
|
||||
## Commands for running gcc to compile a C file.
|
||||
###############################################################################
|
||||
|
||||
define transform-c-to-o
|
||||
@echo "C: $(PRIVATE_MODULE) <= $<"
|
||||
@mkdir -p $(dir $@)
|
||||
$(Q)$(GCC) \
|
||||
$(TARGET_PROJECT_INCLUDES) $(TARGET_C_INCLUDES) $(PRIVATE_C_INCLUDES) \
|
||||
$(TARGET_GLOBAL_CFLAGS) $(GCC_FLAGS_WARNINGS) \
|
||||
$(PRIVATE_CFLAGS) \
|
||||
-c -MMD -MP -o $@ $<
|
||||
endef
|
||||
|
||||
###############################################################################
|
||||
## Commands for compiling rc files.
|
||||
###############################################################################
|
||||
define transform-rc-to-o
|
||||
@echo "RC: $(PRIVATE_MODULE) <= $<"
|
||||
@mkdir -p $(dir $@)
|
||||
@rm -f $@
|
||||
$(Q)$(WINDRES) \
|
||||
--use-temp-file -i$< -o$@ -I$(dir $<) \
|
||||
$(filter -D%, $(TARGET_GLOBAL_CFLAGS)) \
|
||||
$(filter -D%, $(PRIVATE_CFLAGS)) \
|
||||
$(TARGET_GLOBAL_RCFLAGS) $(PRIVATE_RCFLAGS)
|
||||
endef
|
||||
|
||||
###############################################################################
|
||||
## Commands for running ar.
|
||||
###############################################################################
|
||||
|
||||
# Explicitly delete the archive first so that ar doesn't
|
||||
# try to add to an existing archive.
|
||||
define transform-o-to-static-lib
|
||||
@mkdir -p $(dir $@)
|
||||
@echo "StaticLib: $(PRIVATE_MODULE) ($@)"
|
||||
@rm -f $@
|
||||
$(Q)$(AR) $(TARGET_GLOBAL_ARFLAGS) $(PRIVATE_ARFLAGS) $@ $^
|
||||
endef
|
||||
|
||||
###############################################################################
|
||||
## Commands for running gcc to link a shared library.
|
||||
###############################################################################
|
||||
|
||||
define transform-o-to-shared-lib
|
||||
@mkdir -p $(dir $@)
|
||||
@echo "SharedLib: $(PRIVATE_MODULE) ($@)"
|
||||
$(Q)$(GXX) \
|
||||
$(TARGET_GLOBAL_LDFLAGS) \
|
||||
-Wl,-Map -Wl,$(basename $@).map \
|
||||
-shared \
|
||||
-Wl,-soname -Wl,$(notdir $@) \
|
||||
-Wl,--unresolved-symbols=ignore-in-shared-libs \
|
||||
$(PRIVATE_LDFLAGS) \
|
||||
$(PRIVATE_ALL_OBJECTS) \
|
||||
-Wl,--no-whole-archive \
|
||||
$(PRIVATE_ALL_STATIC_LIBRARIES) \
|
||||
$(PRIVATE_ALL_SHARED_LIBRARIES) \
|
||||
-o $@ \
|
||||
$(PRIVATE_LDLIBS)
|
||||
endef
|
||||
|
||||
###############################################################################
|
||||
## Commands for running gcc to link an executable.
|
||||
###############################################################################
|
||||
|
||||
define transform-o-to-executable
|
||||
@mkdir -p $(dir $@)
|
||||
@echo "Executable: $(PRIVATE_MODULE) ($@)"
|
||||
$(Q)$(GXX) \
|
||||
-Wl,-Map -Wl,$(basename $@).map \
|
||||
$(PRIVATE_ALL_OBJECTS) \
|
||||
-Wl,--no-whole-archive \
|
||||
$(PRIVATE_ALL_STATIC_LIBRARIES) \
|
||||
$(PRIVATE_ALL_SHARED_LIBRARIES) \
|
||||
$(TARGET_GLOBAL_LDFLAGS) \
|
||||
$(PRIVATE_LDFLAGS) \
|
||||
-o $@ \
|
||||
$(PRIVATE_LDLIBS)
|
||||
endef
|
||||
|
||||
###############################################################################
|
||||
## Commands to generate resource list
|
||||
###############################################################################
|
||||
|
||||
# $(1) : ResListMaker full path
|
||||
# $(2) : source directory
|
||||
# $(3) : destination directory
|
||||
define transform-reslist
|
||||
@mkdir -p $(dir $@)
|
||||
@echo "ResList: $(PRIVATE_MODULE) ($@)"
|
||||
$(Q)$(1) $(2)/ResList.txt $(3)/ResList.h $(3)/ResList.c $(2)
|
||||
$(Q)date | cat > $@
|
||||
endef
|
||||
|
||||
# $(1) : source directory
|
||||
# $(2) : destination directory
|
||||
define generate-reslistmaker
|
||||
@mkdir -p $(dir $@)
|
||||
@echo "ResListMaker: $(PRIVATE_MODULE) ($@)"
|
||||
$(Q)$(GCC) -O2 -g0 -c -o $(2)/ResListMaker.o $(1)/ResListMaker.c
|
||||
$(Q)$(GCC) -o $@ $(2)/ResListMaker.o
|
||||
endef
|
||||
|
||||
###############################################################################
|
||||
## Commands for copying files.
|
||||
###############################################################################
|
||||
|
||||
# Copy a single file from one place to another, preserving permissions and
|
||||
# overwriting any existing file.
|
||||
define copy-file-to-target
|
||||
@mkdir -p $(dir $@)
|
||||
$(Q)cp -fp $< $@
|
||||
endef
|
||||
|
||||
# Define a rule to copy a file. For use via $(eval).
|
||||
# $(1): source file
|
||||
# $(2): destination file
|
||||
define copy-one-file
|
||||
$(2): $(1)
|
||||
@echo "Copy: $$@"
|
||||
$$(copy-file-to-target)
|
||||
endef
|
||||
|
||||
|
||||
|
||||
###############################################################################
|
||||
## Commands for importing module files.
|
||||
###############################################################################
|
||||
import-module = \
|
||||
$(eval include $(shell find $(PROJECT_MODULE)$1 -name Linux.mk))
|
||||
16
Build/coreLinux/executable.mk
Normal file
16
Build/coreLinux/executable.mk
Normal file
@ -0,0 +1,16 @@
|
||||
###############################################################################
|
||||
## @file executable.mk
|
||||
## @author Y.M. Morgan
|
||||
## @date 2011/05/14
|
||||
##
|
||||
## Build an executable.
|
||||
###############################################################################
|
||||
|
||||
LOCAL_MODULE_SUFFIX := $(TARGET_EXECUTABLE_SUFFIX)
|
||||
LOCAL_BUILDING_EXECUTABLE := 1
|
||||
|
||||
include $(RULES)
|
||||
|
||||
$(LOCAL_BUILT_MODULE): $(all_libraries) $(all_objects)
|
||||
$(transform-o-to-executable)
|
||||
|
||||
179
Build/coreLinux/main.mk
Normal file
179
Build/coreLinux/main.mk
Normal file
@ -0,0 +1,179 @@
|
||||
###############################################################################
|
||||
## @file main.mk
|
||||
## @author Y.M. Morgan
|
||||
## @date 2011/05/14
|
||||
##
|
||||
## Main Makefile.
|
||||
###############################################################################
|
||||
|
||||
# Make sure SHELL is correctly set
|
||||
SHELL := /bin/bash
|
||||
|
||||
# Turns off suffix rules built into make
|
||||
.SUFFIXES:
|
||||
|
||||
# Installation variables
|
||||
PACKAGE := fsanalyser
|
||||
DESTDIR :=
|
||||
PREFIX := /usr/local
|
||||
|
||||
# Tools
|
||||
GCC := gcc
|
||||
GXX := g++
|
||||
AR := ar
|
||||
LD := ld
|
||||
WINDRES := windres
|
||||
|
||||
# Overridable settings
|
||||
V := 0
|
||||
W := 0
|
||||
DEBUG := 0
|
||||
STATIC := 0
|
||||
|
||||
# Quiet command if V is not 1
|
||||
ifneq ("$(V)","1")
|
||||
Q := @
|
||||
endif
|
||||
|
||||
# Directories
|
||||
TOP_DIR := .
|
||||
#BUILD_SYSTEM := $(TOP_DIR)/Build/coreLinux
|
||||
BUILD_SYSTEM := $(PROJECT_NDK)/Build/coreLinux/
|
||||
|
||||
# This is the default target. It must be the first declared target.
|
||||
all:
|
||||
|
||||
# Global variables
|
||||
TARGET_PROJECT_INCLUDES :=
|
||||
TARGET_C_INCLUDES :=
|
||||
TARGET_GLOBAL_CFLAGS := -fno-exceptions -fstrict-aliasing
|
||||
TARGET_GLOBAL_CPPFLAGS :=
|
||||
TARGET_GLOBAL_RCFLAGS :=
|
||||
TARGET_GLOBAL_ARFLAGS := -rcs
|
||||
TARGET_GLOBAL_LDFLAGS := -Wl,--gc-sections -Wl,--warn-common -Wl,--warn-constructors
|
||||
ALL_MODULES :=
|
||||
|
||||
# To be able to load automatically .so libraries located in the same
|
||||
# folder than the application, we need to add $ORIGIN to DT_RPATH
|
||||
# '\' is to escape the '$' in the shell command
|
||||
# '$$' is to escape the '$' in the makefile
|
||||
TARGET_GLOBAL_LDFLAGS += -Wl,-rpath,\$$ORIGIN
|
||||
|
||||
###############################################################################
|
||||
# Version
|
||||
###############################################################################
|
||||
VERSION_MAJOR := 111
|
||||
VERSION_MINOR := 2222
|
||||
VERSION_REVISION := 3453
|
||||
VERSION := $(VERSION_MAJOR).$(VERSION_MINOR).$(VERSION_REVISION)
|
||||
|
||||
###############################################################################
|
||||
###############################################################################
|
||||
|
||||
# Setup macros definitions
|
||||
include $(BUILD_SYSTEM)/defs.mk
|
||||
|
||||
# Setup configuration
|
||||
include $(BUILD_SYSTEM)/config.mk
|
||||
|
||||
# Names of makefiles that can be included by "local.mk" Makefiles
|
||||
CLEAR_VARS := $(BUILD_SYSTEM)/clearvars.mk
|
||||
BUILD_STATIC_LIBRARY := $(BUILD_SYSTEM)/static.mk
|
||||
BUILD_SHARED_LIBRARY := $(BUILD_SYSTEM)/shared.mk
|
||||
BUILD_EXECUTABLE := $(BUILD_SYSTEM)/executable.mk
|
||||
RULES := $(BUILD_SYSTEM)/rules.mk
|
||||
|
||||
###############################################################################
|
||||
## Flags to activate warnings.
|
||||
###############################################################################
|
||||
|
||||
COMMON_FLAGS_WARNINGS :=
|
||||
GCC_FLAGS_WARNINGS :=
|
||||
GXX_FLAGS_WARNINGS :=
|
||||
|
||||
COMMON_FLAGS_WARNINGS += -Wall
|
||||
|
||||
# Add common flags to specific flags
|
||||
GCC_FLAGS_WARNINGS += $(COMMON_FLAGS_WARNINGS)
|
||||
GXX_FLAGS_WARNINGS += $(COMMON_FLAGS_WARNINGS)
|
||||
|
||||
###############################################################################
|
||||
###############################################################################
|
||||
|
||||
# Get the list of all makefiles available and include them
|
||||
makefiles += $(shell find $(TOP_DIR) -name Linux.mk)
|
||||
include $(makefiles)
|
||||
|
||||
TARGET_GLOBAL_CPPFLAGS := $(addprefix -I, $(LIB_EXTERN_C_INCLUDE))
|
||||
TARGET_GLOBAL_LDFLAGS := $(TARGET_GLOBAL_LDFLAGS) $(LIB_EXTERN_LDLIBS)
|
||||
###############################################################################
|
||||
# Main rules.
|
||||
###############################################################################
|
||||
|
||||
.PHONY: all
|
||||
all: $(foreach m,$(ALL_MODULES),$(m))
|
||||
|
||||
.PHONY: clean
|
||||
clean: $(foreach m,$(ALL_MODULES),clean-$(m))
|
||||
|
||||
.PHONY: distclean
|
||||
distclean: clean
|
||||
|
||||
.PHONY: test
|
||||
test:
|
||||
|
||||
.PHONY: install
|
||||
install: $(foreach m,$(ALL_MODULES),install-$(m))
|
||||
|
||||
###############################################################################
|
||||
# debian package generation.
|
||||
###############################################################################
|
||||
|
||||
.PHONY: deb
|
||||
deb:
|
||||
@chmod +x debian/rules
|
||||
$(Q)fakeroot debian/rules binary
|
||||
|
||||
.PHONY: deb-clean
|
||||
deb-clean:
|
||||
@chmod +x debian/rules
|
||||
$(Q)fakeroot debian/rules clean
|
||||
|
||||
###############################################################################
|
||||
# source/binary pakage generation.
|
||||
###############################################################################
|
||||
|
||||
# Generate archive with source files from git
|
||||
SRCZIP_NAME := $(PACKAGE)-src-$(VERSION)
|
||||
.PHONY: src-zip
|
||||
src-zip:
|
||||
@rm -f $(SRCZIP_NAME).tar
|
||||
@rm -f $(SRCZIP_NAME).tar.bz2
|
||||
$(Q)git archive --format=tar --prefix=$(SRCZIP_NAME)/ \
|
||||
-o $(SRCZIP_NAME).tar HEAD
|
||||
$(Q)bzip2 $(SRCZIP_NAME).tar
|
||||
|
||||
# Generate archive with binary files
|
||||
BINZIP_NAME := $(PACKAGE)-bin-$(VERSION)
|
||||
.PHONY: bin-zip
|
||||
bin-zip:
|
||||
@rm -f $(BINZIP_NAME).tar
|
||||
@rm -f $(BINZIP_NAME).tar.bz2
|
||||
$(Q)tar -cf $(BINZIP_NAME).tar -C $(TARGET_OUT) \
|
||||
--transform "s/\.\(\/.*\)/$(BINZIP_NAME)\\1/" .
|
||||
$(Q)bzip2 $(BINZIP_NAME).tar
|
||||
|
||||
###############################################################################
|
||||
# Display configuration.
|
||||
###############################################################################
|
||||
|
||||
$(info ----------------------------------------------------------------------)
|
||||
$(info + VERSION = $(VERSION))
|
||||
$(info + DEBUG = $(DEBUG))
|
||||
$(info + STATIC = $(STATIC))
|
||||
$(info + TARGET_OUT_INTERMEDIATES = $(TARGET_OUT_INTERMEDIATES))
|
||||
$(info + TARGET_OUT = $(TARGET_OUT))
|
||||
$(info + GCC_PATH = $(GCC_PATH))
|
||||
$(info + GCC_VERSION = $(GCC_VERSION))
|
||||
$(info ----------------------------------------------------------------------)
|
||||
|
||||
232
Build/coreLinux/rules.mk
Normal file
232
Build/coreLinux/rules.mk
Normal file
@ -0,0 +1,232 @@
|
||||
###############################################################################
|
||||
## @file rules.mk
|
||||
## @author Y.M. Morgan
|
||||
## @date 2011/05/14
|
||||
##
|
||||
## Generate rules for building an executable or library.
|
||||
###############################################################################
|
||||
|
||||
# Make sure LOCAL_MODULE is defined and not empty
|
||||
LOCAL_MODULE := $(strip $(LOCAL_MODULE))
|
||||
ifeq ("$(LOCAL_MODULE)","")
|
||||
$(error $(LOCAL_PATH): LOCAL_MODULE is not defined)
|
||||
endif
|
||||
|
||||
# Intermediates directory
|
||||
intermediates := $(TARGET_OUT_INTERMEDIATES)/$(LOCAL_MODULE)
|
||||
|
||||
# Full path to build module
|
||||
LOCAL_BUILT_MODULE := $(intermediates)/$(LOCAL_MODULE)$(LOCAL_MODULE_SUFFIX)
|
||||
|
||||
# Full path to final module
|
||||
LOCAL_FINAL_MODULE := $(TARGET_OUT)/$(LOCAL_MODULE)$(LOCAL_MODULE_SUFFIX)
|
||||
|
||||
# Assemble the list of targets to create PRIVATE_ variables for.
|
||||
LOCAL_INTERMEDIATE_TARGETS += $(LOCAL_BUILT_MODULE)
|
||||
|
||||
# Prepend some directories in include list
|
||||
LOCAL_C_INCLUDES := -I$(intermediates) -I$(TOP_DIR)/$(LOCAL_PATH) $(LOCAL_C_INCLUDES)
|
||||
|
||||
# Register the module
|
||||
ALL_MODULES += $(LOCAL_MODULE)
|
||||
|
||||
###############################################################################
|
||||
## List of sources, objects and libraries.
|
||||
###############################################################################
|
||||
|
||||
cpp_sources := $(filter %.cpp,$(LOCAL_SRC_FILES))
|
||||
cpp_objects := $(addprefix $(intermediates)/,$(cpp_sources:.cpp=.o))
|
||||
|
||||
cxx_sources := $(filter %.cxx,$(LOCAL_SRC_FILES))
|
||||
cxx_objects := $(addprefix $(intermediates)/,$(cxx_sources:.cxx=.o))
|
||||
|
||||
c_sources := $(filter %.c,$(LOCAL_SRC_FILES))
|
||||
c_objects := $(addprefix $(intermediates)/,$(c_sources:.c=.o))
|
||||
|
||||
# rc files are used only under Mingw32
|
||||
ifeq ("$(OS_MINGW32)","1")
|
||||
rc_sources := $(filter %.rc,$(LOCAL_SRC_FILES))
|
||||
rc_objects := $(addprefix $(intermediates)/,$(rc_sources:.rc=.rc.o))
|
||||
endif
|
||||
|
||||
all_objects := \
|
||||
$(cpp_objects) \
|
||||
$(cxx_objects) \
|
||||
$(c_objects) \
|
||||
$(rc_objects) \
|
||||
|
||||
# Under mingw32, use .dll.a to link against shared libraries instead of .so
|
||||
ifeq ("$(OS_MINGW32)","1")
|
||||
shared_suffix := $(TARGET_SHARED_LIB_SUFFIX)$(TARGET_STATIC_LIB_SUFFIX)
|
||||
else
|
||||
shared_suffix := $(TARGET_SHARED_LIB_SUFFIX)
|
||||
endif
|
||||
|
||||
built_shared_libraries := \
|
||||
$(foreach lib,$(LOCAL_SHARED_LIBRARIES), \
|
||||
$(TARGET_OUT_INTERMEDIATES)/$(lib)/$(lib)$(shared_suffix))
|
||||
|
||||
built_static_libraries := \
|
||||
$(foreach lib,$(LOCAL_STATIC_LIBRARIES), \
|
||||
$(TARGET_OUT_INTERMEDIATES)/$(lib)/$(lib)$(TARGET_STATIC_LIB_SUFFIX))
|
||||
|
||||
# all_libraries is used for the dependencies on LOCAL_BUILT_MODULE.
|
||||
all_libraries := \
|
||||
$(built_shared_libraries) \
|
||||
$(built_static_libraries) \
|
||||
|
||||
###############################################################################
|
||||
## Resource list management.
|
||||
###############################################################################
|
||||
|
||||
LOCAL_RESLIST := $(strip $(LOCAL_RESLIST))
|
||||
|
||||
ifneq ("$(LOCAL_RESLIST)","")
|
||||
|
||||
# This makes sure resource list is created before compilation (order prerequisite)
|
||||
$(all_objects): | $(intermediates)/ResList
|
||||
|
||||
# Additional dependencies
|
||||
$(intermediates)/ResList.h: $(intermediates)/ResList
|
||||
$(intermediates)/ResList.c: $(intermediates)/ResList
|
||||
$(intermediates)/ResList: $(TOP_DIR)/$(LOCAL_PATH)/$(LOCAL_XRC)
|
||||
|
||||
reslist := $(TOP_DIR)/$(LOCAL_PATH)/$(LOCAL_RESLIST)
|
||||
reslistsrc := $(shell dirname $(reslist))
|
||||
reslistdst := $(intermediates)
|
||||
reslistmaker := $(reslistdst)/ResListMaker/ResListMaker$(TARGET_EXE_SUFFIX)
|
||||
|
||||
# Generate resource list
|
||||
$(intermediates)/ResList: $(reslist) $(reslistmaker)
|
||||
$(call transform-reslist, $(reslistmaker), $(reslistsrc), $(reslistdst))
|
||||
|
||||
# Generate resource list maker
|
||||
$(reslistmaker): $(reslistsrc)/ResListMaker.c
|
||||
$(call generate-reslistmaker, $(reslistsrc), $(dir $(reslistmaker)))
|
||||
|
||||
endif
|
||||
|
||||
###############################################################################
|
||||
## Actual rules.
|
||||
###############################################################################
|
||||
|
||||
# Final copy (not for static libraries)
|
||||
$(LOCAL_FINAL_MODULE): $(LOCAL_BUILT_MODULE)
|
||||
ifeq ("$(LOCAL_BUILDING_STATIC_LIBRARY)","")
|
||||
@echo "Copy: $@"
|
||||
$(copy-file-to-target)
|
||||
endif
|
||||
|
||||
# cpp files
|
||||
ifneq ("$(strip $(cpp_objects))","")
|
||||
$(cpp_objects): $(intermediates)/%.o: $(LOCAL_PATH)/%.cpp
|
||||
$(transform-cpp-to-o)
|
||||
-include $(cpp_objects:%.o=%.d)
|
||||
endif
|
||||
|
||||
# cxx files
|
||||
ifneq ("$(strip $(cxx_objects))","")
|
||||
$(cxx_objects): $(intermediates)/%.o: $(LOCAL_PATH)/%.cxx
|
||||
$(transform-cpp-to-o)
|
||||
-include $(cxx_objects:%.o=%.d)
|
||||
endif
|
||||
|
||||
# c files
|
||||
ifneq ("$(strip $(c_objects))","")
|
||||
$(c_objects): $(intermediates)/%.o: $(LOCAL_PATH)/%.c
|
||||
$(transform-c-to-o)
|
||||
-include $(c_objects:%.o=%.d)
|
||||
endif
|
||||
|
||||
# rc files
|
||||
ifneq ("$(strip $(rc_objects))","")
|
||||
$(rc_objects): $(addprefix $(LOCAL_PATH)/,$(LOCAL_RC_DEPS))
|
||||
$(rc_objects): $(intermediates)/%.rc.o: $(TOP_DIR)/$(LOCAL_PATH)/%.rc
|
||||
$(transform-rc-to-o)
|
||||
endif
|
||||
|
||||
# copy files verbatim to target (flat copy in output directory)
|
||||
copy_files :=
|
||||
$(foreach f,$(LOCAL_COPY_FILES), \
|
||||
$(eval _src := $(TOP_DIR)/$(LOCAL_PATH)/$(f)) \
|
||||
$(eval _dst := $(TARGET_OUT)/$(notdir $(f))) \
|
||||
$(eval copy_files += $(_dst)) \
|
||||
$(eval $(call copy-one-file,$(_src),$(_dst))) \
|
||||
)
|
||||
$(LOCAL_BUILT_MODULE): $(copy_files)
|
||||
|
||||
# clean- targets
|
||||
cleantarget := clean-$(LOCAL_MODULE)
|
||||
$(cleantarget) : PRIVATE_MODULE := $(LOCAL_MODULE)
|
||||
$(cleantarget) : PRIVATE_CLEAN_FILES := \
|
||||
$(PRIVATE_CLEAN_FILES) \
|
||||
$(LOCAL_BUILT_MODULE) \
|
||||
$(LOCAL_FINAL_MODULE) \
|
||||
$(copy_files) \
|
||||
$(intermediates)
|
||||
$(cleantarget)::
|
||||
@echo "Clean: $(PRIVATE_MODULE)"
|
||||
$(Q)rm -rf $(PRIVATE_CLEAN_FILES)
|
||||
|
||||
# install- targets
|
||||
installtarget := install-$(LOCAL_MODULE)
|
||||
$(installtarget) : PRIVATE_MODULE := $(LOCAL_MODULE)
|
||||
$(installtarget) : PRIVATE_FINAL_MODULE := $(LOCAL_FINAL_MODULE)
|
||||
$(installtarget) : PRIVATE_COPY_FILES := $(copy_files)
|
||||
$(installtarget) ::
|
||||
@echo "Install: $(PRIVATE_MODULE)"
|
||||
# create directories
|
||||
$(Q)install -d $(DESTDIR)$(PREFIX)/bin
|
||||
$(Q)install -d $(DESTDIR)$(PREFIX)/lib/$(PACKAGE)
|
||||
# install executables and shared libraries in lib/<package> directory
|
||||
ifeq ("$(LOCAL_BUILDING_STATIC_LIBRARY)","")
|
||||
$(Q)install $(PRIVATE_FINAL_MODULE) $(DESTDIR)$(PREFIX)/lib/$(PACKAGE)
|
||||
endif
|
||||
# install files copied verbatim
|
||||
ifneq ("$(strip $(copy_files))","")
|
||||
$(Q)install $(PRIVATE_COPY_FILES) $(DESTDIR)$(PREFIX)/lib/$(PACKAGE)
|
||||
endif
|
||||
# create a link for executables in bin
|
||||
ifeq ("$(LOCAL_BUILDING_EXECUTABLE)","1")
|
||||
$(Q)ln -s ../lib/$(PACKAGE)/$(PRIVATE_MODULE) $(DESTDIR)$(PREFIX)/bin/$(PRIVATE_MODULE)
|
||||
endif
|
||||
|
||||
## Provide a short-hand for building this module.
|
||||
.PHONY: $(LOCAL_MODULE)
|
||||
$(LOCAL_MODULE): $(LOCAL_BUILT_MODULE) $(LOCAL_FINAL_MODULE)
|
||||
|
||||
###############################################################################
|
||||
## Precompiled headers.
|
||||
###############################################################################
|
||||
|
||||
LOCAL_PRECOMPILED_FILE := $(strip $(LOCAL_PRECOMPILED_FILE))
|
||||
ifneq ("$(LOCAL_PRECOMPILED_FILE)","")
|
||||
|
||||
gch_file := $(intermediates)/$(LOCAL_PRECOMPILED_FILE).gch
|
||||
|
||||
# All objects will depends on the precompiled file
|
||||
$(all_objects): $(gch_file)
|
||||
|
||||
# Generate the precompiled file
|
||||
$(gch_file): $(TOP_DIR)/$(LOCAL_PATH)/$(LOCAL_PRECOMPILED_FILE)
|
||||
$(transform-h-to-gch)
|
||||
-include $(gch_file:%.gch=%.d)
|
||||
endif
|
||||
|
||||
###############################################################################
|
||||
# Rule-specific variable definitions.
|
||||
###############################################################################
|
||||
|
||||
$(LOCAL_INTERMEDIATE_TARGETS): PRIVATE_PATH := $(LOCAL_PATH)
|
||||
$(LOCAL_INTERMEDIATE_TARGETS): PRIVATE_MODULE := $(LOCAL_MODULE)
|
||||
$(LOCAL_INTERMEDIATE_TARGETS): PRIVATE_CFLAGS := $(LOCAL_CFLAGS)
|
||||
$(LOCAL_INTERMEDIATE_TARGETS): PRIVATE_C_INCLUDES := $(LOCAL_C_INCLUDES)
|
||||
$(LOCAL_INTERMEDIATE_TARGETS): PRIVATE_CPPFLAGS := $(LOCAL_CPPFLAGS)
|
||||
$(LOCAL_INTERMEDIATE_TARGETS): PRIVATE_RCFLAGS := $(LOCAL_RCFLAGS)
|
||||
$(LOCAL_INTERMEDIATE_TARGETS): PRIVATE_ARFLAGS := $(LOCAL_ARFLAGS)
|
||||
$(LOCAL_INTERMEDIATE_TARGETS): PRIVATE_LDFLAGS := $(LOCAL_LDFLAGS)
|
||||
$(LOCAL_INTERMEDIATE_TARGETS): PRIVATE_LDLIBS := $(LOCAL_LDLIBS)
|
||||
$(LOCAL_INTERMEDIATE_TARGETS): PRIVATE_ALL_SHARED_LIBRARIES := $(built_shared_libraries)
|
||||
$(LOCAL_INTERMEDIATE_TARGETS): PRIVATE_ALL_STATIC_LIBRARIES := $(built_static_libraries)
|
||||
$(LOCAL_INTERMEDIATE_TARGETS): PRIVATE_ALL_OBJECTS := $(all_objects)
|
||||
|
||||
22
Build/coreLinux/shared.mk
Normal file
22
Build/coreLinux/shared.mk
Normal file
@ -0,0 +1,22 @@
|
||||
###############################################################################
|
||||
## @file shared.mk
|
||||
## @author Y.M. Morgan
|
||||
## @date 2011/05/14
|
||||
##
|
||||
## Build a shared library.
|
||||
###############################################################################
|
||||
|
||||
LOCAL_MODULE_SUFFIX := $(TARGET_SHARED_LIB_SUFFIX)
|
||||
LOCAL_BUILDING_SHARED_LIBRARY := 1
|
||||
|
||||
include $(RULES)
|
||||
|
||||
# Generate .dll.a file under mingw32
|
||||
ifeq ("$(OS_MINGW32)","1")
|
||||
$(LOCAL_BUILT_MODULE)$(TARGET_STATIC_LIB_SUFFIX): $(LOCAL_BUILT_MODULE)
|
||||
$(LOCAL_INTERMEDIATE_TARGETS): PRIVATE_LDFLAGS += \
|
||||
-Wl,--out-implib -Wl,$(LOCAL_BUILT_MODULE)$(TARGET_STATIC_LIB_SUFFIX)
|
||||
endif
|
||||
|
||||
$(LOCAL_BUILT_MODULE): $(all_objects) $(all_libraries)
|
||||
$(transform-o-to-shared-lib)
|
||||
19
Build/coreLinux/static.mk
Normal file
19
Build/coreLinux/static.mk
Normal file
@ -0,0 +1,19 @@
|
||||
###############################################################################
|
||||
## @file static.mk
|
||||
## @author Y.M. Morgan
|
||||
## @date 2011/05/14
|
||||
##
|
||||
## Build a static library.
|
||||
###############################################################################
|
||||
|
||||
LOCAL_MODULE_SUFFIX := $(TARGET_STATIC_LIB_SUFFIX)
|
||||
LOCAL_BUILDING_STATIC_LIBRARY := 1
|
||||
|
||||
include $(RULES)
|
||||
|
||||
#$(info plopppppp=$(LOCAL_BUILT_MODULE)= $(all_libraries))
|
||||
$(LOCAL_BUILT_MODULE): $(all_libraries) $(all_objects)
|
||||
$(transform-o-to-static-lib)
|
||||
|
||||
LIB_EXTERN_C_INCLUDE := $(LIB_EXTERN_C_INCLUDE) $(LOCAL_EXPORT_C_INCLUDES)
|
||||
LIB_EXTERN_LDLIBS := $(LIB_EXTERN_LDLIBS) $(LOCAL_EXPORT_LDLIBS)
|
||||
79
Build/ewol.mk
Normal file
79
Build/ewol.mk
Normal 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
|
||||
|
||||
184
Java/PROJECT_NAME.java
Normal file
184
Java/PROJECT_NAME.java
Normal file
@ -0,0 +1,184 @@
|
||||
|
||||
|
||||
|
||||
package com.__PROJECT_VENDOR__.__PROJECT_PACKAGE__;
|
||||
|
||||
import javax.microedition.khronos.egl.EGLConfig;
|
||||
import javax.microedition.khronos.opengles.GL10;
|
||||
|
||||
import android.app.Activity;
|
||||
import android.content.Context;
|
||||
import android.opengl.GLSurfaceView;
|
||||
import android.os.Bundle;
|
||||
import android.view.MotionEvent;
|
||||
// For No Title :
|
||||
import android.view.Window;
|
||||
|
||||
// For the full screen :
|
||||
import android.view.WindowManager;
|
||||
|
||||
import java.io.File;
|
||||
import android.content.Context;
|
||||
|
||||
// For the getting apk name :
|
||||
import android.content.pm.ActivityInfo;
|
||||
import android.content.pm.ApplicationInfo;
|
||||
import android.content.pm.PackageManager;
|
||||
import android.content.pm.PackageManager.NameNotFoundException;
|
||||
import android.content.res.AssetFileDescriptor;
|
||||
import android.content.res.AssetManager;
|
||||
|
||||
/**
|
||||
* @brief Class :
|
||||
*
|
||||
*/
|
||||
public class __PROJECT_NAME__ extends Activity {
|
||||
|
||||
private GLSurfaceView mGLView;
|
||||
|
||||
static {
|
||||
System.loadLibrary("__PROJECT_PACKAGE__");
|
||||
}
|
||||
|
||||
@Override protected void onCreate(Bundle savedInstanceState) {
|
||||
super.onCreate(savedInstanceState);
|
||||
// Remove the title of the current display :
|
||||
requestWindowFeature(Window.FEATURE_NO_TITLE);
|
||||
// set full screen Mode :
|
||||
getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
|
||||
//Force landscape
|
||||
//setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
|
||||
// create bsurface system
|
||||
mGLView = new EwolGLSurfaceView(this);
|
||||
setContentView(mGLView);
|
||||
}
|
||||
|
||||
@Override protected void onPause() {
|
||||
super.onPause();
|
||||
mGLView.onPause();
|
||||
}
|
||||
|
||||
@Override protected void onResume() {
|
||||
super.onResume();
|
||||
mGLView.onResume();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @brief Class :
|
||||
*
|
||||
*/
|
||||
class EwolGLSurfaceView extends GLSurfaceView {
|
||||
private static native void nativeApplicationInit();
|
||||
private static native void nativeApplicationUnInit();
|
||||
private static native void nativeEventInputMotion(int pointerID, float x, float y);
|
||||
private static native void nativeEventInputState(int pointerID, boolean isDown, float x, float y);
|
||||
private static native void nativeEventUnknow(int eventID);
|
||||
private static native void nativeParamSetArchiveDir(int mode, String myString);
|
||||
|
||||
public EwolGLSurfaceView(Context context) {
|
||||
// super must be first statement in constructor
|
||||
super(context);
|
||||
// Load the application directory
|
||||
nativeParamSetArchiveDir(1, context.getFilesDir().toString());
|
||||
nativeParamSetArchiveDir(2, context.getCacheDir().toString());
|
||||
// to enable extarnal storage: add in the manifest the restriction needed ...
|
||||
//nativeParamSetArchiveDir(3, context.getExternalCacheDir().toString());
|
||||
|
||||
// return apk file path (or null on error)
|
||||
String apkFilePath = null;
|
||||
ApplicationInfo appInfo = null;
|
||||
PackageManager packMgmr = context.getPackageManager();
|
||||
try {
|
||||
appInfo = packMgmr.getApplicationInfo("com.__PROJECT_VENDOR__.__PROJECT_PACKAGE__", 0);
|
||||
} catch (NameNotFoundException e) {
|
||||
e.printStackTrace();
|
||||
throw new RuntimeException("Unable to locate assets, aborting...");
|
||||
}
|
||||
apkFilePath = appInfo.sourceDir;
|
||||
nativeParamSetArchiveDir(0, apkFilePath);
|
||||
|
||||
// je n'ai pas compris ...
|
||||
mRenderer = new EwolRenderer();
|
||||
setRenderer(mRenderer);
|
||||
nativeApplicationInit();
|
||||
}
|
||||
|
||||
private boolean InputDown1 = false;
|
||||
private boolean InputDown2 = false;
|
||||
private boolean InputDown3 = false;
|
||||
|
||||
public boolean onTouchEvent(final MotionEvent event) {
|
||||
// Wrapper on input events :
|
||||
int tmpActionType = event.getAction();
|
||||
|
||||
if (tmpActionType == MotionEvent.ACTION_MOVE) {
|
||||
final int pointerCount = event.getPointerCount();
|
||||
for (int p = 0; p < pointerCount; p++) {
|
||||
nativeEventInputMotion(event.getPointerId(p), (float)event.getX(p), (float)event.getY(p));
|
||||
}
|
||||
} else if( tmpActionType == MotionEvent.ACTION_POINTER_1_DOWN
|
||||
|| tmpActionType == MotionEvent.ACTION_DOWN) {
|
||||
nativeEventInputState(0, true, (float)event.getX(0), (float)event.getY(0));
|
||||
InputDown1 = true;
|
||||
} else if(tmpActionType == MotionEvent.ACTION_POINTER_1_UP) {
|
||||
nativeEventInputState(0, false, (float)event.getX(0), (float)event.getY(0));
|
||||
InputDown1 = false;
|
||||
} else if (tmpActionType == MotionEvent.ACTION_POINTER_2_DOWN) {
|
||||
nativeEventInputState(1, true, (float)event.getX(1), (float)event.getY(1));
|
||||
InputDown2 = true;
|
||||
} else if (tmpActionType == MotionEvent.ACTION_POINTER_2_UP) {
|
||||
nativeEventInputState(1, false, (float)event.getX(1), (float)event.getY(1));
|
||||
InputDown2 = false;
|
||||
} else if (tmpActionType == MotionEvent.ACTION_POINTER_3_DOWN) {
|
||||
nativeEventInputState(2, true, (float)event.getX(2), (float)event.getY(2));
|
||||
InputDown3 = true;
|
||||
} else if (tmpActionType == MotionEvent.ACTION_POINTER_3_UP) {
|
||||
nativeEventInputState(2, false, (float)event.getX(2), (float)event.getY(2));
|
||||
InputDown3 = false;
|
||||
} else if(tmpActionType == MotionEvent.ACTION_UP){
|
||||
if (InputDown1) {
|
||||
nativeEventInputState(0, false, (float)event.getX(0), (float)event.getY(0));
|
||||
InputDown1 = false;
|
||||
} else if (InputDown2) {
|
||||
nativeEventInputState(1, false, (float)event.getX(1), (float)event.getY(1));
|
||||
InputDown2 = false;
|
||||
} else {
|
||||
nativeEventInputState(2, false, (float)event.getX(2), (float)event.getY(2));
|
||||
InputDown3 = false;
|
||||
}
|
||||
} else {
|
||||
nativeEventUnknow(tmpActionType);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
EwolRenderer mRenderer;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* @brief Class :
|
||||
*
|
||||
*/
|
||||
class EwolRenderer implements GLSurfaceView.Renderer {
|
||||
private static native void nativeInit();
|
||||
private static native void nativeResize(int w, int h);
|
||||
private static native void nativeRender();
|
||||
private static native void nativeDone();
|
||||
|
||||
public void onSurfaceCreated(GL10 gl, EGLConfig config) {
|
||||
nativeInit();
|
||||
}
|
||||
|
||||
public void onSurfaceChanged(GL10 gl, int w, int h) {
|
||||
nativeResize(w, h);
|
||||
}
|
||||
|
||||
public void onDrawFrame(GL10 gl) {
|
||||
nativeRender();
|
||||
}
|
||||
}
|
||||
|
||||
101
Java/ewolAndroidAbstraction.cpp
Normal file
101
Java/ewolAndroidAbstraction.cpp
Normal file
@ -0,0 +1,101 @@
|
||||
/**
|
||||
*******************************************************************************
|
||||
* @file ewolAndroidAbstraction.cpp
|
||||
* @brief User abstraction for Android (Sources)
|
||||
* @author Edouard DUPIN
|
||||
* @date 14/12/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 <stdint.h>
|
||||
|
||||
// declaration of the ewol android abstraction ...
|
||||
void EWOL_NativeInit(void);
|
||||
void EWOL_NativeResize(int w, int h );
|
||||
void EWOL_NativeDone(void);
|
||||
void EWOL_NativeEventInputMotion(int pointerID, float x, float y );
|
||||
void EWOL_NativeEventInputState(int pointerID, bool isUp, float x, float y );
|
||||
void EWOL_NativeEventUnknow(int ID);
|
||||
void EWOL_NativeParamSetArchiveDir(int mode, const char* str);
|
||||
void EWOL_NativeApplicationInit(void);
|
||||
void EWOL_NativeApplicationUnInit(void);
|
||||
void EWOL_NativeRender(void);
|
||||
|
||||
extern "C"
|
||||
{
|
||||
|
||||
/* Call to initialize the graphics state */
|
||||
void Java_com___PROJECT_VENDOR_____PROJECT_PACKAGE___EwolRenderer_nativeInit( JNIEnv* env )
|
||||
{
|
||||
EWOL_NativeInit();
|
||||
}
|
||||
|
||||
|
||||
void Java_com___PROJECT_VENDOR_____PROJECT_PACKAGE___EwolRenderer_nativeResize( JNIEnv* env, jobject thiz, jint w, jint h )
|
||||
{
|
||||
EWOL_NativeResize(w, h);
|
||||
}
|
||||
|
||||
void Java_com___PROJECT_VENDOR_____PROJECT_PACKAGE___EwolRenderer_nativeDone( JNIEnv* env )
|
||||
{
|
||||
EWOL_NativeDone();
|
||||
}
|
||||
|
||||
void Java_com___PROJECT_VENDOR_____PROJECT_PACKAGE___EwolGLSurfaceView_nativeEventInputMotion( JNIEnv* env, jobject thiz, jint pointerID, jfloat x, jfloat y )
|
||||
{
|
||||
EWOL_NativeEventInputMotion(pointerID, x, y);
|
||||
}
|
||||
|
||||
void Java_com___PROJECT_VENDOR_____PROJECT_PACKAGE___EwolGLSurfaceView_nativeEventInputState( JNIEnv* env, jobject thiz, jint pointerID, jboolean isUp, jfloat x, jfloat y )
|
||||
{
|
||||
EWOL_NativeEventInputState(pointerID, isUp, x, y);
|
||||
}
|
||||
|
||||
|
||||
void Java_com___PROJECT_VENDOR_____PROJECT_PACKAGE___EwolGLSurfaceView_nativeEventUnknow( JNIEnv* env, jobject thiz, jint ID)
|
||||
{
|
||||
EWOL_NativeEventUnknow(ID);
|
||||
}
|
||||
|
||||
void Java_com___PROJECT_VENDOR_____PROJECT_PACKAGE___EwolGLSurfaceView_nativeParamSetArchiveDir( JNIEnv* env, jobject thiz, jint mode, jstring myString)
|
||||
{
|
||||
const char* str = env->GetStringUTFChars(myString,0);
|
||||
EWOL_NativeParamSetArchiveDir(mode, str);
|
||||
//env->ReleaseStringUTFChars(str,myString,0);
|
||||
}
|
||||
|
||||
void Java_com___PROJECT_VENDOR_____PROJECT_PACKAGE___EwolGLSurfaceView_nativeApplicationInit( JNIEnv* env)
|
||||
{
|
||||
EWOL_NativeApplicationInit();
|
||||
}
|
||||
|
||||
void Java_com___PROJECT_VENDOR_____PROJECT_PACKAGE___EwolGLSurfaceView_nativeApplicationUnInit( JNIEnv* env)
|
||||
{
|
||||
EWOL_NativeApplicationUnInit();
|
||||
}
|
||||
|
||||
void Java_com___PROJECT_VENDOR_____PROJECT_PACKAGE___EwolRenderer_nativeRender( JNIEnv* env )
|
||||
{
|
||||
EWOL_NativeRender();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
373
LICENSE
373
LICENSE
@ -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.
|
||||
137
README.md
137
README.md
@ -1,128 +1,41 @@
|
||||
Ewol
|
||||
Edn
|
||||
====
|
||||
|
||||
`Ewol` (Edn Widget OpenGl Layer) is a FREE software.
|
||||
|
||||
Release (master)
|
||||
----------------
|
||||
|
||||
[](https://travis-ci.org/atria-soft/ewol)
|
||||
[](http://atria-soft.com/ci/atria-soft/ewol)
|
||||
[](http://atria-soft.com/ci/atria-soft/ewol)
|
||||
[](http://atria-soft.com/ci/atria-soft/ewol)
|
||||
|
||||
[](http://atria-soft.com/ci/atria-soft/ewol)
|
||||
[](http://atria-soft.com/ci/atria-soft/ewol)
|
||||
[](http://atria-soft.com/ci/atria-soft/ewol)
|
||||
|
||||
[](http://atria-soft.com/ci/atria-soft/ewol)
|
||||
[](http://atria-soft.com/ci/atria-soft/ewol)
|
||||
|
||||
Developement (dev)
|
||||
------------------
|
||||
|
||||
[](https://travis-ci.org/atria-soft/ewol)
|
||||
[](http://atria-soft.com/ci/atria-soft/ewol)
|
||||
[](http://atria-soft.com/ci/atria-soft/ewol)
|
||||
[](http://atria-soft.com/ci/atria-soft/ewol)
|
||||
|
||||
[](http://atria-soft.com/ci/atria-soft/ewol)
|
||||
[](http://atria-soft.com/ci/atria-soft/ewol)
|
||||
[](http://atria-soft.com/ci/atria-soft/ewol)
|
||||
|
||||
[](http://atria-soft.com/ci/atria-soft/ewol)
|
||||
[](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
|
||||
=========================
|
||||
|
||||
|
||||
|
||||
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
|
||||
|
||||
2
Sources/Android.mk
Normal file
2
Sources/Android.mk
Normal file
@ -0,0 +1,2 @@
|
||||
LOCAL_PATH := $(call my-dir)
|
||||
include $(call all-subdir-makefiles)
|
||||
32
Sources/libetk/Android.mk
Normal file
32
Sources/libetk/Android.mk
Normal file
@ -0,0 +1,32 @@
|
||||
LOCAL_PATH := $(call my-dir)
|
||||
|
||||
include $(CLEAR_VARS)
|
||||
|
||||
LOCAL_MODULE := etk
|
||||
LOCAL_STATIC_LIBRARIES := libzip
|
||||
|
||||
LOCAL_C_INCLUDES := $(LOCAL_PATH)
|
||||
|
||||
LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)
|
||||
|
||||
|
||||
LOCAL_CFLAGS := -D__PLATFORM__Android \
|
||||
-Wno-write-strings \
|
||||
-DDATA_IN_APK \
|
||||
-DETK_DEBUG_LEVEL=3
|
||||
|
||||
|
||||
|
||||
# load the common sources file of the platform
|
||||
include $(LOCAL_PATH)/file.mk
|
||||
|
||||
LOCAL_SRC_FILES := $(FILE_LIST)
|
||||
|
||||
#for freetype : https://github.com/cdave1/freetype2-android
|
||||
|
||||
# Ewol Test Software :
|
||||
LOCAL_LDLIBS := -lGLESv1_CM -ldl -llog -lz
|
||||
|
||||
include $(BUILD_STATIC_LIBRARY)
|
||||
|
||||
|
||||
31
Sources/libetk/Linux.mk
Normal file
31
Sources/libetk/Linux.mk
Normal file
@ -0,0 +1,31 @@
|
||||
LOCAL_PATH := $(call my-dir)
|
||||
|
||||
include $(CLEAR_VARS)
|
||||
|
||||
LOCAL_MODULE := etk
|
||||
LOCAL_STATIC_LIBRARIES := libzip
|
||||
|
||||
LOCAL_C_INCLUDES := -I$(LOCAL_PATH)
|
||||
|
||||
LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)
|
||||
LOCAL_EXPORT_LDLIBS :=
|
||||
|
||||
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\""
|
||||
|
||||
# load the common sources file of the platform
|
||||
include $(LOCAL_PATH)/file.mk
|
||||
|
||||
LOCAL_SRC_FILES := $(FILE_LIST)
|
||||
|
||||
#for freetype : https://github.com/cdave1/freetype2-android
|
||||
|
||||
# Ewol Test Software :
|
||||
LOCAL_LDLIBS :=
|
||||
|
||||
|
||||
include $(BUILD_STATIC_LIBRARY)
|
||||
75
Sources/libetk/etk/Debug.cpp
Normal file
75
Sources/libetk/etk/Debug.cpp
Normal file
@ -0,0 +1,75 @@
|
||||
/**
|
||||
*******************************************************************************
|
||||
* @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)
|
||||
{
|
||||
char tmpdata[50];
|
||||
#ifdef __PLATFORM__Android
|
||||
struct timeval now;
|
||||
gettimeofday(&now, NULL);
|
||||
sprintf(tmpdata, " %2dh %2dmin %2ds | ", (int32_t)(now.tv_sec/3600), (int32_t)(now.tv_sec/60)%60, (int32_t)(now.tv_sec%60));
|
||||
#else
|
||||
time_t rawtime;
|
||||
struct tm * timeinfo;
|
||||
time(&rawtime);
|
||||
timeinfo = localtime(&rawtime);
|
||||
sprintf(tmpdata, " %2dh %2dmin %2ds | ", timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec);
|
||||
#endif
|
||||
etk::cout << tmpdata ;
|
||||
}
|
||||
|
||||
97
Sources/libetk/etk/Debug.h
Normal file
97
Sources/libetk/etk/Debug.h
Normal 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/libetk/etk/DebugInternal.cpp
Normal file
25
Sources/libetk/etk/DebugInternal.cpp
Normal 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/libetk/etk/DebugInternal.h
Normal file
71
Sources/libetk/etk/DebugInternal.h
Normal 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
|
||||
|
||||
824
Sources/libetk/etk/File.cpp
Normal file
824
Sources/libetk/etk/File.cpp
Normal file
@ -0,0 +1,824 @@
|
||||
/**
|
||||
*******************************************************************************
|
||||
* @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/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 {
|
||||
TK_INFO("File existed ... in APK : \"" << tmpFilename << "\" ==> id=" << m_idZipFile);
|
||||
}
|
||||
#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 = baseFolderData + 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 = baseFolderData + 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;
|
||||
}
|
||||
etk::String myCompleateName = baseFolderData + GetCompleateName();
|
||||
m_PointerFile=fopen(myCompleateName.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;
|
||||
}
|
||||
etk::String myCompleateName = baseFolderData + GetCompleateName();
|
||||
m_PointerFile=fopen(myCompleateName.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/libetk/etk/File.h
Normal file
121
Sources/libetk/etk/File.h
Normal 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/libetk/etk/Memory.cpp
Normal file
51
Sources/libetk/etk/Memory.cpp
Normal 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
|
||||
|
||||
96
Sources/libetk/etk/Memory.h
Normal file
96
Sources/libetk/etk/Memory.h
Normal file
@ -0,0 +1,96 @@
|
||||
/**
|
||||
*******************************************************************************
|
||||
* @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 __ETK_TOOLS_MEMORY_H__
|
||||
#define __ETK_TOOLS_MEMORY_H__
|
||||
|
||||
#ifndef ETK_MEMORY_CHECKER
|
||||
#define ETK_MEMORY_CHECKER 0
|
||||
#endif
|
||||
|
||||
// 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/libetk/etk/RegExp.cpp
Normal file
484
Sources/libetk/etk/RegExp.cpp
Normal 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/libetk/etk/RegExp.h
Normal file
2120
Sources/libetk/etk/RegExp.h
Normal file
File diff suppressed because it is too large
Load Diff
72
Sources/libetk/etk/Singleton.h
Normal file
72
Sources/libetk/etk/Singleton.h
Normal file
@ -0,0 +1,72 @@
|
||||
/**
|
||||
*******************************************************************************
|
||||
* @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 T *getInstance()
|
||||
{
|
||||
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/libetk/etk/Stream.cpp
Normal file
31
Sources/libetk/etk/Stream.cpp
Normal 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/libetk/etk/Stream.h
Normal file
159
Sources/libetk/etk/Stream.h
Normal 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/libetk/etk/String.cpp
Normal file
724
Sources/libetk/etk/String.cpp
Normal 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/libetk/etk/String.h
Normal file
93
Sources/libetk/etk/String.h
Normal 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/libetk/etk/Types.h
Normal file
115
Sources/libetk/etk/Types.h
Normal 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
|
||||
|
||||
|
||||
323
Sources/libetk/etk/Vector.h
Normal file
323
Sources/libetk/etk/Vector.h
Normal file
@ -0,0 +1,323 @@
|
||||
/**
|
||||
*******************************************************************************
|
||||
* @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/Types.h>
|
||||
#include <etk/DebugInternal.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 etk
|
||||
{
|
||||
|
||||
template<class T, int32_t INC=0> class Vector
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* @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, 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;
|
||||
ETK_MALLOC_CAST(m_data, m_size, T, 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 ---
|
||||
*
|
||||
*/
|
||||
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, 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/libetk/etk/VectorType.h
Normal file
672
Sources/libetk/etk/VectorType.h
Normal 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
|
||||
|
||||
12
Sources/libetk/file.mk
Normal file
12
Sources/libetk/file.mk
Normal file
@ -0,0 +1,12 @@
|
||||
|
||||
|
||||
FILE_LIST = \
|
||||
etk/Debug.cpp \
|
||||
etk/DebugInternal.cpp \
|
||||
etk/Memory.cpp \
|
||||
etk/String.cpp \
|
||||
etk/Stream.cpp \
|
||||
etk/File.cpp \
|
||||
etk/RegExp.cpp
|
||||
|
||||
|
||||
33
Sources/libewol/Android.mk
Normal file
33
Sources/libewol/Android.mk
Normal file
@ -0,0 +1,33 @@
|
||||
LOCAL_PATH := $(call my-dir)
|
||||
|
||||
include $(CLEAR_VARS)
|
||||
|
||||
LOCAL_MODULE := ewol
|
||||
LOCAL_STATIC_LIBRARIES := libetk libtinyxml libzip libpng
|
||||
|
||||
LOCAL_C_INCLUDES := $(LOCAL_PATH)
|
||||
|
||||
LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)
|
||||
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 := ewol/base/guiAndroid.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)
|
||||
|
||||
|
||||
36
Sources/libewol/Linux.mk
Normal file
36
Sources/libewol/Linux.mk
Normal file
@ -0,0 +1,36 @@
|
||||
LOCAL_PATH := $(call my-dir)
|
||||
|
||||
include $(CLEAR_VARS)
|
||||
|
||||
LOCAL_MODULE := ewol
|
||||
LOCAL_STATIC_LIBRARIES := etk tinyxml libzip libpng
|
||||
|
||||
LOCAL_C_INCLUDES := -I$(LOCAL_PATH)
|
||||
|
||||
LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)
|
||||
LOCAL_EXPORT_LDLIBS := -lGL -lGLU -lz -lX11 -lXxf86vm `pkg-config --libs freetype2`
|
||||
|
||||
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\"" \
|
||||
-DEWOL_X11_MODE__XF86V \
|
||||
-DEWOL_USE_FREE_TYPE \
|
||||
`pkg-config --cflags freetype2`
|
||||
|
||||
# load the common sources file of the platform
|
||||
include $(LOCAL_PATH)/file.mk
|
||||
|
||||
LOCAL_SRC_FILES := \
|
||||
ewol/base/guiX11.cpp \
|
||||
$(FILE_LIST)
|
||||
|
||||
#for freetype : https://github.com/cdave1/freetype2-android
|
||||
|
||||
# Ewol Test Software :
|
||||
LOCAL_LDLIBS := -lGL -lGLU -lz -lX11 -lXxf86vm
|
||||
|
||||
|
||||
include $(BUILD_STATIC_LIBRARY)
|
||||
28
Sources/libewol/ewol/Debug.cpp
Normal file
28
Sources/libewol/ewol/Debug.cpp
Normal 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/libewol/ewol/Debug.h
Normal file
74
Sources/libewol/ewol/Debug.h
Normal 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
|
||||
|
||||
110
Sources/libewol/ewol/Font.h
Normal file
110
Sources/libewol/ewol/Font.h
Normal file
@ -0,0 +1,110 @@
|
||||
/**
|
||||
*******************************************************************************
|
||||
* @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,
|
||||
coord2D_ts & clipSize,
|
||||
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
|
||||
|
||||
526
Sources/libewol/ewol/FontBitmap.cpp
Normal file
526
Sources/libewol/ewol/FontBitmap.cpp
Normal file
@ -0,0 +1,526 @@
|
||||
/**
|
||||
*******************************************************************************
|
||||
* @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.
|
||||
*
|
||||
*******************************************************************************
|
||||
*/
|
||||
|
||||
#ifndef EWOL_USE_FREE_TYPE
|
||||
|
||||
#include <ewol/Font.h>
|
||||
#include <ewol/Texture.h>
|
||||
#include <etk/VectorType.h>
|
||||
#include <ewol/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)
|
||||
{
|
||||
EWOL_TODO("previous code does not work at all");
|
||||
|
||||
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, // Id of the desire font
|
||||
coord2D_ts & drawPosition, // position to start the writing (can be < 0) ==> no check
|
||||
coord2D_ts & clipSize, // clipping size
|
||||
const char * utf8String, // my UTF8 string
|
||||
uint32_t & fontTextureId, // return the fontID needed to display this string
|
||||
etk::VectorType<coord2D_ts> & coord, // return the coordonates
|
||||
etk::VectorType<texCoord_ts> & coordTex) // return the texture coordonates
|
||||
{
|
||||
// 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;
|
||||
// check the clipping
|
||||
if (clipSize.x>0 && posDrawX+sizeWidth > clipSize.x) {
|
||||
// TODO : Create a better clipping methode ...
|
||||
break;
|
||||
}
|
||||
// 0x01 == 0x20 == ' ';
|
||||
if (tmpChar != 0x01) {
|
||||
// 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);
|
||||
}
|
||||
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();
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
737
Sources/libewol/ewol/FontFreeType.cpp
Normal file
737
Sources/libewol/ewol/FontFreeType.cpp
Normal file
@ -0,0 +1,737 @@
|
||||
/**
|
||||
*******************************************************************************
|
||||
* @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.
|
||||
*
|
||||
*******************************************************************************
|
||||
*/
|
||||
#ifdef EWOL_USE_FREE_TYPE
|
||||
|
||||
#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 <ewol/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;
|
||||
m_FileBuffer = NULL;
|
||||
m_FileSize = 0;
|
||||
#if 0
|
||||
int32_t error = FT_New_Face( library, m_fileName.GetCompleateName().c_str(), 0, &m_fftFace );
|
||||
#else
|
||||
if (false == m_fileName.Exist()) {
|
||||
EWOL_ERROR("File Does not exist : " << m_fileName);
|
||||
return;
|
||||
}
|
||||
m_FileSize = m_fileName.Size();
|
||||
if (0==m_FileSize) {
|
||||
EWOL_ERROR("This file is empty : " << m_fileName);
|
||||
return;
|
||||
}
|
||||
if (false == m_fileName.fOpenRead()) {
|
||||
EWOL_ERROR("Can not open the file : " << m_fileName);
|
||||
return;
|
||||
}
|
||||
// allocate data
|
||||
m_FileBuffer = new FT_Byte[m_FileSize];
|
||||
if (NULL == m_FileBuffer) {
|
||||
EWOL_ERROR("Error Memory allocation size=" << m_FileSize);
|
||||
return;
|
||||
}
|
||||
// load data from the file :
|
||||
m_fileName.fRead(m_FileBuffer, 1, m_FileSize);
|
||||
// close the file:
|
||||
m_fileName.fClose();
|
||||
// load Face ...
|
||||
int32_t error = FT_New_Memory_Face( library, m_FileBuffer, m_FileSize, 0, &m_fftFace );
|
||||
#endif
|
||||
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)
|
||||
{
|
||||
// clean the tmp memory
|
||||
if (NULL != m_FileBuffer) {
|
||||
delete[] m_FileBuffer;
|
||||
m_FileBuffer = NULL;
|
||||
}
|
||||
}
|
||||
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_Byte * m_FileBuffer;
|
||||
int32_t m_FileSize;
|
||||
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,
|
||||
coord2D_ts & clipSize,
|
||||
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;
|
||||
// check the clipping
|
||||
if (clipSize.x>0 && posDrawX+sizeWidth > clipSize.x) {
|
||||
// TODO : Create a better clipping methode ...
|
||||
break;
|
||||
}
|
||||
// 0x01 == 0x20 == ' ';
|
||||
if (tmpChar != 0x01) {
|
||||
|
||||
// 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);
|
||||
}
|
||||
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();
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
63
Sources/libewol/ewol/OObject.cpp
Normal file
63
Sources/libewol/ewol/OObject.cpp
Normal 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 <ewol/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/libewol/ewol/OObject.h
Normal file
84
Sources/libewol/ewol/OObject.h
Normal 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/libewol/ewol/OObject/2DColored.cpp
Normal file
610
Sources/libewol/ewol/OObject/2DColored.cpp
Normal 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 <ewol/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/libewol/ewol/OObject/2DColored.h
Normal file
69
Sources/libewol/ewol/OObject/2DColored.h
Normal 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
|
||||
|
||||
106
Sources/libewol/ewol/OObject/2DText.cpp
Normal file
106
Sources/libewol/ewol/OObject/2DText.cpp
Normal file
@ -0,0 +1,106 @@
|
||||
/**
|
||||
*******************************************************************************
|
||||
* @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 <ewol/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] );
|
||||
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::OObject2DText::Text(etkFloat_t x, etkFloat_t y, const char* utf8String, int32_t clippingPositionX)
|
||||
{
|
||||
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;
|
||||
coord2D_ts clipSize;
|
||||
clipSize.x = clippingPositionX;
|
||||
clipSize.y = -1;
|
||||
ewol::DrawText(m_FontId, drawPosition, clipSize, 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/libewol/ewol/OObject/2DText.h
Normal file
53
Sources/libewol/ewol/OObject/2DText.h
Normal 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, int32_t clippingPositionX);
|
||||
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/libewol/ewol/OObject/2DTextured.cpp
Normal file
120
Sources/libewol/ewol/OObject/2DTextured.cpp
Normal 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 <ewol/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/libewol/ewol/OObject/2DTextured.h
Normal file
49
Sources/libewol/ewol/OObject/2DTextured.h
Normal 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/libewol/ewol/Texture.cpp
Normal file
477
Sources/libewol/ewol/Texture.cpp
Normal 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 <ewol/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/libewol/ewol/Texture.h
Normal file
50
Sources/libewol/ewol/Texture.h
Normal 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
|
||||
|
||||
285
Sources/libewol/ewol/Widget.cpp
Normal file
285
Sources/libewol/ewol/Widget.cpp
Normal file
@ -0,0 +1,285 @@
|
||||
/**
|
||||
*******************************************************************************
|
||||
* @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);
|
||||
}
|
||||
|
||||
int32_t ewol::Widget::GetWidgetId(void)
|
||||
{
|
||||
return ewol::widgetManager::Get(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;
|
||||
}
|
||||
if (true == GenEventInputExternal(m_inputEvent[iii].generateEventId, x, y)) {
|
||||
ended = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (false == ended) {
|
||||
return OnEventInput(IdInput, typeEvent, x, y);
|
||||
}
|
||||
return ended;
|
||||
}
|
||||
|
||||
bool ewol::Widget::GenEventInputExternal(const char * generateEventId, etkFloat_t x, etkFloat_t y)
|
||||
{
|
||||
bool ended = false;
|
||||
// For all external Event Requested :
|
||||
for( int32_t jjj=0; jjj<m_externEvent.Size(); jjj++) {
|
||||
// Check if it is the same ID :
|
||||
if (m_externEvent[jjj].generateEventId == generateEventId) {
|
||||
// get the widget Pointer:
|
||||
|
||||
ewol::Widget * tmpWidget = ewol::widgetManager::Get(m_externEvent[jjj].widgetCall);
|
||||
if (NULL == tmpWidget) {
|
||||
EWOL_ERROR("Try to call an NULL Widget, it might be removed ... id=" << m_externEvent[jjj].widgetCall);
|
||||
} else {
|
||||
ended = tmpWidget->OnEventAreaExternal(GetWidgetId(), generateEventId, m_externEvent[jjj].generateEventIdExtern, x, y);
|
||||
}
|
||||
if (true == ended) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
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.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)
|
||||
{
|
||||
EWOL_TODO("code not writed now...");
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool ewol::Widget::AddEventShortCut(char * descriptiveString, const char * generateEventId)
|
||||
{
|
||||
EWOL_TODO("code not writed now...");
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool ewol::Widget::ExternLinkOnEvent(const char * eventName, int32_t widgetId, const char * eventExternId)
|
||||
{
|
||||
if(NULL == eventName || 0 > widgetId) {
|
||||
EWOL_ERROR("Try to add extern event with wrong input ..");
|
||||
return false;
|
||||
}
|
||||
|
||||
eventExtern_ts tmpEvent;
|
||||
// search the ID ...
|
||||
for(int32_t iii=0; iii < m_ListEventAvaillable.Size(); iii++) {
|
||||
if (strcmp(m_ListEventAvaillable[iii], eventName) == 0) {
|
||||
tmpEvent.generateEventId = m_ListEventAvaillable[iii];
|
||||
tmpEvent.widgetCall = widgetId;
|
||||
tmpEvent.generateEventIdExtern = eventExternId;
|
||||
m_externEvent.PushBack(tmpEvent);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
EWOL_ERROR("Try to add extern event with Unknow EventID : \"" << eventName << "\"" );
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
void ewol::Widget::AddOObject(ewol::OObject* newObject, etk::String name, int32_t pos)
|
||||
{
|
||||
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);
|
||||
if (pos < 0 || pos >= m_listOObject.Size() ) {
|
||||
m_listOObject.PushBack(newObject);
|
||||
} else {
|
||||
m_listOObject.Insert(pos, 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;
|
||||
}
|
||||
|
||||
|
||||
//} // ???
|
||||
|
||||
|
||||
297
Sources/libewol/ewol/Widget.h
Normal file
297
Sources/libewol/ewol/Widget.h
Normal file
@ -0,0 +1,297 @@
|
||||
/**
|
||||
*******************************************************************************
|
||||
* @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__
|
||||
|
||||
|
||||
namespace ewol {
|
||||
class Widget;
|
||||
};
|
||||
|
||||
#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 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;
|
||||
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
|
||||
const char * generateEventIdExtern; //!< External generated event ID (to be unique it was pointer on the string name)
|
||||
} eventExtern_ts;
|
||||
};
|
||||
|
||||
class Widget {
|
||||
public:
|
||||
Widget(void);
|
||||
virtual ~Widget(void);
|
||||
int32_t GetWidgetId(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 ...
|
||||
//update the min Size ... and the expend parameters for the sizer
|
||||
virtual bool CalculateMinSize(void) {m_minSize.x = m_userMinSize.x; m_minSize.y = m_userMinSize.y; return true; };
|
||||
virtual void SetMinSize(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; };
|
||||
virtual bool CanExpentX(void) { return m_userExpendX; };
|
||||
virtual void SetExpendY(bool newExpend=false) { m_userExpendY = newExpend; };
|
||||
virtual 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
|
||||
etk::VectorType<eventExtern_ts> m_externEvent; //!< Generic list of event generation for output link
|
||||
etk::VectorType<const char*> m_ListEventAvaillable; //!< List of all event availlable for this widget
|
||||
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 GenEventInputExternal(const char * generateEventId, etkFloat_t x, etkFloat_t y);
|
||||
bool GenEventShortCut(bool shift, bool control, bool alt, bool pomme, char UTF8_data[UTF8_MAX_SIZE]);
|
||||
protected:
|
||||
void AddEventId(const char * generateEventId) {
|
||||
if (NULL != generateEventId) {
|
||||
m_ListEventAvaillable.PushBack(generateEventId);
|
||||
}
|
||||
}
|
||||
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, const char * eventExternId = NULL);
|
||||
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, const char * eventExternId, 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 = "", int32_t pos=-1);
|
||||
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
|
||||
210
Sources/libewol/ewol/WidgetManager.cpp
Normal file
210
Sources/libewol/ewol/WidgetManager.cpp
Normal file
@ -0,0 +1,210 @@
|
||||
/**
|
||||
*******************************************************************************
|
||||
* @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"
|
||||
|
||||
extern "C" {
|
||||
typedef struct {
|
||||
int32_t widgetId;
|
||||
ewol::Widget* widgetPointer;
|
||||
} widgetList_ts;
|
||||
};
|
||||
|
||||
// internal element of the widget manager :
|
||||
static etk::VectorType<widgetList_ts> 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].widgetPointer!=NULL) {
|
||||
EWOL_WARNING("Un-Removed widget ... id=" << iii);
|
||||
FocusRemoveIfRemove(m_widgetList[iii].widgetPointer);
|
||||
delete(m_widgetList[iii].widgetPointer);
|
||||
m_widgetList[iii].widgetPointer=NULL;
|
||||
}
|
||||
}
|
||||
m_widgetList.Clear();
|
||||
}
|
||||
|
||||
void ewol::widgetManager::Add(ewol::Widget * newWidget)
|
||||
{
|
||||
static int32_t UniqueWidgetId = 0;
|
||||
// Check existance
|
||||
int32_t tmpID = ewol::widgetManager::Get(newWidget);
|
||||
if (0 > tmpID) {
|
||||
widgetList_ts tmpElement;
|
||||
tmpElement.widgetId = UniqueWidgetId++;
|
||||
tmpElement.widgetPointer = newWidget;
|
||||
m_widgetList.PushBack(tmpElement);
|
||||
} else {
|
||||
EWOL_WARNING("Widget Already added to the widget manager, id=" << tmpID);
|
||||
}
|
||||
}
|
||||
|
||||
void ewol::widgetManager::Rm(ewol::Widget * newWidget)
|
||||
{
|
||||
if (NULL == newWidget) {
|
||||
EWOL_ERROR("Try to remove (NULL) Widget");
|
||||
return;
|
||||
}
|
||||
for (int32_t iii=0; iii<m_widgetList.Size(); iii++) {
|
||||
if (m_widgetList[iii].widgetPointer == newWidget) {
|
||||
FocusRemoveIfRemove(newWidget);
|
||||
// Remove Element
|
||||
m_widgetList.Erase(iii);
|
||||
return;
|
||||
}
|
||||
}
|
||||
EWOL_ERROR("Widget already removed ...");
|
||||
}
|
||||
|
||||
int32_t ewol::widgetManager::Get(ewol::Widget * newWidget)
|
||||
{
|
||||
if (NULL == newWidget) {
|
||||
return -1;
|
||||
}
|
||||
for(int32_t iii=0; iii<m_widgetList.Size(); iii++) {
|
||||
if (m_widgetList[iii].widgetPointer == newWidget) {
|
||||
return m_widgetList[iii].widgetId;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
ewol::Widget * ewol::widgetManager::Get(int32_t widgetId)
|
||||
{
|
||||
if (0 > widgetId) {
|
||||
return NULL;
|
||||
}
|
||||
for(int32_t iii=0; iii<m_widgetList.Size(); iii++) {
|
||||
if (m_widgetList[iii].widgetId == widgetId) {
|
||||
return m_widgetList[iii].widgetPointer;
|
||||
}
|
||||
}
|
||||
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::Get(newWidget));
|
||||
return;
|
||||
}
|
||||
if (newWidget == m_focusWidgetCurrent) {
|
||||
// nothing to do ...
|
||||
return;
|
||||
}
|
||||
if (NULL != m_focusWidgetCurrent) {
|
||||
EWOL_DEBUG("Rm Focus on WidgetID=" << ewol::widgetManager::Get(m_focusWidgetCurrent));
|
||||
m_focusWidgetCurrent->RmFocus();
|
||||
}
|
||||
m_focusWidgetCurrent = newWidget;
|
||||
if (NULL != m_focusWidgetCurrent) {
|
||||
EWOL_DEBUG("Set Focus on WidgetID=" << ewol::widgetManager::Get(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::Get(newWidget));
|
||||
return;
|
||||
}
|
||||
if (m_focusWidgetDefault == m_focusWidgetCurrent) {
|
||||
if (NULL != m_focusWidgetCurrent) {
|
||||
EWOL_DEBUG("Rm Focus on WidgetID=" << ewol::widgetManager::Get(m_focusWidgetCurrent));
|
||||
m_focusWidgetCurrent->RmFocus();
|
||||
}
|
||||
m_focusWidgetCurrent = newWidget;
|
||||
if (NULL != m_focusWidgetCurrent) {
|
||||
EWOL_DEBUG("Set Focus on WidgetID=" << ewol::widgetManager::Get(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::Get(m_focusWidgetCurrent));
|
||||
m_focusWidgetCurrent->RmFocus();
|
||||
}
|
||||
m_focusWidgetCurrent = m_focusWidgetDefault;
|
||||
if (NULL != m_focusWidgetCurrent) {
|
||||
EWOL_DEBUG("Set Focus on WidgetID=" << ewol::widgetManager::Get(m_focusWidgetCurrent));
|
||||
m_focusWidgetCurrent->SetFocus();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
ewol::Widget * ewol::widgetManager::FocusGet(void)
|
||||
{
|
||||
return m_focusWidgetCurrent;
|
||||
}
|
||||
|
||||
void ewol::widgetManager::FocusRemoveIfRemove(ewol::Widget * newWidget)
|
||||
{
|
||||
if (m_focusWidgetCurrent == newWidget) {
|
||||
EWOL_WARNING("Release Focus when remove widget");
|
||||
FocusRelease();
|
||||
}
|
||||
if (m_focusWidgetDefault == newWidget) {
|
||||
EWOL_WARNING("Release default Focus when remove widget");
|
||||
FocusSetDefault(NULL);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
52
Sources/libewol/ewol/WidgetManager.h
Normal file
52
Sources/libewol/ewol/WidgetManager.h
Normal 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);
|
||||
int32_t Get( 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);
|
||||
void FocusRemoveIfRemove(ewol::Widget * newWidget);
|
||||
};
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
293
Sources/libewol/ewol/Windows.cpp
Normal file
293
Sources/libewol/ewol/Windows.cpp
Normal file
@ -0,0 +1,293 @@
|
||||
/**
|
||||
*******************************************************************************
|
||||
* @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 <ewol/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";
|
||||
const char * ewolEventWindowsHideKeyboard = "ewol Windows hideKeyboard";
|
||||
|
||||
|
||||
ewol::Windows::Windows(void)
|
||||
{
|
||||
AddEventId(ewolEventWindowsClose);
|
||||
AddEventId(ewolEventWindowsMinimize);
|
||||
AddEventId(ewolEventWindowsExpend);
|
||||
SetCanHaveFocus(true);
|
||||
m_subWidget = NULL;
|
||||
m_popUpWidget = NULL;
|
||||
m_keyBoardwidget = NULL;
|
||||
// enable specific drawing system ...
|
||||
SpecificDrawEnable();
|
||||
SetDecorationDisable();
|
||||
//KeyboardShow(KEYBOARD_MODE_CODE);
|
||||
}
|
||||
|
||||
ewol::Windows::~Windows(void)
|
||||
{
|
||||
if (NULL != m_subWidget) {
|
||||
delete(m_subWidget);
|
||||
m_subWidget=NULL;
|
||||
}
|
||||
if (NULL != m_popUpWidget) {
|
||||
delete(m_popUpWidget);
|
||||
m_popUpWidget=NULL;
|
||||
}
|
||||
if (NULL != m_keyBoardwidget) {
|
||||
delete(m_keyBoardwidget);
|
||||
m_keyBoardwidget=NULL;
|
||||
}
|
||||
}
|
||||
|
||||
bool ewol::Windows::CalculateSize(etkFloat_t availlableX, etkFloat_t availlableY)
|
||||
{
|
||||
m_size.x = availlableX;
|
||||
m_size.y = availlableY;
|
||||
int32_t keyboardHigh = 0;
|
||||
if (NULL != m_keyBoardwidget && false == m_keyBoardwidget->IsHide() ) {
|
||||
m_keyBoardwidget->CalculateMinSize();
|
||||
coord tmpSize = m_keyBoardwidget->GetMinSize();
|
||||
keyboardHigh = (int32_t)tmpSize.y;
|
||||
m_keyBoardwidget->SetOrigin(0, m_size.y - keyboardHigh);
|
||||
m_keyBoardwidget->CalculateSize(m_size.x, keyboardHigh);
|
||||
}
|
||||
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 - keyboardHigh);
|
||||
}
|
||||
if (NULL != m_popUpWidget) {
|
||||
m_popUpWidget->CalculateMinSize();
|
||||
m_popUpWidget->CalculateSize(m_size.x, m_size.y - keyboardHigh);
|
||||
}
|
||||
// regenerate all the display ...
|
||||
OnRegenerateDisplay();
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool ewol::Windows::OnEventInput(int32_t IdInput, eventInputType_te typeEvent, etkFloat_t x, etkFloat_t y)
|
||||
{
|
||||
if (NULL != m_keyBoardwidget && false == m_keyBoardwidget->IsHide() ) {
|
||||
coord tmpSize = m_keyBoardwidget->GetMinSize();
|
||||
if (y > m_size.y - tmpSize.y) {
|
||||
m_keyBoardwidget->GenEventInput(IdInput, typeEvent, x, y);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
// event go directly on the pop-up
|
||||
if (NULL != m_popUpWidget) {
|
||||
m_popUpWidget->GenEventInput(IdInput, typeEvent, x, y);
|
||||
// otherwise in the normal windows
|
||||
} else 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();
|
||||
}
|
||||
if (NULL != m_popUpWidget) {
|
||||
m_popUpWidget->OnRegenerateDisplay();
|
||||
}
|
||||
if (NULL != m_keyBoardwidget && false == m_keyBoardwidget->IsHide() ) {
|
||||
m_keyBoardwidget->OnRegenerateDisplay();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
bool ewol::Windows::OnDraw(void)
|
||||
{
|
||||
// first display the windows on the display
|
||||
if (NULL != m_subWidget) {
|
||||
m_subWidget->GenDraw();
|
||||
//EWOL_DEBUG("Draw Windows");
|
||||
}
|
||||
// second display the pop-up
|
||||
if (NULL != m_popUpWidget) {
|
||||
m_popUpWidget->GenDraw();
|
||||
//EWOL_DEBUG("Draw Pop-up");
|
||||
}
|
||||
if (NULL != m_keyBoardwidget && false == m_keyBoardwidget->IsHide() ) {
|
||||
m_keyBoardwidget->GenDraw();
|
||||
//EWOL_DEBUG("Draw Pop-up");
|
||||
}
|
||||
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);
|
||||
}
|
||||
|
||||
|
||||
void ewol::Windows::PopUpWidgetPush(ewol::Widget * widget)
|
||||
{
|
||||
if (NULL != m_popUpWidget) {
|
||||
EWOL_INFO("Remove current pop-up Widget...");
|
||||
delete(m_popUpWidget);
|
||||
m_popUpWidget = NULL;
|
||||
}
|
||||
m_popUpWidget = widget;
|
||||
// Regenerate the size calculation :
|
||||
CalculateSize(m_size.x, m_size.y);
|
||||
}
|
||||
|
||||
|
||||
void ewol::Windows::PopUpWidgetPop(void)
|
||||
{
|
||||
if (NULL != m_popUpWidget) {
|
||||
EWOL_INFO("Remove current pop-up Widget...");
|
||||
delete(m_popUpWidget);
|
||||
m_popUpWidget = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
bool ewol::Windows::OnEventAreaExternal(int32_t widgetID, const char * generateEventId, const char * eventExternId, etkFloat_t x, etkFloat_t y)
|
||||
{
|
||||
EWOL_DEBUG("kjhlkjhlkjhlkjhlkhlkjhlkjhlkjhlkjhlkjhlkjh");
|
||||
if(ewolEventWindowsHideKeyboard == generateEventId) {
|
||||
EWOL_INFO("Request Hide keyboard");
|
||||
KeyboardHide();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void ewol::Windows::KeyboardShow(ewol::keyboardMode_te mode)
|
||||
{
|
||||
if (NULL == m_keyBoardwidget) {
|
||||
// Create the keyboard ...
|
||||
m_keyBoardwidget = new ewol::Keyboard();
|
||||
if (NULL == m_keyBoardwidget) {
|
||||
EWOL_ERROR("Fail to initialize memory");
|
||||
} else {
|
||||
m_keyBoardwidget->ExternLinkOnEvent("ewol event Keyboard request hide", GetWidgetId(), ewolEventWindowsHideKeyboard );
|
||||
m_keyBoardwidget->SetParrent(this);
|
||||
}
|
||||
}
|
||||
if (NULL != m_keyBoardwidget) {
|
||||
m_keyBoardwidget->Show();
|
||||
}
|
||||
CalculateSize(m_size.x, m_size.y);
|
||||
OnRegenerateDisplay();
|
||||
}
|
||||
|
||||
|
||||
void ewol::Windows::KeyboardHide(void)
|
||||
{
|
||||
EWOL_INFO("Request Hide keyboard");
|
||||
if (NULL != m_keyBoardwidget) {
|
||||
m_keyBoardwidget->Hide();
|
||||
}
|
||||
CalculateSize(m_size.x, m_size.y);
|
||||
OnRegenerateDisplay();
|
||||
}
|
||||
93
Sources/libewol/ewol/Windows.h
Normal file
93
Sources/libewol/ewol/Windows.h
Normal file
@ -0,0 +1,93 @@
|
||||
/**
|
||||
*******************************************************************************
|
||||
* @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>
|
||||
#include <ewol/widgetMeta/Keyboard.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);
|
||||
virtual bool OnEventAreaExternal(int32_t widgetID, const char * generateEventId, const char * eventExternId, 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;
|
||||
ewol::Widget* m_popUpWidget;
|
||||
ewol::Keyboard* m_keyBoardwidget;
|
||||
public:
|
||||
void SetSubWidget(ewol::Widget * widget);
|
||||
void PopUpWidgetPush(ewol::Widget * widget);
|
||||
void PopUpWidgetPop(void);
|
||||
protected:
|
||||
virtual bool OnDraw(void);
|
||||
public:
|
||||
virtual void OnRegenerateDisplay(void);
|
||||
public:
|
||||
void KeyboardShow(ewol::keyboardMode_te mode);
|
||||
void KeyboardHide(void);
|
||||
};
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
58
Sources/libewol/ewol/base/gui.h
Normal file
58
Sources/libewol/ewol/base/gui.h
Normal file
@ -0,0 +1,58 @@
|
||||
/**
|
||||
*******************************************************************************
|
||||
* @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 <etk/String.h>
|
||||
#include <ewol/Windows.h>
|
||||
#include <ewol/ewolInterne.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);
|
||||
bool IsPressedInput(int32_t inputID);
|
||||
void KeyboardShow(ewol::keyboardMode_te mode);
|
||||
void KeyboardHide(void);
|
||||
void ForceRedrawAll(void);
|
||||
void SendKeyboardEvent(bool isDown, etk::String &keyInput);
|
||||
};
|
||||
|
||||
//!< 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
|
||||
611
Sources/libewol/ewol/base/guiAndroid.cpp
Normal file
611
Sources/libewol/ewol/base/guiAndroid.cpp
Normal file
@ -0,0 +1,611 @@
|
||||
/**
|
||||
*******************************************************************************
|
||||
* @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 <ewol/base/gui.h>
|
||||
#include <ewol/ewol.h>
|
||||
|
||||
#include <ewol/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 int64_t GetCurrentTime(void)
|
||||
{
|
||||
struct timeval now;
|
||||
gettimeofday(&now, NULL);
|
||||
//EWOL_VERBOSE("current time : " << now.tv_sec << "s " << now.tv_usec << "us");
|
||||
return (int64_t)((int64_t)now.tv_sec*(int64_t)1000 + (int64_t)now.tv_usec/(int64_t)1000);
|
||||
}
|
||||
|
||||
|
||||
void Draw(void);
|
||||
#define OFFSET_MOVE_CLICKED (20)
|
||||
#define OFFSET_MOVE_CLICKED_DOUBLE (40)
|
||||
#undef SEPARATED_CLICK_TIME
|
||||
#define SEPARATED_CLICK_TIME (300)
|
||||
|
||||
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 )
|
||||
{
|
||||
//EWOL_INFO("Event : Input ID=" << pointerID << " [" << isUp << "] x=" << x << " y=" << 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 = GetCurrentTime(); // return the tic in 10ms
|
||||
//EWOL_DEBUG("time is : " << (int)currentTime << " "<< (int)(currentTime/100) <<"s " << (int)((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) {
|
||||
guiAbstraction::Init(0, NULL);
|
||||
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();
|
||||
// basic abstraction un-init
|
||||
guiAbstraction::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 =GetCurrentTime() + 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 ... ");
|
||||
}
|
||||
}
|
||||
|
||||
bool guiAbstraction::IsPressedInput(int32_t inputID)
|
||||
{
|
||||
//if (true == guiAbstractionIsInit) {
|
||||
// return myX11Access->IsPressedInput(inputID);
|
||||
//} else {
|
||||
// EWOL_CRITICAL("X11 ==> not init ... ");
|
||||
return false;
|
||||
//}
|
||||
}
|
||||
|
||||
void guiAbstraction::KeyboardShow(ewol::keyboardMode_te mode)
|
||||
{
|
||||
if (NULL != m_uniqueWindows) {
|
||||
m_uniqueWindows->KeyboardShow(mode);
|
||||
}
|
||||
}
|
||||
|
||||
void guiAbstraction::KeyboardHide(void)
|
||||
{
|
||||
if (NULL != m_uniqueWindows) {
|
||||
m_uniqueWindows->KeyboardHide();
|
||||
}
|
||||
}
|
||||
|
||||
void guiAbstraction::ForceRedrawAll(void)
|
||||
{
|
||||
if (NULL != m_uniqueWindows) {
|
||||
m_uniqueWindows->CalculateSize((etkFloat_t)m_width, (etkFloat_t)m_height);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void guiAbstraction::SendKeyboardEvent(bool isDown, etk::String &keyInput)
|
||||
{
|
||||
// Get the current Focused Widget :
|
||||
ewol::Widget * tmpWidget = ewol::widgetManager::FocusGet();
|
||||
if (NULL != tmpWidget) {
|
||||
if(true == isDown) {
|
||||
EWOL_DEBUG("X11 PRESSED : \"" << keyInput << "\" size=" << keyInput.Size());
|
||||
tmpWidget->OnEventKb(ewol::EVENT_KB_TYPE_DOWN, keyInput.c_str());
|
||||
} else {
|
||||
EWOL_DEBUG("X11 Release : \"" << keyInput << "\" size=" << keyInput.Size());
|
||||
tmpWidget->OnEventKb(ewol::EVENT_KB_TYPE_UP, keyInput.c_str());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 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/libewol/ewol/base/guiDoubleBuffer.cpp
Normal file
46
Sources/libewol/ewol/base/guiDoubleBuffer.cpp
Normal 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/libewol/ewol/base/guiIPhone.cpp
Normal file
46
Sources/libewol/ewol/base/guiIPhone.cpp
Normal 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");
|
||||
}
|
||||
916
Sources/libewol/ewol/base/guiX11.cpp
Normal file
916
Sources/libewol/ewol/base/guiX11.cpp
Normal file
@ -0,0 +1,916 @@
|
||||
/**
|
||||
*******************************************************************************
|
||||
* @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 <ewol/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>
|
||||
|
||||
|
||||
static int64_t GetCurrentTime(void)
|
||||
{
|
||||
return times(NULL);
|
||||
}
|
||||
|
||||
#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_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:
|
||||
{
|
||||
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:
|
||||
{
|
||||
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 = GetCurrentTime(); // 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:
|
||||
//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:
|
||||
{
|
||||
// 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:
|
||||
//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:
|
||||
EWOL_VERBOSE("X11 event : " << event.type << " = \"FocusIn\"");
|
||||
m_uniqueWindows->SetFocus();
|
||||
break;
|
||||
case FocusOut:
|
||||
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';
|
||||
etk::String tmpData = buf;
|
||||
if(event.type == KeyPress) {
|
||||
SendKeyboardEvent(true, tmpData);
|
||||
} else {
|
||||
SendKeyboardEvent(true, tmpData);
|
||||
}
|
||||
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 KeyboardShow(ewol::keyboardMode_te mode)
|
||||
{
|
||||
if (NULL != m_uniqueWindows) {
|
||||
m_uniqueWindows->KeyboardShow(mode);
|
||||
}
|
||||
}
|
||||
void KeyboardHide(void)
|
||||
{
|
||||
if (NULL != m_uniqueWindows) {
|
||||
m_uniqueWindows->KeyboardHide();
|
||||
}
|
||||
ForceRedrawAll();
|
||||
}
|
||||
|
||||
void ForceRedrawAll(void)
|
||||
{
|
||||
if (NULL != m_uniqueWindows) {
|
||||
m_uniqueWindows->CalculateSize((etkFloat_t)m_width, (etkFloat_t)m_height);
|
||||
}
|
||||
};
|
||||
|
||||
private:
|
||||
/*
|
||||
int32_t m_startX;
|
||||
int32_t m_startY;
|
||||
int32_t m_screenOffsetX;
|
||||
int32_t m_screenOffsetY;
|
||||
*/
|
||||
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 ... ");
|
||||
}
|
||||
}
|
||||
|
||||
bool guiAbstraction::IsPressedInput(int32_t inputID)
|
||||
{
|
||||
if (true == guiAbstractionIsInit) {
|
||||
return myX11Access->IsPressedInput(inputID);
|
||||
} else {
|
||||
EWOL_CRITICAL("X11 ==> not init ... ");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
void guiAbstraction::KeyboardShow(ewol::keyboardMode_te mode)
|
||||
{
|
||||
if (true == guiAbstractionIsInit) {
|
||||
myX11Access->KeyboardShow(mode);
|
||||
} else {
|
||||
EWOL_CRITICAL("X11 ==> not init ... ");
|
||||
}
|
||||
}
|
||||
|
||||
void guiAbstraction::KeyboardHide(void)
|
||||
{
|
||||
if (true == guiAbstractionIsInit) {
|
||||
myX11Access->KeyboardHide();
|
||||
} else {
|
||||
EWOL_CRITICAL("X11 ==> not init ... ");
|
||||
}
|
||||
}
|
||||
|
||||
void guiAbstraction::ForceRedrawAll(void)
|
||||
{
|
||||
if (true == guiAbstractionIsInit) {
|
||||
myX11Access->ForceRedrawAll();
|
||||
} else {
|
||||
EWOL_CRITICAL("X11 ==> not init ... ");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void guiAbstraction::SendKeyboardEvent(bool isDown, etk::String &keyInput)
|
||||
{
|
||||
// Get the current Focused Widget :
|
||||
ewol::Widget * tmpWidget = ewol::widgetManager::FocusGet();
|
||||
if (NULL != tmpWidget) {
|
||||
if(true == isDown) {
|
||||
EWOL_DEBUG("X11 PRESSED : \"" << keyInput << "\" size=" << keyInput.Size());
|
||||
tmpWidget->OnEventKb(ewol::EVENT_KB_TYPE_DOWN, keyInput.c_str());
|
||||
} else {
|
||||
EWOL_DEBUG("X11 Release : \"" << keyInput << "\" size=" << keyInput.Size());
|
||||
tmpWidget->OnEventKb(ewol::EVENT_KB_TYPE_UP, keyInput.c_str());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#include <ewol/ewol.h>
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
guiAbstraction::Init(argc, argv);
|
||||
// init Ewol
|
||||
ewol::Init(argc, argv);
|
||||
// Init Application ...
|
||||
APP_Init(argc, argv);
|
||||
// Start Ewol diwplay while
|
||||
guiAbstraction::Run();
|
||||
// unset all windows
|
||||
ewol::DisplayWindows(NULL);
|
||||
// call application to uninit
|
||||
APP_UnInit();
|
||||
// basic abstraction un-init
|
||||
guiAbstraction::UnInit();
|
||||
// uninit Ewol
|
||||
ewol::UnInit();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
88
Sources/libewol/ewol/ewol.cpp
Normal file
88
Sources/libewol/ewol/ewol.cpp
Normal file
@ -0,0 +1,88 @@
|
||||
/**
|
||||
*******************************************************************************
|
||||
* @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/WidgetManager.h>
|
||||
|
||||
#include <ewol/base/gui.h>
|
||||
|
||||
#undef __class__
|
||||
#define __class__ "ewol"
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
|
||||
bool ewol::IsPressedInput(int32_t inputID)
|
||||
{
|
||||
return guiAbstraction::IsPressedInput(inputID);
|
||||
}
|
||||
|
||||
void ewol::KeyboardShow(ewol::keyboardMode_te mode)
|
||||
{
|
||||
guiAbstraction::KeyboardShow(mode);
|
||||
}
|
||||
|
||||
void ewol::KeyboardHide(void)
|
||||
{
|
||||
guiAbstraction::KeyboardHide();
|
||||
}
|
||||
|
||||
void ewol::ForceRedrawAll(void)
|
||||
{
|
||||
guiAbstraction::ForceRedrawAll();
|
||||
}
|
||||
|
||||
|
||||
50
Sources/libewol/ewol/ewol.h
Normal file
50
Sources/libewol/ewol/ewol.h
Normal file
@ -0,0 +1,50 @@
|
||||
/**
|
||||
*******************************************************************************
|
||||
* @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 Stop(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);
|
||||
bool IsPressedInput(int32_t inputID);
|
||||
void KeyboardShow(ewol::keyboardMode_te mode);
|
||||
void KeyboardHide(void);
|
||||
void ForceRedrawAll(void);
|
||||
};
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
51
Sources/libewol/ewol/ewolInterne.cpp
Normal file
51
Sources/libewol/ewol/ewolInterne.cpp
Normal file
@ -0,0 +1,51 @@
|
||||
/**
|
||||
*******************************************************************************
|
||||
* @file ewol/ewolInterne.cpp
|
||||
* @brief Main code of ewol interne interaction (sources)
|
||||
* @author Edouard DUPIN
|
||||
* @date 07/01/2012
|
||||
* @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/ewolInterne.h>
|
||||
#include <ewol/Font.h>
|
||||
#include <ewol/WidgetManager.h>
|
||||
#include <ewol/themeManager.h>
|
||||
|
||||
#include <ewol/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);
|
||||
ewol::theme::Init();
|
||||
ewol::widgetManager::Init();
|
||||
ewol::InitFont();
|
||||
}
|
||||
|
||||
void ewol::UnInit(void)
|
||||
{
|
||||
ewol::UnInitFont();
|
||||
ewol::widgetManager::UnInit();
|
||||
ewol::theme::UnInit();
|
||||
}
|
||||
|
||||
43
Sources/libewol/ewol/ewolInterne.h
Normal file
43
Sources/libewol/ewol/ewolInterne.h
Normal file
@ -0,0 +1,43 @@
|
||||
/**
|
||||
*******************************************************************************
|
||||
* @file ewol/ewolInterne.h
|
||||
* @brief Main include of ewol internal interation(header)
|
||||
* @author Edouard DUPIN
|
||||
* @date 07/01/2012
|
||||
* @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_INTERNE_H__
|
||||
#define __EWOL_INTERNE_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 UnInit(void);
|
||||
};
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
34
Sources/libewol/ewol/importgl.h
Normal file
34
Sources/libewol/ewol/importgl.h
Normal 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
|
||||
47
Sources/libewol/ewol/theme/EolBase.cpp
Normal file
47
Sources/libewol/ewol/theme/EolBase.cpp
Normal 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/libewol/ewol/theme/EolBase.h
Normal file
50
Sources/libewol/ewol/theme/EolBase.h
Normal 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/libewol/ewol/theme/EolBaseCircle.cpp
Normal file
119
Sources/libewol/ewol/theme/EolBaseCircle.cpp
Normal 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/libewol/ewol/theme/EolBaseCircle.h
Normal file
57
Sources/libewol/ewol/theme/EolBaseCircle.h
Normal 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/libewol/ewol/theme/EolBaseCirclePart.cpp
Normal file
28
Sources/libewol/ewol/theme/EolBaseCirclePart.cpp
Normal 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/libewol/ewol/theme/EolBaseCirclePart.h
Normal file
32
Sources/libewol/ewol/theme/EolBaseCirclePart.h
Normal 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/libewol/ewol/theme/EolBaseLine.cpp
Normal file
101
Sources/libewol/ewol/theme/EolBaseLine.cpp
Normal 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/libewol/ewol/theme/EolBaseLine.h
Normal file
58
Sources/libewol/ewol/theme/EolBaseLine.h
Normal 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/libewol/ewol/theme/EolBasePolygone.cpp
Normal file
28
Sources/libewol/ewol/theme/EolBasePolygone.cpp
Normal 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/libewol/ewol/theme/EolBasePolygone.h
Normal file
32
Sources/libewol/ewol/theme/EolBasePolygone.h
Normal 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/libewol/ewol/theme/EolBaseRect.cpp
Normal file
117
Sources/libewol/ewol/theme/EolBaseRect.cpp
Normal 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/libewol/ewol/theme/EolBaseRect.h
Normal file
59
Sources/libewol/ewol/theme/EolBaseRect.h
Normal 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/libewol/ewol/theme/EolBaseTriangle.cpp
Normal file
28
Sources/libewol/ewol/theme/EolBaseTriangle.cpp
Normal 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/libewol/ewol/theme/EolBaseTriangle.h
Normal file
32
Sources/libewol/ewol/theme/EolBaseTriangle.h
Normal 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/libewol/ewol/theme/EolColor.cpp
Normal file
127
Sources/libewol/ewol/theme/EolColor.cpp
Normal 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/libewol/ewol/theme/EolColor.h
Normal file
60
Sources/libewol/ewol/theme/EolColor.h
Normal 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/libewol/ewol/theme/EolElement.cpp
Normal file
288
Sources/libewol/ewol/theme/EolElement.cpp
Normal 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/libewol/ewol/theme/EolElement.h
Normal file
81
Sources/libewol/ewol/theme/EolElement.h
Normal 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/libewol/ewol/theme/EolElementFrame.cpp
Normal file
133
Sources/libewol/ewol/theme/EolElementFrame.cpp
Normal 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/libewol/ewol/theme/EolElementFrame.h
Normal file
70
Sources/libewol/ewol/theme/EolElementFrame.h
Normal 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/libewol/ewol/theme/Theme.cpp
Normal file
262
Sources/libewol/ewol/theme/Theme.cpp
Normal 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/libewol/ewol/theme/Theme.h
Normal file
71
Sources/libewol/ewol/theme/Theme.h
Normal 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/libewol/ewol/themeManager.cpp
Normal file
93
Sources/libewol/ewol/themeManager.cpp
Normal 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/libewol/ewol/themeManager.h
Normal file
52
Sources/libewol/ewol/themeManager.h
Normal 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
|
||||
|
||||
202
Sources/libewol/ewol/widget/Button.cpp
Normal file
202
Sources/libewol/ewol/widget/Button.cpp
Normal file
@ -0,0 +1,202 @@
|
||||
/**
|
||||
*******************************************************************************
|
||||
* @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)
|
||||
{
|
||||
AddEventId(ewolEventButtonPressed);
|
||||
AddEventId(ewolEventButtonEnter);
|
||||
AddEventId(ewolEventButtonLeave);
|
||||
|
||||
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 = 16+minWidth;
|
||||
m_minSize.y = 16+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();
|
||||
|
||||
// TODO later : Add this in the basic element of the widget ...
|
||||
int32_t borderSize = 2;
|
||||
int32_t paddingSize = 3;
|
||||
|
||||
int32_t tmpSizeX = m_minSize.x;
|
||||
int32_t tmpSizeY = m_minSize.y;
|
||||
int32_t tmpOriginX = (m_size.x - tmpSizeX) / 2;
|
||||
int32_t tmpOriginY = (m_size.y - tmpSizeY) / 2;
|
||||
// no change for the text orogin :
|
||||
int32_t tmpTextOriginX = (m_size.x - tmpSizeX) / 2 + borderSize + 2*paddingSize;
|
||||
int32_t tmpTextOriginY = (m_size.y - tmpSizeY) / 2 + borderSize + 2*paddingSize;
|
||||
|
||||
if (true==m_userFillX) {
|
||||
tmpSizeX = m_size.x;
|
||||
tmpOriginX = 0;
|
||||
}
|
||||
if (true==m_userFillY) {
|
||||
tmpSizeY = m_size.y;
|
||||
tmpOriginY = 0;
|
||||
}
|
||||
tmpOriginX += paddingSize;
|
||||
tmpOriginY += paddingSize;
|
||||
tmpSizeX -= 2*paddingSize;
|
||||
tmpSizeY -= 2*paddingSize;
|
||||
|
||||
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());
|
||||
*/
|
||||
tmpText->Text(tmpTextOriginX, tmpTextOriginY, m_label.c_str(), m_size.x - borderSize - 2*paddingSize);
|
||||
|
||||
ewol::OObject2DColored * tmpOObjects = new ewol::OObject2DColored;
|
||||
tmpOObjects->SetColor(m_textColorBg);
|
||||
tmpOObjects->Rectangle( tmpOriginX, tmpOriginY, tmpSizeX, tmpSizeY);
|
||||
tmpOObjects->SetColor(m_textColorFg);
|
||||
tmpOObjects->RectangleBorder( tmpOriginX, tmpOriginY, tmpSizeX, tmpSizeY, borderSize);
|
||||
|
||||
AddOObject(tmpOObjects, "BouttonDecoration");
|
||||
|
||||
AddOObject(tmpText, "BouttonText");
|
||||
|
||||
// Regenerate the event Area:
|
||||
EventAreaRemoveAll();
|
||||
coord origin;
|
||||
coord size;
|
||||
origin.x = tmpOriginX;
|
||||
origin.y = tmpOriginY;
|
||||
size.x = tmpSizeX;
|
||||
size.y = tmpSizeY;
|
||||
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);
|
||||
}
|
||||
|
||||
/*
|
||||
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;
|
||||
// in every case this not stop the propagation of the event
|
||||
return false;
|
||||
// if overwrited... you can ...
|
||||
}
|
||||
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user