[RELEASE] Release v1.0.0

Conflicts:
	README.md
	sources/tag

.gitignore

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

.travis.yml

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

Build/Makefile.Android.mk

@@ -1,61 +0,0 @@
-
-
-include $(EWOL_FOLDER)/Build/Makefile.common.mk
-
-
-PROJECT_PACKAGE=$(PROJECT_NAME)package
-JAVA_FOLDER=src/com/$(PROJECT_VENDOR)/$(PROJECT_NAME)
-
-
-all:
-	@echo $(CADRE_HAUT_BAS)
-	@echo $(CADRE_COTERS)
-	@echo '
           DEBUT DE COMPILATION DU PROGRAMME :'$(CADRE_COTERS)
-	@echo '
             Project name    : $(F_BLUE)$(PROJECT_NAME)$(F_NORMALE)'$(CADRE_COTERS)
-	@echo '
             Project Vendor  : $(F_CYAN)$(PROJECT_VENDOR)$(F_NORMALE)'$(CADRE_COTERS)
-	@echo '
             Build date      : $(F_ROUGE)$(BUILD_TIME) $(F_NORMALE)'$(CADRE_COTERS)
-	@echo '
             Tag             : $(F_VIOLET)$(PROJECT_VERSION_TAG) $(F_NORMALE)'$(CADRE_COTERS)
-	@echo $(CADRE_COTERS)
-	@echo $(CADRE_HAUT_BAS)
-	
-	@rm -rf bin
-	
-	@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
-	$(PROJECT_SDK)/platform-tools/adb  install -r ./bin/$(PROJECT_NAME)-debug.apk
-
-clean:
-	@echo $(CADRE_HAUT_BAS)
-	@echo '           CLEANING : bin libs gen obj'$(CADRE_COTERS)
-	@echo $(CADRE_HAUT_BAS)
-	rm -rf bin libs gen obj

Build/Makefile.Linux.mk

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

Build/Makefile.Linux_old.mk

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

Build/Makefile.common.mk

@@ -1,56 +0,0 @@
-##################################################################################################################
-#                                                                                                                #
-#   Fichier     :   Makefile.common                                                                              #
-#                                                                                                                #
-#   Type        :   common part of the ewol Makefile                                                             #
-#                                                                                                                #
-#   Auteur      :   Heero Yui                                                                                    #
-#                                                                                                                #
-#   Evolutions  :   Date          Auteur        Raison                                                           #
-#                2011-12-15      Heero Yui      Mise en place du système de couleur et d'encart                  #
-#                                                                                                                #
-##################################################################################################################
-export F_GRAS=
-export F_INVERSER=
-export F_SOUSLIGNER=
-export F_NORMALE=
-export F_NOIR=
-export F_ROUGE=
-export F_VERT=
-export F_MARRON=
-export F_BLUE=
-export F_VIOLET=
-export F_CYAN=
-export F_GRIS=
-export CADRE_HAUT_BAS='	$(F_INVERSER)                                                                    $(F_NORMALE)'
-export CADRE_COTERS='
	$(F_INVERSER)  $(F_NORMALE)								  $(F_INVERSER)  $(F_NORMALE)'
-
-###############################################################################
-### Platform specificity :                                                  ###
-###############################################################################
-SUPPORTED_PLATFORM=Linux IMac IPhone IPad Android AndroidTablet
-DEFAULT_PLATFORM=Linux
-
-# default platform can be overridden
-PLATFORM?=$(DEFAULT_PLATFORM)
-
-ifeq ($(PLATFORM), Linux)
-    CXXFILES += base/guiX11.cpp
-else ifeq ($(PLATFORM), IMac)
-    CXXFILES += base/guiIMac.cpp
-else ifeq ($(PLATFORM), IPhone)
-    CXXFILES += base/guiIPhone.cpp
-else ifeq ($(PLATFORM), IPad)
-    CXXFILES += base/guiIPad.cpp
-else ifeq ($(PLATFORM), Android)
-    CXXFILES += base/guiAndroid.cpp
-else ifeq ($(PLATFORM), AndroidTablet)
-    CXXFILES += base/guiAndroidTablet.cpp
-else
-    $(error you must specify a corect platform : make PLATFORM=$(SUPPORTED_PLATFORM))
-endif
-
-
-BUILD_TIME=$(shell date)
-
-

Build/coreLinux/clearvars.mk

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

Build/coreLinux/common-vc10.props

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

Build/coreLinux/config.mk

@@ -1,109 +0,0 @@
-###############################################################################
-## @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/")
-

Build/coreLinux/defs.mk

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

Build/coreLinux/executable.mk

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

Build/coreLinux/main.mk

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

Build/coreLinux/rules.mk

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

Build/coreLinux/shared.mk

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

Build/coreLinux/static.mk

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

Build/ewol.mk

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

Java/PROJECT_NAME.java

@@ -1,231 +0,0 @@
-
-
-
-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;
-import android.view.KeyEvent;
-// For No Title : 
-import android.view.Window;
-
-// For the full screen : 
-import android.view.WindowManager;
-
-import java.io.File;
-import android.content.Context;
-import android.content.res.Configuration;
-
-// 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 static native void ActivityOnCreate();
-	private static native void ActivityOnStart();
-	private static native void ActivityOnReStart();
-	private static native void ActivityOnResume();
-	private static native void ActivityOnPause();
-	private static native void ActivityOnStop();
-	private static native void ActivityOnDestroy();
-	private static native void ActivityParamSetArchiveDir(int mode, String myString);
-
-	private GLSurfaceView mGLView;
-
-	static {
-		System.loadLibrary("__PROJECT_PACKAGE__");
-	}
-
-	@Override protected void onCreate(Bundle savedInstanceState) {
-		super.onCreate(savedInstanceState);
-		
-		// Load the application directory
-		ActivityParamSetArchiveDir(1, getFilesDir().toString());
-		ActivityParamSetArchiveDir(2, getCacheDir().toString());
-		// to enable extarnal storage: add in the manifest the restriction needed ...
-		//ActivityParamSetArchiveDir(3, getExternalCacheDir().toString());
-		
-		// return apk file path (or null on error)
-		String apkFilePath = null;
-		ApplicationInfo appInfo = null;
-		PackageManager packMgmr = 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;
-		ActivityParamSetArchiveDir(0, apkFilePath);
-		
-		
-		// call C init ...
-		ActivityOnCreate();
-		
-		// 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 onStart() {
-		super.onStart();
-		// call C
-		ActivityOnStart();
-	}
-	
-	@Override protected void onRestart() {
-		super.onRestart();
-		// call C
-		ActivityOnReStart();
-	}
-	
-	@Override protected void onResume() {
-		super.onResume();
-		mGLView.onResume();
-		// call C
-		ActivityOnResume();
-	}
-	
-	@Override protected void onPause() {
-		super.onPause();
-		mGLView.onPause();
-		// call C
-		ActivityOnPause();
-	}
-	
-	@Override protected void onStop() {
-		super.onStop();
-		// call C
-		ActivityOnStop();
-	}
-	@Override protected void onDestroy() {
-		super.onDestroy();
-		// call C
-		ActivityOnDestroy();
-	}
-	public void onConfigurationChanged(Configuration newConfig) {
-		super.onConfigurationChanged(newConfig);
-	}
-}
-
-
-/**
- * @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);
-	
-	public EwolGLSurfaceView(Context context) {
-		// super must be first statement in constructor
-		super(context);
-		
-		// 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(event.getPointerId(0), true, (float)event.getX(0), (float)event.getY(0));
-			InputDown1 = true;
-		} else if(tmpActionType == MotionEvent.ACTION_POINTER_1_UP) {
-			nativeEventInputState(event.getPointerId(0), false, (float)event.getX(0), (float)event.getY(0));
-			InputDown1 = false;
-		} else if (tmpActionType == MotionEvent.ACTION_POINTER_2_DOWN) {
-			nativeEventInputState(event.getPointerId(1), true, (float)event.getX(1), (float)event.getY(1));
-			InputDown2 = true;
-		} else if (tmpActionType == MotionEvent.ACTION_POINTER_2_UP) {
-			nativeEventInputState(event.getPointerId(1), false, (float)event.getX(1), (float)event.getY(1));
-			InputDown2 = false;
-		} else if (tmpActionType == MotionEvent.ACTION_POINTER_3_DOWN) {
-			nativeEventInputState(event.getPointerId(2), true, (float)event.getX(2), (float)event.getY(2));
-			InputDown3 = true;
-		} else if (tmpActionType == MotionEvent.ACTION_POINTER_3_UP) {
-			nativeEventInputState(event.getPointerId(2), false, (float)event.getX(2), (float)event.getY(2));
-			InputDown3 = false;
-		} else if(tmpActionType == MotionEvent.ACTION_UP){
-			if (InputDown1) {
-				nativeEventInputState(event.getPointerId(0), false, (float)event.getX(0), (float)event.getY(0));
-				InputDown1 = false;
-			} else if (InputDown2) {
-				nativeEventInputState(event.getPointerId(0), false, (float)event.getX(0), (float)event.getY(0));
-				InputDown2 = false;
-			} else {
-				nativeEventInputState(event.getPointerId(0), false, (float)event.getX(0), (float)event.getY(0));
-				InputDown3 = false;
-			}
-		}
-		return true;
-	}
-	
-	public boolean onKeyDown (int keyCode, KeyEvent event){
-		// TODO ...
-		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();
-	
-	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();
-	}
-}
-

Java/ewolAndroidAbstraction.cpp

@@ -1,148 +0,0 @@
-/**
- *******************************************************************************
- * @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>
-#include <pthread.h>
-#include <tools_debug.h>
-
-#include <ewol/threadMsg.h>
-
-// declaration of the ewol android abstraction ...
-
-void EWOL_SystemStart(void);
-void EWOL_SystemStop(void);
-void EWOL_ThreadSetArchiveDir(int mode, const char* str);
-void EWOL_ThreadResize(int w, int h );
-void EWOL_ThreadEventInputMotion(int pointerID, float x, float y);
-void EWOL_ThreadEventInputState(int pointerID, bool isUp, float x, float y);
-void EWOL_NativeRender(void);
-void EWOL_NativeGLDestroy(void);
-
-
-extern "C"
-{
-	/* Call to initialize the graphics state */
-	
-	void Java_com___PROJECT_VENDOR_____PROJECT_PACKAGE_____PROJECT_NAME___ActivityParamSetArchiveDir( JNIEnv* env, jobject  thiz, jint mode, jstring myString)
-	{
-		// direct setting of the date in the string system ...
-		const char* str = env->GetStringUTFChars(myString,0);
-		EWOL_ThreadSetArchiveDir(mode, str);
-		//env->ReleaseStringUTFChars(str,myString,0);
-	}
-	
-	void Java_com___PROJECT_VENDOR_____PROJECT_PACKAGE_____PROJECT_NAME___ActivityOnCreate( JNIEnv*  env )
-	{
-		EDN_DEBUG("*******************************************");
-		EDN_DEBUG("**  Activity On Create                   **");
-		EDN_DEBUG("*******************************************");
-		EWOL_SystemStart();
-	}
-	void Java_com___PROJECT_VENDOR_____PROJECT_PACKAGE_____PROJECT_NAME___ActivityOnStart( JNIEnv*  env )
-	{
-		EDN_DEBUG("*******************************************");
-		EDN_DEBUG("**  Activity On Start                    **");
-		EDN_DEBUG("*******************************************");
-	}
-	void Java_com___PROJECT_VENDOR_____PROJECT_PACKAGE_____PROJECT_NAME___ActivityOnReStart( JNIEnv*  env )
-	{
-		EDN_DEBUG("*******************************************");
-		EDN_DEBUG("**  Activity On Re-Start                 **");
-		EDN_DEBUG("*******************************************");
-	}
-	void Java_com___PROJECT_VENDOR_____PROJECT_PACKAGE_____PROJECT_NAME___ActivityOnResume( JNIEnv*  env )
-	{
-		EDN_DEBUG("*******************************************");
-		EDN_DEBUG("**  Activity On Resume                   **");
-		EDN_DEBUG("*******************************************");
-	}
-	void Java_com___PROJECT_VENDOR_____PROJECT_PACKAGE_____PROJECT_NAME___ActivityOnPause( JNIEnv*  env )
-	{
-		EDN_DEBUG("*******************************************");
-		EDN_DEBUG("**  Activity On Pause                    **");
-		EDN_DEBUG("*******************************************");
-		// All the openGl has been destroyed ...
-		// TODO : Mark all the texture to be reloaded ...
-		EWOL_NativeGLDestroy();
-	}
-	void Java_com___PROJECT_VENDOR_____PROJECT_PACKAGE_____PROJECT_NAME___ActivityOnStop( JNIEnv*  env )
-	{
-		EDN_DEBUG("*******************************************");
-		EDN_DEBUG("**  Activity On Stop                     **");
-		EDN_DEBUG("*******************************************");
-	}
-	void Java_com___PROJECT_VENDOR_____PROJECT_PACKAGE_____PROJECT_NAME___ActivityOnDestroy( JNIEnv*  env )
-	{
-		EDN_DEBUG("*******************************************");
-		EDN_DEBUG("**  Activity On Destroy                  **");
-		EDN_DEBUG("*******************************************");
-		EWOL_SystemStop();
-	}
-	
-	
-	/* Call to initialize the graphics state */
-	void Java_com___PROJECT_VENDOR_____PROJECT_PACKAGE___EwolRenderer_nativeInit( JNIEnv*  env )
-	{
-		
-	}
-	
-	
-	void Java_com___PROJECT_VENDOR_____PROJECT_PACKAGE___EwolRenderer_nativeResize( JNIEnv* env, jobject thiz, jint w, jint h )
-	{
-		EWOL_ThreadResize(w, h);
-	}
-	
-	void Java_com___PROJECT_VENDOR_____PROJECT_PACKAGE___EwolGLSurfaceView_nativeEventInputMotion( JNIEnv* env, jobject  thiz, jint pointerID, jfloat x, jfloat y )
-	{
-		EWOL_ThreadEventInputMotion(pointerID+1, x, y);
-	}
-	
-	void Java_com___PROJECT_VENDOR_____PROJECT_PACKAGE___EwolGLSurfaceView_nativeEventInputState( JNIEnv* env, jobject  thiz, jint pointerID, jboolean isUp, jfloat x, jfloat y )
-	{
-		EWOL_ThreadEventInputState(pointerID+1, isUp, x, y);
-	}
-	
-	
-	void Java_com___PROJECT_VENDOR_____PROJECT_PACKAGE___EwolGLSurfaceView_nativeApplicationInit( JNIEnv* env)
-	{
-		//ewol::threadMsg::SendMessage(androidJniMsg, JNI_APP_INIT);
-		//EWOL_NativeApplicationInit();
-	}
-	
-	void Java_com___PROJECT_VENDOR_____PROJECT_PACKAGE___EwolGLSurfaceView_nativeApplicationUnInit( JNIEnv* env)
-	{
-		//ewol::threadMsg::SendMessage(androidJniMsg, JNI_APP_UN_INIT);
-		//EWOL_NativeApplicationUnInit();
-	}
-	
-	void Java_com___PROJECT_VENDOR_____PROJECT_PACKAGE___EwolRenderer_nativeRender( JNIEnv*  env )
-	{
-		EWOL_NativeRender();
-	}
-
-}
-

LICENSE

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

README.md

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

Sources/Android.mk

@@ -1,2 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-include $(call all-subdir-makefiles)

Sources/libagg/Android.mk

@@ -1,34 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE := ewol
-LOCAL_STATIC_LIBRARIES := libetk libtinyxml libzip libpng libfreetype
-
-LOCAL_C_INCLUDES := $(LOCAL_PATH)
-
-LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)
-LOCAL_EXPORT_LDLIBS := -lGLESv1_CM -ldl -llog -lz
-
-LOCAL_CFLAGS := -D__PLATFORM__Android \
-                -D__MODE__Touch \
-                -Wno-write-strings \
-                -DETK_DEBUG_LEVEL=3 \
-                -DEWOL_DEBUG_LEVEL=3 \
-                -DEWOL_VERSION_TAG_NAME="\"UNKNOW-debug\"" \
-                -DVERSION_BUILD_TIME="\"pasd_heure\"" \
-                -DEWOL_USE_FREE_TYPE \
-                -DDATA_IN_APK \
-                -frtti
-
-# load the common sources file of the platform
-include $(LOCAL_PATH)/file.mk
-
-LOCAL_SRC_FILES := ewol/base/guiAndroid.cpp $(FILE_LIST)
-
-# Ewol Test Software :
-LOCAL_LDLIBS := -lGLESv1_CM -ldl -llog -lz
-
-include $(BUILD_STATIC_LIBRARY)
-
-

Sources/libagg/Linux.mk

@@ -1,37 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-# name of the librairy
-LOCAL_MODULE := agg
-
-# name of the dependency
-LOCAL_STATIC_LIBRARIES := libfreetype
-
-LOCAL_C_INCLUDES := -I$(LOCAL_PATH) \
-                    -I$(LOCAL_PATH)/agg-2.4/ \
-                    -I$(LOCAL_PATH)/agg-2.4/util/
-
-LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)
-LOCAL_EXPORT_LDLIBS := 
-
-ifeq ($(DEBUG),1)
-LOCAL_CFLAGS := -D__PLATFORM__Linux \
-                -DAGG_VERSION_TAG_NAME="\"2.4-debug\""
-else
-LOCAL_CFLAGS := -D__PLATFORM__Linux \
-                -DAGG_VERSION_TAG_NAME="\"2.4-release\""
-endif
-
-# 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)

Sources/libagg/agg-2.4/agg_alpha_mask_u8.h

@@ -1,499 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// scanline_u8 class
-//
-//----------------------------------------------------------------------------
-#ifndef AGG_ALPHA_MASK_U8_INCLUDED
-#define AGG_ALPHA_MASK_U8_INCLUDED
-
-#include <string.h>
-#include "agg_basics.h"
-#include "agg_rendering_buffer.h"
-
-namespace agg
-{
-    //===================================================one_component_mask_u8
-    struct one_component_mask_u8
-    {
-        static unsigned calculate(const int8u* p) { return *p; }
-    };
-    
-
-    //=====================================================rgb_to_gray_mask_u8
-    template<unsigned R, unsigned G, unsigned B>
-    struct rgb_to_gray_mask_u8
-    {
-        static unsigned calculate(const int8u* p) 
-        { 
-            return (p[R]*77 + p[G]*150 + p[B]*29) >> 8; 
-        }
-    };
-
-    //==========================================================alpha_mask_u8
-    template<unsigned Step=1, unsigned Offset=0, class MaskF=one_component_mask_u8>
-    class alpha_mask_u8
-    {
-    public:
-        typedef int8u cover_type;
-        typedef alpha_mask_u8<Step, Offset, MaskF> self_type;
-        enum cover_scale_e
-        { 
-            cover_shift = 8,
-            cover_none  = 0,
-            cover_full  = 255
-        };
-
-        alpha_mask_u8() : m_rbuf(0) {}
-        explicit alpha_mask_u8(rendering_buffer& rbuf) : m_rbuf(&rbuf) {}
-
-        void attach(rendering_buffer& rbuf) { m_rbuf = &rbuf; }
-
-        MaskF& mask_function() { return m_mask_function; }
-        const MaskF& mask_function() const { return m_mask_function; }
-
-        
-        //--------------------------------------------------------------------
-        cover_type pixel(int x, int y) const
-        {
-            if(x >= 0 && y >= 0 && 
-               x < (int)m_rbuf->width() && 
-               y < (int)m_rbuf->height())
-            {
-                return (cover_type)m_mask_function.calculate(
-                                        m_rbuf->row_ptr(y) + x * Step + Offset);
-            }
-            return 0;
-        }
-
-        //--------------------------------------------------------------------
-        cover_type combine_pixel(int x, int y, cover_type val) const
-        {
-            if(x >= 0 && y >= 0 && 
-               x < (int)m_rbuf->width() && 
-               y < (int)m_rbuf->height())
-            {
-                return (cover_type)((cover_full + val * 
-                                     m_mask_function.calculate(
-                                        m_rbuf->row_ptr(y) + x * Step + Offset)) >> 
-                                     cover_shift);
-            }
-            return 0;
-        }
-
-
-        //--------------------------------------------------------------------
-        void fill_hspan(int x, int y, cover_type* dst, int num_pix) const
-        {
-            int xmax = m_rbuf->width() - 1;
-            int ymax = m_rbuf->height() - 1;
-
-            int count = num_pix;
-            cover_type* covers = dst;
-
-            if(y < 0 || y > ymax)
-            {
-                memset(dst, 0, num_pix * sizeof(cover_type));
-                return;
-            }
-
-            if(x < 0)
-            {
-                count += x;
-                if(count <= 0) 
-                {
-                    memset(dst, 0, num_pix * sizeof(cover_type));
-                    return;
-                }
-                memset(covers, 0, -x * sizeof(cover_type));
-                covers -= x;
-                x = 0;
-            }
-
-            if(x + count > xmax)
-            {
-                int rest = x + count - xmax - 1;
-                count -= rest;
-                if(count <= 0) 
-                {
-                    memset(dst, 0, num_pix * sizeof(cover_type));
-                    return;
-                }
-                memset(covers + count, 0, rest * sizeof(cover_type));
-            }
-
-            const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
-            do
-            {
-                *covers++ = (cover_type)m_mask_function.calculate(mask);
-                mask += Step;
-            }
-            while(--count);
-        }
-
-
-        //--------------------------------------------------------------------
-        void combine_hspan(int x, int y, cover_type* dst, int num_pix) const
-        {
-            int xmax = m_rbuf->width() - 1;
-            int ymax = m_rbuf->height() - 1;
-
-            int count = num_pix;
-            cover_type* covers = dst;
-
-            if(y < 0 || y > ymax)
-            {
-                memset(dst, 0, num_pix * sizeof(cover_type));
-                return;
-            }
-
-            if(x < 0)
-            {
-                count += x;
-                if(count <= 0) 
-                {
-                    memset(dst, 0, num_pix * sizeof(cover_type));
-                    return;
-                }
-                memset(covers, 0, -x * sizeof(cover_type));
-                covers -= x;
-                x = 0;
-            }
-
-            if(x + count > xmax)
-            {
-                int rest = x + count - xmax - 1;
-                count -= rest;
-                if(count <= 0) 
-                {
-                    memset(dst, 0, num_pix * sizeof(cover_type));
-                    return;
-                }
-                memset(covers + count, 0, rest * sizeof(cover_type));
-            }
-
-            const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
-            do
-            {
-                *covers = (cover_type)((cover_full + (*covers) * 
-                                       m_mask_function.calculate(mask)) >> 
-                                       cover_shift);
-                ++covers;
-                mask += Step;
-            }
-            while(--count);
-        }
-
-        //--------------------------------------------------------------------
-        void fill_vspan(int x, int y, cover_type* dst, int num_pix) const
-        {
-            int xmax = m_rbuf->width() - 1;
-            int ymax = m_rbuf->height() - 1;
-
-            int count = num_pix;
-            cover_type* covers = dst;
-
-            if(x < 0 || x > xmax)
-            {
-                memset(dst, 0, num_pix * sizeof(cover_type));
-                return;
-            }
-
-            if(y < 0)
-            {
-                count += y;
-                if(count <= 0) 
-                {
-                    memset(dst, 0, num_pix * sizeof(cover_type));
-                    return;
-                }
-                memset(covers, 0, -y * sizeof(cover_type));
-                covers -= y;
-                y = 0;
-            }
-
-            if(y + count > ymax)
-            {
-                int rest = y + count - ymax - 1;
-                count -= rest;
-                if(count <= 0) 
-                {
-                    memset(dst, 0, num_pix * sizeof(cover_type));
-                    return;
-                }
-                memset(covers + count, 0, rest * sizeof(cover_type));
-            }
-
-            const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
-            do
-            {
-                *covers++ = (cover_type)m_mask_function.calculate(mask);
-                mask += m_rbuf->stride();
-            }
-            while(--count);
-        }
-
-        //--------------------------------------------------------------------
-        void combine_vspan(int x, int y, cover_type* dst, int num_pix) const
-        {
-            int xmax = m_rbuf->width() - 1;
-            int ymax = m_rbuf->height() - 1;
-
-            int count = num_pix;
-            cover_type* covers = dst;
-
-            if(x < 0 || x > xmax)
-            {
-                memset(dst, 0, num_pix * sizeof(cover_type));
-                return;
-            }
-
-            if(y < 0)
-            {
-                count += y;
-                if(count <= 0) 
-                {
-                    memset(dst, 0, num_pix * sizeof(cover_type));
-                    return;
-                }
-                memset(covers, 0, -y * sizeof(cover_type));
-                covers -= y;
-                y = 0;
-            }
-
-            if(y + count > ymax)
-            {
-                int rest = y + count - ymax - 1;
-                count -= rest;
-                if(count <= 0) 
-                {
-                    memset(dst, 0, num_pix * sizeof(cover_type));
-                    return;
-                }
-                memset(covers + count, 0, rest * sizeof(cover_type));
-            }
-
-            const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
-            do
-            {
-                *covers = (cover_type)((cover_full + (*covers) * 
-                                       m_mask_function.calculate(mask)) >> 
-                                       cover_shift);
-                ++covers;
-                mask += m_rbuf->stride();
-            }
-            while(--count);
-        }
-
-
-    private:
-        alpha_mask_u8(const self_type&);
-        const self_type& operator = (const self_type&);
-
-        rendering_buffer* m_rbuf;
-        MaskF             m_mask_function;
-    };
-    
-
-    typedef alpha_mask_u8<1, 0> alpha_mask_gray8;   //----alpha_mask_gray8
-
-    typedef alpha_mask_u8<3, 0> alpha_mask_rgb24r;  //----alpha_mask_rgb24r
-    typedef alpha_mask_u8<3, 1> alpha_mask_rgb24g;  //----alpha_mask_rgb24g
-    typedef alpha_mask_u8<3, 2> alpha_mask_rgb24b;  //----alpha_mask_rgb24b
-
-    typedef alpha_mask_u8<3, 2> alpha_mask_bgr24r;  //----alpha_mask_bgr24r
-    typedef alpha_mask_u8<3, 1> alpha_mask_bgr24g;  //----alpha_mask_bgr24g
-    typedef alpha_mask_u8<3, 0> alpha_mask_bgr24b;  //----alpha_mask_bgr24b
-
-    typedef alpha_mask_u8<4, 0> alpha_mask_rgba32r; //----alpha_mask_rgba32r
-    typedef alpha_mask_u8<4, 1> alpha_mask_rgba32g; //----alpha_mask_rgba32g
-    typedef alpha_mask_u8<4, 2> alpha_mask_rgba32b; //----alpha_mask_rgba32b
-    typedef alpha_mask_u8<4, 3> alpha_mask_rgba32a; //----alpha_mask_rgba32a
-
-    typedef alpha_mask_u8<4, 1> alpha_mask_argb32r; //----alpha_mask_argb32r
-    typedef alpha_mask_u8<4, 2> alpha_mask_argb32g; //----alpha_mask_argb32g
-    typedef alpha_mask_u8<4, 3> alpha_mask_argb32b; //----alpha_mask_argb32b
-    typedef alpha_mask_u8<4, 0> alpha_mask_argb32a; //----alpha_mask_argb32a
-
-    typedef alpha_mask_u8<4, 2> alpha_mask_bgra32r; //----alpha_mask_bgra32r
-    typedef alpha_mask_u8<4, 1> alpha_mask_bgra32g; //----alpha_mask_bgra32g
-    typedef alpha_mask_u8<4, 0> alpha_mask_bgra32b; //----alpha_mask_bgra32b
-    typedef alpha_mask_u8<4, 3> alpha_mask_bgra32a; //----alpha_mask_bgra32a
-
-    typedef alpha_mask_u8<4, 3> alpha_mask_abgr32r; //----alpha_mask_abgr32r
-    typedef alpha_mask_u8<4, 2> alpha_mask_abgr32g; //----alpha_mask_abgr32g
-    typedef alpha_mask_u8<4, 1> alpha_mask_abgr32b; //----alpha_mask_abgr32b
-    typedef alpha_mask_u8<4, 0> alpha_mask_abgr32a; //----alpha_mask_abgr32a
-
-    typedef alpha_mask_u8<3, 0, rgb_to_gray_mask_u8<0, 1, 2> > alpha_mask_rgb24gray;  //----alpha_mask_rgb24gray
-    typedef alpha_mask_u8<3, 0, rgb_to_gray_mask_u8<2, 1, 0> > alpha_mask_bgr24gray;  //----alpha_mask_bgr24gray
-    typedef alpha_mask_u8<4, 0, rgb_to_gray_mask_u8<0, 1, 2> > alpha_mask_rgba32gray; //----alpha_mask_rgba32gray
-    typedef alpha_mask_u8<4, 1, rgb_to_gray_mask_u8<0, 1, 2> > alpha_mask_argb32gray; //----alpha_mask_argb32gray
-    typedef alpha_mask_u8<4, 0, rgb_to_gray_mask_u8<2, 1, 0> > alpha_mask_bgra32gray; //----alpha_mask_bgra32gray
-    typedef alpha_mask_u8<4, 1, rgb_to_gray_mask_u8<2, 1, 0> > alpha_mask_abgr32gray; //----alpha_mask_abgr32gray
-
-
-
-    //==========================================================amask_no_clip_u8
-    template<unsigned Step=1, unsigned Offset=0, class MaskF=one_component_mask_u8>
-    class amask_no_clip_u8
-    {
-    public:
-        typedef int8u cover_type;
-        typedef amask_no_clip_u8<Step, Offset, MaskF> self_type;
-        enum cover_scale_e
-        { 
-            cover_shift = 8,
-            cover_none  = 0,
-            cover_full  = 255
-        };
-
-        amask_no_clip_u8() : m_rbuf(0) {}
-        explicit amask_no_clip_u8(rendering_buffer& rbuf) : m_rbuf(&rbuf) {}
-
-        void attach(rendering_buffer& rbuf) { m_rbuf = &rbuf; }
-
-        MaskF& mask_function() { return m_mask_function; }
-        const MaskF& mask_function() const { return m_mask_function; }
-
-
-        //--------------------------------------------------------------------
-        cover_type pixel(int x, int y) const
-        {
-            return (cover_type)m_mask_function.calculate(
-                                   m_rbuf->row_ptr(y) + x * Step + Offset);
-        }
-
-        
-        //--------------------------------------------------------------------
-        cover_type combine_pixel(int x, int y, cover_type val) const
-        {
-            return (cover_type)((cover_full + val * 
-                                 m_mask_function.calculate(
-                                    m_rbuf->row_ptr(y) + x * Step + Offset)) >> 
-                                 cover_shift);
-        }
-
-
-        //--------------------------------------------------------------------
-        void fill_hspan(int x, int y, cover_type* dst, int num_pix) const
-        {
-            const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
-            do
-            {
-                *dst++ = (cover_type)m_mask_function.calculate(mask);
-                mask += Step;
-            }
-            while(--num_pix);
-        }
-
-
-
-        //--------------------------------------------------------------------
-        void combine_hspan(int x, int y, cover_type* dst, int num_pix) const
-        {
-            const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
-            do
-            {
-                *dst = (cover_type)((cover_full + (*dst) * 
-                                    m_mask_function.calculate(mask)) >> 
-                                    cover_shift);
-                ++dst;
-                mask += Step;
-            }
-            while(--num_pix);
-        }
-
-
-        //--------------------------------------------------------------------
-        void fill_vspan(int x, int y, cover_type* dst, int num_pix) const
-        {
-            const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
-            do
-            {
-                *dst++ = (cover_type)m_mask_function.calculate(mask);
-                mask += m_rbuf->stride();
-            }
-            while(--num_pix);
-        }
-
-
-        //--------------------------------------------------------------------
-        void combine_vspan(int x, int y, cover_type* dst, int num_pix) const
-        {
-            const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
-            do
-            {
-                *dst = (cover_type)((cover_full + (*dst) * 
-                                    m_mask_function.calculate(mask)) >> 
-                                    cover_shift);
-                ++dst;
-                mask += m_rbuf->stride();
-            }
-            while(--num_pix);
-        }
-
-    private:
-        amask_no_clip_u8(const self_type&);
-        const self_type& operator = (const self_type&);
-
-        rendering_buffer* m_rbuf;
-        MaskF             m_mask_function;
-    };
-    
-
-    typedef amask_no_clip_u8<1, 0> amask_no_clip_gray8;   //----amask_no_clip_gray8
-
-    typedef amask_no_clip_u8<3, 0> amask_no_clip_rgb24r;  //----amask_no_clip_rgb24r
-    typedef amask_no_clip_u8<3, 1> amask_no_clip_rgb24g;  //----amask_no_clip_rgb24g
-    typedef amask_no_clip_u8<3, 2> amask_no_clip_rgb24b;  //----amask_no_clip_rgb24b
-
-    typedef amask_no_clip_u8<3, 2> amask_no_clip_bgr24r;  //----amask_no_clip_bgr24r
-    typedef amask_no_clip_u8<3, 1> amask_no_clip_bgr24g;  //----amask_no_clip_bgr24g
-    typedef amask_no_clip_u8<3, 0> amask_no_clip_bgr24b;  //----amask_no_clip_bgr24b
-
-    typedef amask_no_clip_u8<4, 0> amask_no_clip_rgba32r; //----amask_no_clip_rgba32r
-    typedef amask_no_clip_u8<4, 1> amask_no_clip_rgba32g; //----amask_no_clip_rgba32g
-    typedef amask_no_clip_u8<4, 2> amask_no_clip_rgba32b; //----amask_no_clip_rgba32b
-    typedef amask_no_clip_u8<4, 3> amask_no_clip_rgba32a; //----amask_no_clip_rgba32a
-
-    typedef amask_no_clip_u8<4, 1> amask_no_clip_argb32r; //----amask_no_clip_argb32r
-    typedef amask_no_clip_u8<4, 2> amask_no_clip_argb32g; //----amask_no_clip_argb32g
-    typedef amask_no_clip_u8<4, 3> amask_no_clip_argb32b; //----amask_no_clip_argb32b
-    typedef amask_no_clip_u8<4, 0> amask_no_clip_argb32a; //----amask_no_clip_argb32a
-
-    typedef amask_no_clip_u8<4, 2> amask_no_clip_bgra32r; //----amask_no_clip_bgra32r
-    typedef amask_no_clip_u8<4, 1> amask_no_clip_bgra32g; //----amask_no_clip_bgra32g
-    typedef amask_no_clip_u8<4, 0> amask_no_clip_bgra32b; //----amask_no_clip_bgra32b
-    typedef amask_no_clip_u8<4, 3> amask_no_clip_bgra32a; //----amask_no_clip_bgra32a
-
-    typedef amask_no_clip_u8<4, 3> amask_no_clip_abgr32r; //----amask_no_clip_abgr32r
-    typedef amask_no_clip_u8<4, 2> amask_no_clip_abgr32g; //----amask_no_clip_abgr32g
-    typedef amask_no_clip_u8<4, 1> amask_no_clip_abgr32b; //----amask_no_clip_abgr32b
-    typedef amask_no_clip_u8<4, 0> amask_no_clip_abgr32a; //----amask_no_clip_abgr32a
-
-    typedef amask_no_clip_u8<3, 0, rgb_to_gray_mask_u8<0, 1, 2> > amask_no_clip_rgb24gray;  //----amask_no_clip_rgb24gray
-    typedef amask_no_clip_u8<3, 0, rgb_to_gray_mask_u8<2, 1, 0> > amask_no_clip_bgr24gray;  //----amask_no_clip_bgr24gray
-    typedef amask_no_clip_u8<4, 0, rgb_to_gray_mask_u8<0, 1, 2> > amask_no_clip_rgba32gray; //----amask_no_clip_rgba32gray
-    typedef amask_no_clip_u8<4, 1, rgb_to_gray_mask_u8<0, 1, 2> > amask_no_clip_argb32gray; //----amask_no_clip_argb32gray
-    typedef amask_no_clip_u8<4, 0, rgb_to_gray_mask_u8<2, 1, 0> > amask_no_clip_bgra32gray; //----amask_no_clip_bgra32gray
-    typedef amask_no_clip_u8<4, 1, rgb_to_gray_mask_u8<2, 1, 0> > amask_no_clip_abgr32gray; //----amask_no_clip_abgr32gray
-
-
-}
-
-
-
-#endif

Sources/libagg/agg-2.4/agg_arc.cpp

@@ -1,106 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// Arc vertex generator
-//
-//----------------------------------------------------------------------------
-
-#include <math.h>
-#include "agg_arc.h"
-
-
-namespace agg
-{
-    //------------------------------------------------------------------------
-    arc::arc(double x,  double y, 
-             double rx, double ry, 
-             double a1, double a2, 
-             bool ccw) :
-        m_x(x), m_y(y), m_rx(rx), m_ry(ry), m_scale(1.0)
-    {
-        normalize(a1, a2, ccw);
-    }
-
-    //------------------------------------------------------------------------
-    void arc::init(double x,  double y, 
-                   double rx, double ry, 
-                   double a1, double a2, 
-                   bool ccw)
-    {
-        m_x   = x;  m_y  = y;
-        m_rx  = rx; m_ry = ry; 
-        normalize(a1, a2, ccw);
-    }
-    
-    //------------------------------------------------------------------------
-    void arc::approximation_scale(double s)
-    {
-        m_scale = s;
-        if(m_initialized)
-        {
-            normalize(m_start, m_end, m_ccw);
-        }
-    }
-
-    //------------------------------------------------------------------------
-    void arc::rewind(unsigned)
-    {
-        m_path_cmd = path_cmd_move_to; 
-        m_angle = m_start;
-    }
-
-    //------------------------------------------------------------------------
-    unsigned arc::vertex(double* x, double* y)
-    {
-        if(is_stop(m_path_cmd)) return path_cmd_stop;
-        if((m_angle < m_end - m_da/4) != m_ccw)
-        {
-            *x = m_x + cos(m_end) * m_rx;
-            *y = m_y + sin(m_end) * m_ry;
-            m_path_cmd = path_cmd_stop;
-            return path_cmd_line_to;
-        }
-
-        *x = m_x + cos(m_angle) * m_rx;
-        *y = m_y + sin(m_angle) * m_ry;
-
-        m_angle += m_da;
-
-        unsigned pf = m_path_cmd;
-        m_path_cmd = path_cmd_line_to;
-        return pf;
-    }
-
-    //------------------------------------------------------------------------
-    void arc::normalize(double a1, double a2, bool ccw)
-    {
-        double ra = (fabs(m_rx) + fabs(m_ry)) / 2;
-        m_da = acos(ra / (ra + 0.125 / m_scale)) * 2;
-        if(ccw)
-        {
-            while(a2 < a1) a2 += pi * 2.0;
-        }
-        else
-        {
-            while(a1 < a2) a1 += pi * 2.0;
-            m_da = -m_da;
-        }
-        m_ccw   = ccw;
-        m_start = a1;
-        m_end   = a2;
-        m_initialized = true;
-    }
-
-}

Sources/libagg/agg-2.4/agg_arc.h

@@ -1,74 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// Arc vertex generator
-//
-//----------------------------------------------------------------------------
-
-#ifndef AGG_ARC_INCLUDED
-#define AGG_ARC_INCLUDED
-
-#include <math.h>
-#include "agg_basics.h"
-
-namespace agg
-{
-
-    //=====================================================================arc
-    //
-    // See Implementation agg_arc.cpp 
-    //
-    class arc
-    {
-    public:
-        arc() : m_scale(1.0), m_initialized(false) {}
-        arc(double x,  double y, 
-            double rx, double ry, 
-            double a1, double a2, 
-            bool ccw=true);
-
-        void init(double x,  double y, 
-                  double rx, double ry, 
-                  double a1, double a2, 
-                  bool ccw=true);
-
-        void approximation_scale(double s);
-        double approximation_scale() const { return m_scale;  }
-
-        void rewind(unsigned);
-        unsigned vertex(double* x, double* y);
-
-    private:
-        void normalize(double a1, double a2, bool ccw);
-
-        double   m_x;
-        double   m_y;
-        double   m_rx;
-        double   m_ry;
-        double   m_angle;
-        double   m_start;
-        double   m_end;
-        double   m_scale;
-        double   m_da;
-        bool     m_ccw;
-        bool     m_initialized;
-        unsigned m_path_cmd;
-    };
-
-
-}
-
-
-#endif

Sources/libagg/agg-2.4/agg_arrowhead.cpp

@@ -1,110 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// Simple arrowhead/arrowtail generator 
-//
-//----------------------------------------------------------------------------
-
-#include "agg_arrowhead.h"
-
-namespace agg
-{
-
-    //------------------------------------------------------------------------
-    arrowhead::arrowhead() :
-        m_head_d1(1.0),
-        m_head_d2(1.0),
-        m_head_d3(1.0),
-        m_head_d4(0.0),
-        m_tail_d1(1.0),
-        m_tail_d2(1.0),
-        m_tail_d3(1.0),
-        m_tail_d4(0.0),
-        m_head_flag(false),
-        m_tail_flag(false),
-        m_curr_id(0),
-        m_curr_coord(0)
-    {
-    }
-
-
-
-    //------------------------------------------------------------------------
-    void arrowhead::rewind(unsigned path_id)
-    {
-        m_curr_id = path_id;
-        m_curr_coord = 0;
-        if(path_id == 0)
-        {
-            if(!m_tail_flag)
-            {
-                m_cmd[0] = path_cmd_stop;
-                return;
-            }
-            m_coord[0]  =  m_tail_d1;             m_coord[1]  =  0.0;
-            m_coord[2]  =  m_tail_d1 - m_tail_d4; m_coord[3]  =  m_tail_d3;
-            m_coord[4]  = -m_tail_d2 - m_tail_d4; m_coord[5]  =  m_tail_d3;
-            m_coord[6]  = -m_tail_d2;             m_coord[7]  =  0.0;
-            m_coord[8]  = -m_tail_d2 - m_tail_d4; m_coord[9]  = -m_tail_d3;
-            m_coord[10] =  m_tail_d1 - m_tail_d4; m_coord[11] = -m_tail_d3;
-
-            m_cmd[0] = path_cmd_move_to;
-            m_cmd[1] = path_cmd_line_to;
-            m_cmd[2] = path_cmd_line_to;
-            m_cmd[3] = path_cmd_line_to;
-            m_cmd[4] = path_cmd_line_to;
-            m_cmd[5] = path_cmd_line_to;
-            m_cmd[7] = path_cmd_end_poly | path_flags_close | path_flags_ccw;
-            m_cmd[6] = path_cmd_stop;
-            return;
-        }
-
-        if(path_id == 1)
-        {
-            if(!m_head_flag)
-            {
-                m_cmd[0] = path_cmd_stop;
-                return;
-            }
-            m_coord[0]  = -m_head_d1;            m_coord[1]  = 0.0;
-            m_coord[2]  = m_head_d2 + m_head_d4; m_coord[3]  = -m_head_d3;
-            m_coord[4]  = m_head_d2;             m_coord[5]  = 0.0;
-            m_coord[6]  = m_head_d2 + m_head_d4; m_coord[7]  = m_head_d3;
-
-            m_cmd[0] = path_cmd_move_to;
-            m_cmd[1] = path_cmd_line_to;
-            m_cmd[2] = path_cmd_line_to;
-            m_cmd[3] = path_cmd_line_to;
-            m_cmd[4] = path_cmd_end_poly | path_flags_close | path_flags_ccw;
-            m_cmd[5] = path_cmd_stop;
-            return;
-        }
-    }
-
-
-    //------------------------------------------------------------------------
-    unsigned arrowhead::vertex(double* x, double* y)
-    {
-        if(m_curr_id < 2)
-        {
-            unsigned curr_idx = m_curr_coord * 2;
-            *x = m_coord[curr_idx];
-            *y = m_coord[curr_idx + 1];
-            return m_cmd[m_curr_coord++];
-        }
-        return path_cmd_stop;
-    }
-
-}

Sources/libagg/agg-2.4/agg_arrowhead.h

@@ -1,82 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// Simple arrowhead/arrowtail generator 
-//
-//----------------------------------------------------------------------------
-#ifndef AGG_ARROWHEAD_INCLUDED
-#define AGG_ARROWHEAD_INCLUDED
-
-#include "agg_basics.h"
-
-namespace agg
-{
-
-    //===============================================================arrowhead
-    //
-    // See implementation agg_arrowhead.cpp 
-    //
-    class arrowhead
-    {
-    public:
-        arrowhead();
-
-        void head(double d1, double d2, double d3, double d4)
-        {
-            m_head_d1 = d1;
-            m_head_d2 = d2;
-            m_head_d3 = d3;
-            m_head_d4 = d4;
-            m_head_flag = true;
-        }
-
-        void head()    { m_head_flag = true; }
-        void no_head() { m_head_flag = false; }
-
-        void tail(double d1, double d2, double d3, double d4)
-        {
-            m_tail_d1 = d1;
-            m_tail_d2 = d2;
-            m_tail_d3 = d3;
-            m_tail_d4 = d4;
-            m_tail_flag = true;
-        }
-
-        void tail()    { m_tail_flag = true;  }
-        void no_tail() { m_tail_flag = false; }
-
-        void rewind(unsigned path_id);
-        unsigned vertex(double* x, double* y);
-
-    private:
-        double   m_head_d1;
-        double   m_head_d2;
-        double   m_head_d3;
-        double   m_head_d4;
-        double   m_tail_d1;
-        double   m_tail_d2;
-        double   m_tail_d3;
-        double   m_tail_d4;
-        bool     m_head_flag;
-        bool     m_tail_flag;
-        double   m_coord[16];
-        unsigned m_cmd[8];
-        unsigned m_curr_id;
-        unsigned m_curr_coord;
-    };
-
-}
-
-#endif

Sources/libagg/agg-2.4/agg_basics.h

@@ -1,530 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-
-#ifndef AGG_BASICS_INCLUDED
-#define AGG_BASICS_INCLUDED
-
-#include <math.h>
-#include "agg_config.h"
-
-//---------------------------------------------------------AGG_CUSTOM_ALLOCATOR
-#ifdef AGG_CUSTOM_ALLOCATOR
-#include "agg_allocator.h"
-#else
-namespace agg
-{
-    // The policy of all AGG containers and memory allocation strategy 
-    // in general is that no allocated data requires explicit construction.
-    // It means that the allocator can be really simple; you can even
-    // replace new/delete to malloc/free. The constructors and destructors 
-    // won't be called in this case, however everything will remain working. 
-    // The second argument of deallocate() is the size of the allocated 
-    // block. You can use this information if you wish.
-    //------------------------------------------------------------pod_allocator
-    template<class T> struct pod_allocator
-    {
-        static T*   allocate(unsigned num)       { return new T [num]; }
-        static void deallocate(T* ptr, unsigned) { delete [] ptr;      }
-    };
-
-    // Single object allocator. It's also can be replaced with your custom
-    // allocator. The difference is that it can only allocate a single 
-    // object and the constructor and destructor must be called. 
-    // In AGG there is no need to allocate an array of objects with
-    // calling their constructors (only single ones). So that, if you
-    // replace these new/delete to malloc/free make sure that the in-place
-    // new is called and take care of calling the destructor too.
-    //------------------------------------------------------------obj_allocator
-    template<class T> struct obj_allocator
-    {
-        static T*   allocate()         { return new T; }
-        static void deallocate(T* ptr) { delete ptr;   }
-    };
-}
-#endif
-
-
-//-------------------------------------------------------- Default basic types
-//
-// If the compiler has different capacity of the basic types you can redefine
-// them via the compiler command line or by generating agg_config.h that is
-// empty by default.
-//
-#ifndef AGG_INT8
-#define AGG_INT8 signed char
-#endif
-
-#ifndef AGG_INT8U
-#define AGG_INT8U unsigned char
-#endif
-
-#ifndef AGG_INT16
-#define AGG_INT16 short
-#endif
-
-#ifndef AGG_INT16U
-#define AGG_INT16U unsigned short
-#endif
-
-#ifndef AGG_INT32
-#define AGG_INT32 int
-#endif
-
-#ifndef AGG_INT32U
-#define AGG_INT32U unsigned
-#endif
-
-#ifndef AGG_INT64
-#if defined(_MSC_VER) || defined(__BORLANDC__)
-#define AGG_INT64 signed __int64
-#else
-#define AGG_INT64 signed long long
-#endif
-#endif
-
-#ifndef AGG_INT64U
-#if defined(_MSC_VER) || defined(__BORLANDC__)
-#define AGG_INT64U unsigned __int64
-#else
-#define AGG_INT64U unsigned long long
-#endif
-#endif
-
-//------------------------------------------------ Some fixes for MS Visual C++
-#if defined(_MSC_VER)
-#pragma warning(disable:4786) // Identifier was truncated...
-#endif
-
-#if defined(_MSC_VER)
-#define AGG_INLINE __forceinline
-#else
-#define AGG_INLINE inline
-#endif
-
-namespace agg
-{
-    //-------------------------------------------------------------------------
-    typedef AGG_INT8   int8;         //----int8
-    typedef AGG_INT8U  int8u;        //----int8u
-    typedef AGG_INT16  int16;        //----int16
-    typedef AGG_INT16U int16u;       //----int16u
-    typedef AGG_INT32  int32;        //----int32
-    typedef AGG_INT32U int32u;       //----int32u
-    typedef AGG_INT64  int64;        //----int64
-    typedef AGG_INT64U int64u;       //----int64u
-
-#if defined(AGG_FISTP)
-#pragma warning(push)
-#pragma warning(disable : 4035) //Disable warning "no return value"
-    AGG_INLINE int iround(double v)              //-------iround
-    {
-        int t;
-        __asm fld   qword ptr [v]
-        __asm fistp dword ptr [t]
-        __asm mov eax, dword ptr [t]
-    }
-    AGG_INLINE unsigned uround(double v)         //-------uround
-    {
-        unsigned t;
-        __asm fld   qword ptr [v]
-        __asm fistp dword ptr [t]
-        __asm mov eax, dword ptr [t]
-    }
-#pragma warning(pop)
-    AGG_INLINE unsigned ufloor(double v)         //-------ufloor
-    {
-        return unsigned(floor(v));
-    }
-    AGG_INLINE unsigned uceil(double v)          //--------uceil
-    {
-        return unsigned(ceil(v));
-    }
-#elif defined(AGG_QIFIST)
-    AGG_INLINE int iround(double v)
-    {
-        return int(v);
-    }
-    AGG_INLINE int uround(double v)
-    {
-        return unsigned(v);
-    }
-    AGG_INLINE unsigned ufloor(double v)
-    {
-        return unsigned(floor(v));
-    }
-    AGG_INLINE unsigned uceil(double v)
-    {
-        return unsigned(ceil(v));
-    }
-#else
-    AGG_INLINE int iround(double v)
-    {
-        return int((v < 0.0) ? v - 0.5 : v + 0.5);
-    }
-    AGG_INLINE int uround(double v)
-    {
-        return unsigned(v + 0.5);
-    }
-    AGG_INLINE unsigned ufloor(double v)
-    {
-        return unsigned(v);
-    }
-    AGG_INLINE unsigned uceil(double v)
-    {
-        return unsigned(ceil(v));
-    }
-#endif
-
-    //---------------------------------------------------------------saturation
-    template<int Limit> struct saturation
-    {
-        AGG_INLINE static int iround(double v)
-        {
-            if(v < double(-Limit)) return -Limit;
-            if(v > double( Limit)) return  Limit;
-            return agg::iround(v);
-        }
-    };
-
-    //------------------------------------------------------------------mul_one
-    template<unsigned Shift> struct mul_one
-    {
-        AGG_INLINE static unsigned mul(unsigned a, unsigned b)
-        {
-            register unsigned q = a * b + (1 << (Shift-1));
-            return (q + (q >> Shift)) >> Shift;
-        }
-    };
-
-    //-------------------------------------------------------------------------
-    typedef unsigned char cover_type;    //----cover_type
-    enum cover_scale_e
-    {
-        cover_shift = 8,                 //----cover_shift
-        cover_size  = 1 << cover_shift,  //----cover_size 
-        cover_mask  = cover_size - 1,    //----cover_mask 
-        cover_none  = 0,                 //----cover_none 
-        cover_full  = cover_mask         //----cover_full 
-    };
-
-    //----------------------------------------------------poly_subpixel_scale_e
-    // These constants determine the subpixel accuracy, to be more precise, 
-    // the number of bits of the fractional part of the coordinates. 
-    // The possible coordinate capacity in bits can be calculated by formula:
-    // sizeof(int) * 8 - poly_subpixel_shift, i.e, for 32-bit integers and
-    // 8-bits fractional part the capacity is 24 bits.
-    enum poly_subpixel_scale_e
-    {
-        poly_subpixel_shift = 8,                      //----poly_subpixel_shift
-        poly_subpixel_scale = 1<<poly_subpixel_shift, //----poly_subpixel_scale 
-        poly_subpixel_mask  = poly_subpixel_scale-1,  //----poly_subpixel_mask 
-    };
-
-    //----------------------------------------------------------filling_rule_e
-    enum filling_rule_e
-    {
-        fill_non_zero,
-        fill_even_odd
-    };
-
-    //-----------------------------------------------------------------------pi
-    const double pi = 3.14159265358979323846;
-
-    //------------------------------------------------------------------deg2rad
-    inline double deg2rad(double deg)
-    {
-        return deg * pi / 180.0;
-    }
-
-    //------------------------------------------------------------------rad2deg
-    inline double rad2deg(double rad)
-    {
-        return rad * 180.0 / pi;
-    }
- 
-    //----------------------------------------------------------------rect_base
-    template<class T> struct rect_base
-    {
-        typedef T            value_type;
-        typedef rect_base<T> self_type;
-        T x1, y1, x2, y2;
-
-        rect_base() {}
-        rect_base(T x1_, T y1_, T x2_, T y2_) :
-            x1(x1_), y1(y1_), x2(x2_), y2(y2_) {}
-
-        void init(T x1_, T y1_, T x2_, T y2_) 
-        {
-            x1 = x1_; y1 = y1_; x2 = x2_; y2 = y2_; 
-        }
-
-        const self_type& normalize()
-        {
-            T t;
-            if(x1 > x2) { t = x1; x1 = x2; x2 = t; }
-            if(y1 > y2) { t = y1; y1 = y2; y2 = t; }
-            return *this;
-        }
-
-        bool clip(const self_type& r)
-        {
-            if(x2 > r.x2) x2 = r.x2;
-            if(y2 > r.y2) y2 = r.y2;
-            if(x1 < r.x1) x1 = r.x1;
-            if(y1 < r.y1) y1 = r.y1;
-            return x1 <= x2 && y1 <= y2;
-        }
-
-        bool is_valid() const
-        {
-            return x1 <= x2 && y1 <= y2;
-        }
-
-        bool hit_test(T x, T y) const
-        {
-            return (x >= x1 && x <= x2 && y >= y1 && y <= y2);
-        }
-    };
-
-    //-----------------------------------------------------intersect_rectangles
-    template<class Rect> 
-    inline Rect intersect_rectangles(const Rect& r1, const Rect& r2)
-    {
-        Rect r = r1;
-
-        // First process x2,y2 because the other order 
-        // results in Internal Compiler Error under 
-        // Microsoft Visual C++ .NET 2003 69462-335-0000007-18038 in 
-        // case of "Maximize Speed" optimization option.
-        //-----------------
-        if(r.x2 > r2.x2) r.x2 = r2.x2; 
-        if(r.y2 > r2.y2) r.y2 = r2.y2;
-        if(r.x1 < r2.x1) r.x1 = r2.x1;
-        if(r.y1 < r2.y1) r.y1 = r2.y1;
-        return r;
-    }
-
-
-    //---------------------------------------------------------unite_rectangles
-    template<class Rect> 
-    inline Rect unite_rectangles(const Rect& r1, const Rect& r2)
-    {
-        Rect r = r1;
-        if(r.x2 < r2.x2) r.x2 = r2.x2;
-        if(r.y2 < r2.y2) r.y2 = r2.y2;
-        if(r.x1 > r2.x1) r.x1 = r2.x1;
-        if(r.y1 > r2.y1) r.y1 = r2.y1;
-        return r;
-    }
-
-    typedef rect_base<int>    rect_i; //----rect_i
-    typedef rect_base<float>  rect_f; //----rect_f
-    typedef rect_base<double> rect_d; //----rect_d
-
-    //---------------------------------------------------------path_commands_e
-    enum path_commands_e
-    {
-        path_cmd_stop     = 0,        //----path_cmd_stop    
-        path_cmd_move_to  = 1,        //----path_cmd_move_to 
-        path_cmd_line_to  = 2,        //----path_cmd_line_to 
-        path_cmd_curve3   = 3,        //----path_cmd_curve3  
-        path_cmd_curve4   = 4,        //----path_cmd_curve4  
-        path_cmd_curveN   = 5,        //----path_cmd_curveN
-        path_cmd_catrom   = 6,        //----path_cmd_catrom
-        path_cmd_ubspline = 7,        //----path_cmd_ubspline
-        path_cmd_end_poly = 0x0F,     //----path_cmd_end_poly
-        path_cmd_mask     = 0x0F      //----path_cmd_mask    
-    };
-
-    //------------------------------------------------------------path_flags_e
-    enum path_flags_e
-    {
-        path_flags_none  = 0,         //----path_flags_none 
-        path_flags_ccw   = 0x10,      //----path_flags_ccw  
-        path_flags_cw    = 0x20,      //----path_flags_cw   
-        path_flags_close = 0x40,      //----path_flags_close
-        path_flags_mask  = 0xF0       //----path_flags_mask 
-    };
-
-    //---------------------------------------------------------------is_vertex
-    inline bool is_vertex(unsigned c)
-    {
-        return c >= path_cmd_move_to && c < path_cmd_end_poly;
-    }
-
-    //--------------------------------------------------------------is_drawing
-    inline bool is_drawing(unsigned c)
-    {
-        return c >= path_cmd_line_to && c < path_cmd_end_poly;
-    }
-
-    //-----------------------------------------------------------------is_stop
-    inline bool is_stop(unsigned c)
-    { 
-        return c == path_cmd_stop;
-    }
-
-    //--------------------------------------------------------------is_move_to
-    inline bool is_move_to(unsigned c)
-    {
-        return c == path_cmd_move_to;
-    }
-
-    //--------------------------------------------------------------is_line_to
-    inline bool is_line_to(unsigned c)
-    {
-        return c == path_cmd_line_to;
-    }
-
-    //----------------------------------------------------------------is_curve
-    inline bool is_curve(unsigned c)
-    {
-        return c == path_cmd_curve3 || c == path_cmd_curve4;
-    }
-
-    //---------------------------------------------------------------is_curve3
-    inline bool is_curve3(unsigned c)
-    {
-        return c == path_cmd_curve3;
-    }
-
-    //---------------------------------------------------------------is_curve4
-    inline bool is_curve4(unsigned c)
-    {
-        return c == path_cmd_curve4;
-    }
-
-    //-------------------------------------------------------------is_end_poly
-    inline bool is_end_poly(unsigned c)
-    {
-        return (c & path_cmd_mask) == path_cmd_end_poly;
-    }
-
-    //----------------------------------------------------------------is_close
-    inline bool is_close(unsigned c)
-    {
-        return (c & ~(path_flags_cw | path_flags_ccw)) ==
-               (path_cmd_end_poly | path_flags_close); 
-    }
-
-    //------------------------------------------------------------is_next_poly
-    inline bool is_next_poly(unsigned c)
-    {
-        return is_stop(c) || is_move_to(c) || is_end_poly(c);
-    }
-
-    //-------------------------------------------------------------------is_cw
-    inline bool is_cw(unsigned c)
-    {
-        return (c & path_flags_cw) != 0;
-    }
-
-    //------------------------------------------------------------------is_ccw
-    inline bool is_ccw(unsigned c)
-    {
-        return (c & path_flags_ccw) != 0;
-    }
-
-    //-------------------------------------------------------------is_oriented
-    inline bool is_oriented(unsigned c)
-    {
-        return (c & (path_flags_cw | path_flags_ccw)) != 0; 
-    }
-
-    //---------------------------------------------------------------is_closed
-    inline bool is_closed(unsigned c)
-    {
-        return (c & path_flags_close) != 0; 
-    }
-
-    //----------------------------------------------------------get_close_flag
-    inline unsigned get_close_flag(unsigned c)
-    {
-        return c & path_flags_close; 
-    }
-
-    //-------------------------------------------------------clear_orientation
-    inline unsigned clear_orientation(unsigned c)
-    {
-        return c & ~(path_flags_cw | path_flags_ccw);
-    }
-
-    //---------------------------------------------------------get_orientation
-    inline unsigned get_orientation(unsigned c)
-    {
-        return c & (path_flags_cw | path_flags_ccw);
-    }
-
-    //---------------------------------------------------------set_orientation
-    inline unsigned set_orientation(unsigned c, unsigned o)
-    {
-        return clear_orientation(c) | o;
-    }
-
-    //--------------------------------------------------------------point_base
-    template<class T> struct point_base
-    {
-        typedef T value_type;
-        T x,y;
-        point_base() {}
-        point_base(T x_, T y_) : x(x_), y(y_) {}
-    };
-    typedef point_base<int>    point_i; //-----point_i
-    typedef point_base<float>  point_f; //-----point_f
-    typedef point_base<double> point_d; //-----point_d
-
-    //-------------------------------------------------------------vertex_base
-    template<class T> struct vertex_base
-    {
-        typedef T value_type;
-        T x,y;
-        unsigned cmd;
-        vertex_base() {}
-        vertex_base(T x_, T y_, unsigned cmd_) : x(x_), y(y_), cmd(cmd_) {}
-    };
-    typedef vertex_base<int>    vertex_i; //-----vertex_i
-    typedef vertex_base<float>  vertex_f; //-----vertex_f
-    typedef vertex_base<double> vertex_d; //-----vertex_d
-
-    //----------------------------------------------------------------row_info
-    template<class T> struct row_info
-    {
-        int x1, x2;
-        T* ptr;
-        row_info() {}
-        row_info(int x1_, int x2_, T* ptr_) : x1(x1_), x2(x2_), ptr(ptr_) {}
-    };
-
-    //----------------------------------------------------------const_row_info
-    template<class T> struct const_row_info
-    {
-        int x1, x2;
-        const T* ptr;
-        const_row_info() {}
-        const_row_info(int x1_, int x2_, const T* ptr_) : 
-            x1(x1_), x2(x2_), ptr(ptr_) {}
-    };
-
-    //------------------------------------------------------------is_equal_eps
-    template<class T> inline bool is_equal_eps(T v1, T v2, T epsilon)
-    {
-        return fabs(v1 - v2) <= double(epsilon);
-    }
-
-}
-
-
-#endif
-

Sources/libagg/agg-2.4/agg_bezier_arc.cpp

@@ -1,258 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// Arc generator. Produces at most 4 consecutive cubic bezier curves, i.e., 
-// 4, 7, 10, or 13 vertices.
-//
-//----------------------------------------------------------------------------
-
-
-#include <math.h>
-#include "agg_bezier_arc.h"
-
-
-namespace agg
-{
-
-    // This epsilon is used to prevent us from adding degenerate curves 
-    // (converging to a single point).
-    // The value isn't very critical. Function arc_to_bezier() has a limit 
-    // of the sweep_angle. If fabs(sweep_angle) exceeds pi/2 the curve 
-    // becomes inaccurate. But slight exceeding is quite appropriate.
-    //-------------------------------------------------bezier_arc_angle_epsilon
-    const double bezier_arc_angle_epsilon = 0.01;
-
-    //------------------------------------------------------------arc_to_bezier
-    void arc_to_bezier(double cx, double cy, double rx, double ry, 
-                       double start_angle, double sweep_angle,
-                       double* curve)
-    {
-        double x0 = cos(sweep_angle / 2.0);
-        double y0 = sin(sweep_angle / 2.0);
-        double tx = (1.0 - x0) * 4.0 / 3.0;
-        double ty = y0 - tx * x0 / y0;
-        double px[4];
-        double py[4];
-        px[0] =  x0;
-        py[0] = -y0;
-        px[1] =  x0 + tx;
-        py[1] = -ty;
-        px[2] =  x0 + tx;
-        py[2] =  ty;
-        px[3] =  x0;
-        py[3] =  y0;
-
-        double sn = sin(start_angle + sweep_angle / 2.0);
-        double cs = cos(start_angle + sweep_angle / 2.0);
-
-        unsigned i;
-        for(i = 0; i < 4; i++)
-        {
-            curve[i * 2]     = cx + rx * (px[i] * cs - py[i] * sn);
-            curve[i * 2 + 1] = cy + ry * (px[i] * sn + py[i] * cs);
-        }
-    }
-
-
-
-    //------------------------------------------------------------------------
-    void bezier_arc::init(double x,  double y, 
-                          double rx, double ry, 
-                          double start_angle, 
-                          double sweep_angle)
-    {
-        start_angle = fmod(start_angle, 2.0 * pi);
-        if(sweep_angle >=  2.0 * pi) sweep_angle =  2.0 * pi;
-        if(sweep_angle <= -2.0 * pi) sweep_angle = -2.0 * pi;
-
-        if(fabs(sweep_angle) < 1e-10)
-        {
-            m_num_vertices = 4;
-            m_cmd = path_cmd_line_to;
-            m_vertices[0] = x + rx * cos(start_angle);
-            m_vertices[1] = y + ry * sin(start_angle);
-            m_vertices[2] = x + rx * cos(start_angle + sweep_angle);
-            m_vertices[3] = y + ry * sin(start_angle + sweep_angle);
-            return;
-        }
-
-        double total_sweep = 0.0;
-        double local_sweep = 0.0;
-        double prev_sweep;
-        m_num_vertices = 2;
-        m_cmd = path_cmd_curve4;
-        bool done = false;
-        do
-        {
-            if(sweep_angle < 0.0)
-            {
-                prev_sweep  = total_sweep;
-                local_sweep = -pi * 0.5;
-                total_sweep -= pi * 0.5;
-                if(total_sweep <= sweep_angle + bezier_arc_angle_epsilon)
-                {
-                    local_sweep = sweep_angle - prev_sweep;
-                    done = true;
-                }
-            }
-            else
-            {
-                prev_sweep  = total_sweep;
-                local_sweep =  pi * 0.5;
-                total_sweep += pi * 0.5;
-                if(total_sweep >= sweep_angle - bezier_arc_angle_epsilon)
-                {
-                    local_sweep = sweep_angle - prev_sweep;
-                    done = true;
-                }
-            }
-
-            arc_to_bezier(x, y, rx, ry, 
-                          start_angle, 
-                          local_sweep, 
-                          m_vertices + m_num_vertices - 2);
-
-            m_num_vertices += 6;
-            start_angle += local_sweep;
-        }
-        while(!done && m_num_vertices < 26);
-    }
-
-
-
-
-    //--------------------------------------------------------------------
-    void bezier_arc_svg::init(double x0, double y0, 
-                              double rx, double ry, 
-                              double angle,
-                              bool large_arc_flag,
-                              bool sweep_flag,
-                              double x2, double y2)
-    {
-        m_radii_ok = true;
-
-        if(rx < 0.0) rx = -rx;
-        if(ry < 0.0) ry = -rx;
-
-        // Calculate the middle point between 
-        // the current and the final points
-        //------------------------
-        double dx2 = (x0 - x2) / 2.0;
-        double dy2 = (y0 - y2) / 2.0;
-
-        double cos_a = cos(angle);
-        double sin_a = sin(angle);
-
-        // Calculate (x1, y1)
-        //------------------------
-        double x1 =  cos_a * dx2 + sin_a * dy2;
-        double y1 = -sin_a * dx2 + cos_a * dy2;
-
-        // Ensure radii are large enough
-        //------------------------
-        double prx = rx * rx;
-        double pry = ry * ry;
-        double px1 = x1 * x1;
-        double py1 = y1 * y1;
-
-        // Check that radii are large enough
-        //------------------------
-        double radii_check = px1/prx + py1/pry;
-        if(radii_check > 1.0) 
-        {
-            rx = sqrt(radii_check) * rx;
-            ry = sqrt(radii_check) * ry;
-            prx = rx * rx;
-            pry = ry * ry;
-            if(radii_check > 10.0) m_radii_ok = false;
-        }
-
-        // Calculate (cx1, cy1)
-        //------------------------
-        double sign = (large_arc_flag == sweep_flag) ? -1.0 : 1.0;
-        double sq   = (prx*pry - prx*py1 - pry*px1) / (prx*py1 + pry*px1);
-        double coef = sign * sqrt((sq < 0) ? 0 : sq);
-        double cx1  = coef *  ((rx * y1) / ry);
-        double cy1  = coef * -((ry * x1) / rx);
-
-        //
-        // Calculate (cx, cy) from (cx1, cy1)
-        //------------------------
-        double sx2 = (x0 + x2) / 2.0;
-        double sy2 = (y0 + y2) / 2.0;
-        double cx = sx2 + (cos_a * cx1 - sin_a * cy1);
-        double cy = sy2 + (sin_a * cx1 + cos_a * cy1);
-
-        // Calculate the start_angle (angle1) and the sweep_angle (dangle)
-        //------------------------
-        double ux =  (x1 - cx1) / rx;
-        double uy =  (y1 - cy1) / ry;
-        double vx = (-x1 - cx1) / rx;
-        double vy = (-y1 - cy1) / ry;
-        double p, n;
-
-        // Calculate the angle start
-        //------------------------
-        n = sqrt(ux*ux + uy*uy);
-        p = ux; // (1 * ux) + (0 * uy)
-        sign = (uy < 0) ? -1.0 : 1.0;
-        double v = p / n;
-        if(v < -1.0) v = -1.0;
-        if(v >  1.0) v =  1.0;
-        double start_angle = sign * acos(v);
-
-        // Calculate the sweep angle
-        //------------------------
-        n = sqrt((ux*ux + uy*uy) * (vx*vx + vy*vy));
-        p = ux * vx + uy * vy;
-        sign = (ux * vy - uy * vx < 0) ? -1.0 : 1.0;
-        v = p / n;
-        if(v < -1.0) v = -1.0;
-        if(v >  1.0) v =  1.0;
-        double sweep_angle = sign * acos(v);
-        if(!sweep_flag && sweep_angle > 0) 
-        {
-            sweep_angle -= pi * 2.0;
-        } 
-        else 
-        if (sweep_flag && sweep_angle < 0) 
-        {
-            sweep_angle += pi * 2.0;
-        }
-
-        // We can now build and transform the resulting arc
-        //------------------------
-        m_arc.init(0.0, 0.0, rx, ry, start_angle, sweep_angle);
-        trans_affine mtx = trans_affine_rotation(angle);
-        mtx *= trans_affine_translation(cx, cy);
-        
-        for(unsigned i = 2; i < m_arc.num_vertices()-2; i += 2)
-        {
-            mtx.transform(m_arc.vertices() + i, m_arc.vertices() + i + 1);
-        }
-
-        // We must make sure that the starting and ending points
-        // exactly coincide with the initial (x0,y0) and (x2,y2)
-        m_arc.vertices()[0] = x0;
-        m_arc.vertices()[1] = y0;
-        if(m_arc.num_vertices() > 2)
-        {
-            m_arc.vertices()[m_arc.num_vertices() - 2] = x2;
-            m_arc.vertices()[m_arc.num_vertices() - 1] = y2;
-        }
-    }
-
-
-}

Sources/libagg/agg-2.4/agg_bezier_arc.h

@@ -1,159 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// Arc generator. Produces at most 4 consecutive cubic bezier curves, i.e., 
-// 4, 7, 10, or 13 vertices.
-//
-//----------------------------------------------------------------------------
-
-#ifndef AGG_BEZIER_ARC_INCLUDED
-#define AGG_BEZIER_ARC_INCLUDED
-
-#include "agg_conv_transform.h"
-
-namespace agg
-{
-
-    //-----------------------------------------------------------------------
-    void arc_to_bezier(double cx, double cy, double rx, double ry, 
-                       double start_angle, double sweep_angle,
-                       double* curve);
-
-
-    //==============================================================bezier_arc
-    // 
-    // See implemantaion agg_bezier_arc.cpp
-    //
-    class bezier_arc
-    {
-    public:
-        //--------------------------------------------------------------------
-        bezier_arc() : m_vertex(26), m_num_vertices(0), m_cmd(path_cmd_line_to) {}
-        bezier_arc(double x,  double y, 
-                   double rx, double ry, 
-                   double start_angle, 
-                   double sweep_angle)
-        {
-            init(x, y, rx, ry, start_angle, sweep_angle);
-        }
-
-        //--------------------------------------------------------------------
-        void init(double x,  double y, 
-                  double rx, double ry, 
-                  double start_angle, 
-                  double sweep_angle);
-
-        //--------------------------------------------------------------------
-        void rewind(unsigned)
-        {
-            m_vertex = 0;
-        }
-
-        //--------------------------------------------------------------------
-        unsigned vertex(double* x, double* y)
-        {
-            if(m_vertex >= m_num_vertices) return path_cmd_stop;
-            *x = m_vertices[m_vertex];
-            *y = m_vertices[m_vertex + 1];
-            m_vertex += 2;
-            return (m_vertex == 2) ? path_cmd_move_to : m_cmd;
-        }
-
-        // Supplemantary functions. num_vertices() actually returns doubled 
-        // number of vertices. That is, for 1 vertex it returns 2.
-        //--------------------------------------------------------------------
-        unsigned  num_vertices() const { return m_num_vertices; }
-        const double* vertices() const { return m_vertices;     }
-        double*       vertices()       { return m_vertices;     }
- 
-    private:
-        unsigned m_vertex;
-        unsigned m_num_vertices;
-        double   m_vertices[26];
-        unsigned m_cmd;
-    };
-
-
-
-    //==========================================================bezier_arc_svg
-    // Compute an SVG-style bezier arc. 
-    //
-    // Computes an elliptical arc from (x1, y1) to (x2, y2). The size and 
-    // orientation of the ellipse are defined by two radii (rx, ry) 
-    // and an x-axis-rotation, which indicates how the ellipse as a whole 
-    // is rotated relative to the current coordinate system. The center 
-    // (cx, cy) of the ellipse is calculated automatically to satisfy the 
-    // constraints imposed by the other parameters. 
-    // large-arc-flag and sweep-flag contribute to the automatic calculations 
-    // and help determine how the arc is drawn.
-    class bezier_arc_svg
-    {
-    public:
-        //--------------------------------------------------------------------
-        bezier_arc_svg() : m_arc(), m_radii_ok(false) {}
-
-        bezier_arc_svg(double x1, double y1, 
-                       double rx, double ry, 
-                       double angle,
-                       bool large_arc_flag,
-                       bool sweep_flag,
-                       double x2, double y2) : 
-            m_arc(), m_radii_ok(false)
-        {
-            init(x1, y1, rx, ry, angle, large_arc_flag, sweep_flag, x2, y2);
-        }
-
-        //--------------------------------------------------------------------
-        void init(double x1, double y1, 
-                  double rx, double ry, 
-                  double angle,
-                  bool large_arc_flag,
-                  bool sweep_flag,
-                  double x2, double y2);
-
-        //--------------------------------------------------------------------
-        bool radii_ok() const { return m_radii_ok; }
-
-        //--------------------------------------------------------------------
-        void rewind(unsigned)
-        {
-            m_arc.rewind(0);
-        }
-
-        //--------------------------------------------------------------------
-        unsigned vertex(double* x, double* y)
-        {
-            return m_arc.vertex(x, y);
-        }
-
-        // Supplemantary functions. num_vertices() actually returns doubled 
-        // number of vertices. That is, for 1 vertex it returns 2.
-        //--------------------------------------------------------------------
-        unsigned  num_vertices() const { return m_arc.num_vertices(); }
-        const double* vertices() const { return m_arc.vertices();     }
-        double*       vertices()       { return m_arc.vertices();     }
-
-    private:
-        bezier_arc m_arc;
-        bool       m_radii_ok;
-    };
-
-
-
-
-}
-
-
-#endif

Sources/libagg/agg-2.4/agg_bitset_iterator.h

@@ -1,54 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-
-#ifndef AGG_BITSET_ITERATOR_INCLUDED
-#define AGG_BITSET_ITERATOR_INCLUDED
-
-#include "agg_basics.h"
-
-namespace agg
-{
-    
-    class bitset_iterator
-    {
-    public:
-        bitset_iterator(const int8u* bits, unsigned offset = 0) :
-            m_bits(bits + (offset >> 3)),
-            m_mask(0x80 >> (offset & 7))
-        {}
-
-        void operator ++ ()
-        {
-            m_mask >>= 1;
-            if(m_mask == 0)
-            {
-                ++m_bits;
-                m_mask = 0x80;
-            }
-        }
-
-        unsigned bit() const
-        {
-            return (*m_bits) & m_mask;
-        }
-
-    private:
-        const int8u* m_bits;
-        int8u        m_mask;
-    };
-
-}
-
-#endif

Sources/libagg/agg-2.4/agg_bounding_rect.h

@@ -1,116 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// bounding_rect function template
-//
-//----------------------------------------------------------------------------
-#ifndef AGG_BOUNDING_RECT_INCLUDED
-#define AGG_BOUNDING_RECT_INCLUDED
-
-#include "agg_basics.h"
-
-namespace agg
-{
-
-    //-----------------------------------------------------------bounding_rect
-    template<class VertexSource, class GetId, class CoordT>
-    bool bounding_rect(VertexSource& vs, GetId& gi, 
-                       unsigned start, unsigned num, 
-                       CoordT* x1, CoordT* y1, CoordT* x2, CoordT* y2)
-    {
-        unsigned i;
-        double x;
-        double y;
-        bool first = true;
-
-        *x1 = CoordT(1);
-        *y1 = CoordT(1);
-        *x2 = CoordT(0);
-        *y2 = CoordT(0);
-
-        for(i = 0; i < num; i++)
-        {
-            vs.rewind(gi[start + i]);
-            unsigned cmd;
-            while(!is_stop(cmd = vs.vertex(&x, &y)))
-            {
-                if(is_vertex(cmd))
-                {
-                    if(first)
-                    {
-                        *x1 = CoordT(x);
-                        *y1 = CoordT(y);
-                        *x2 = CoordT(x);
-                        *y2 = CoordT(y);
-                        first = false;
-                    }
-                    else
-                    {
-                        if(CoordT(x) < *x1) *x1 = CoordT(x);
-                        if(CoordT(y) < *y1) *y1 = CoordT(y);
-                        if(CoordT(x) > *x2) *x2 = CoordT(x);
-                        if(CoordT(y) > *y2) *y2 = CoordT(y);
-                    }
-                }
-            }
-        }
-        return *x1 <= *x2 && *y1 <= *y2;
-    }
-
-
-    //-----------------------------------------------------bounding_rect_single
-    template<class VertexSource, class CoordT> 
-    bool bounding_rect_single(VertexSource& vs, unsigned path_id,
-                              CoordT* x1, CoordT* y1, CoordT* x2, CoordT* y2)
-    {
-        double x;
-        double y;
-        bool first = true;
-
-        *x1 = CoordT(1);
-        *y1 = CoordT(1);
-        *x2 = CoordT(0);
-        *y2 = CoordT(0);
-
-        vs.rewind(path_id);
-        unsigned cmd;
-        while(!is_stop(cmd = vs.vertex(&x, &y)))
-        {
-            if(is_vertex(cmd))
-            {
-                if(first)
-                {
-                    *x1 = CoordT(x);
-                    *y1 = CoordT(y);
-                    *x2 = CoordT(x);
-                    *y2 = CoordT(y);
-                    first = false;
-                }
-                else
-                {
-                    if(CoordT(x) < *x1) *x1 = CoordT(x);
-                    if(CoordT(y) < *y1) *y1 = CoordT(y);
-                    if(CoordT(x) > *x2) *x2 = CoordT(x);
-                    if(CoordT(y) > *y2) *y2 = CoordT(y);
-                }
-            }
-        }
-        return *x1 <= *x2 && *y1 <= *y2;
-    }
-
-
-}
-
-#endif

Sources/libagg/agg-2.4/agg_bspline.cpp

@@ -1,284 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// class bspline
-//
-//----------------------------------------------------------------------------
-
-#include "agg_bspline.h"
-
-namespace agg
-{
-    //------------------------------------------------------------------------
-    bspline::bspline() :
-        m_max(0),
-        m_num(0),
-        m_x(0),
-        m_y(0),
-        m_last_idx(-1)
-    {
-    }
-
-    //------------------------------------------------------------------------
-    bspline::bspline(int num) :
-        m_max(0),
-        m_num(0),
-        m_x(0),
-        m_y(0),
-        m_last_idx(-1)
-    {
-        init(num);
-    }
-
-    //------------------------------------------------------------------------
-    bspline::bspline(int num, const double* x, const double* y) :
-        m_max(0),
-        m_num(0),
-        m_x(0),
-        m_y(0),
-        m_last_idx(-1)
-    {
-        init(num, x, y);
-    }
-
-    
-    //------------------------------------------------------------------------
-    void bspline::init(int max)
-    {
-        if(max > 2 && max > m_max)
-        {
-            m_am.resize(max * 3);
-            m_max = max;
-            m_x   = &m_am[m_max];
-            m_y   = &m_am[m_max * 2];
-        }
-        m_num = 0;
-        m_last_idx = -1;
-    }
-
-
-    //------------------------------------------------------------------------
-    void bspline::add_point(double x, double y)
-    {
-        if(m_num < m_max)
-        {
-            m_x[m_num] = x;
-            m_y[m_num] = y;
-            ++m_num;
-        }
-    }
-
-
-    //------------------------------------------------------------------------
-    void bspline::prepare()
-    {
-        if(m_num > 2)
-        {
-            int i, k, n1;
-            double* temp; 
-            double* r; 
-            double* s;
-            double h, p, d, f, e;
-    
-            for(k = 0; k < m_num; k++) 
-            {
-                m_am[k] = 0.0;
-            }
-
-            n1 = 3 * m_num;
-
-            pod_array<double> al(n1);
-            temp = &al[0];
-
-            for(k = 0; k < n1; k++) 
-            {
-                temp[k] = 0.0;
-            }
-
-            r = temp + m_num;
-            s = temp + m_num * 2;
-
-            n1 = m_num - 1;
-            d = m_x[1] - m_x[0];
-            e = (m_y[1] - m_y[0]) / d;
-
-            for(k = 1; k < n1; k++) 
-            {
-                h     = d;
-                d     = m_x[k + 1] - m_x[k];
-                f     = e;
-                e     = (m_y[k + 1] - m_y[k]) / d;
-                al[k] = d / (d + h);
-                r[k]  = 1.0 - al[k];
-                s[k]  = 6.0 * (e - f) / (h + d);
-            }
-
-            for(k = 1; k < n1; k++) 
-            {
-                p = 1.0 / (r[k] * al[k - 1] + 2.0);
-                al[k] *= -p;
-                s[k] = (s[k] - r[k] * s[k - 1]) * p; 
-            }
-
-            m_am[n1]     = 0.0;
-            al[n1 - 1]   = s[n1 - 1];
-            m_am[n1 - 1] = al[n1 - 1];
-
-            for(k = n1 - 2, i = 0; i < m_num - 2; i++, k--) 
-            {
-                al[k]   = al[k] * al[k + 1] + s[k];
-                m_am[k] = al[k];
-            }
-        }
-        m_last_idx = -1;
-    }
-
-
-
-    //------------------------------------------------------------------------
-    void bspline::init(int num, const double* x, const double* y)
-    {
-        if(num > 2)
-        {
-            init(num);
-            int i;
-            for(i = 0; i < num; i++)
-            {
-                add_point(*x++, *y++);
-            }
-            prepare();
-        }
-        m_last_idx = -1;
-    }
-
-
-    //------------------------------------------------------------------------
-    void bspline::bsearch(int n, const double *x, double x0, int *i) 
-    {
-        int j = n - 1;
-        int k;
-          
-        for(*i = 0; (j - *i) > 1; ) 
-        {
-            if(x0 < x[k = (*i + j) >> 1]) j = k; 
-            else                         *i = k;
-        }
-    }
-
-
-
-    //------------------------------------------------------------------------
-    double bspline::interpolation(double x, int i) const
-    {
-        int j = i + 1;
-        double d = m_x[i] - m_x[j];
-        double h = x - m_x[j];
-        double r = m_x[i] - x;
-        double p = d * d / 6.0;
-        return (m_am[j] * r * r * r + m_am[i] * h * h * h) / 6.0 / d +
-               ((m_y[j] - m_am[j] * p) * r + (m_y[i] - m_am[i] * p) * h) / d;
-    }
-
-
-    //------------------------------------------------------------------------
-    double bspline::extrapolation_left(double x) const
-    {
-        double d = m_x[1] - m_x[0];
-        return (-d * m_am[1] / 6 + (m_y[1] - m_y[0]) / d) * 
-               (x - m_x[0]) + 
-               m_y[0];
-    }
-
-    //------------------------------------------------------------------------
-    double bspline::extrapolation_right(double x) const
-    {
-        double d = m_x[m_num - 1] - m_x[m_num - 2];
-        return (d * m_am[m_num - 2] / 6 + (m_y[m_num - 1] - m_y[m_num - 2]) / d) * 
-               (x - m_x[m_num - 1]) + 
-               m_y[m_num - 1];
-    }
-
-    //------------------------------------------------------------------------
-    double bspline::get(double x) const
-    {
-        if(m_num > 2)
-        {
-            int i;
-
-            // Extrapolation on the left
-            if(x < m_x[0]) return extrapolation_left(x);
-
-            // Extrapolation on the right
-            if(x >= m_x[m_num - 1]) return extrapolation_right(x);
-
-            // Interpolation
-            bsearch(m_num, m_x, x, &i);
-            return interpolation(x, i);
-        }
-        return 0.0;
-    }
-
-
-    //------------------------------------------------------------------------
-    double bspline::get_stateful(double x) const
-    {
-        if(m_num > 2)
-        {
-            // Extrapolation on the left
-            if(x < m_x[0]) return extrapolation_left(x);
-
-            // Extrapolation on the right
-            if(x >= m_x[m_num - 1]) return extrapolation_right(x);
-
-            if(m_last_idx >= 0)
-            {
-                // Check if x is not in current range
-                if(x < m_x[m_last_idx] || x > m_x[m_last_idx + 1])
-                {
-                    // Check if x between next points (most probably)
-                    if(m_last_idx < m_num - 2 && 
-                       x >= m_x[m_last_idx + 1] &&
-                       x <= m_x[m_last_idx + 2])
-                    {
-                        ++m_last_idx;
-                    }
-                    else
-                    if(m_last_idx > 0 && 
-                       x >= m_x[m_last_idx - 1] && 
-                       x <= m_x[m_last_idx])
-                    {
-                        // x is between pevious points
-                        --m_last_idx;
-                    }
-                    else
-                    {
-                        // Else perform full search
-                        bsearch(m_num, m_x, x, &m_last_idx);
-                    }
-                }
-                return interpolation(x, m_last_idx);
-            }
-            else
-            {
-                // Interpolation
-                bsearch(m_num, m_x, x, &m_last_idx);
-                return interpolation(x, m_last_idx);
-            }
-        }
-        return 0.0;
-    }
-
-}
-

Sources/libagg/agg-2.4/agg_bspline.h

@@ -1,76 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// class bspline
-//
-//----------------------------------------------------------------------------
-
-#ifndef AGG_BSPLINE_INCLUDED
-#define AGG_BSPLINE_INCLUDED
-
-#include "agg_array.h"
-
-namespace agg
-{
-    //----------------------------------------------------------------bspline
-    // A very simple class of Bi-cubic Spline interpolation.
-    // First call init(num, x[], y[]) where num - number of source points, 
-    // x, y - arrays of X and Y values respectively. Here Y must be a function 
-    // of X. It means that all the X-coordinates must be arranged in the ascending
-    // order. 
-    // Then call get(x) that calculates a value Y for the respective X. 
-    // The class supports extrapolation, i.e. you can call get(x) where x is
-    // outside the given with init() X-range. Extrapolation is a simple linear 
-    // function.
-    //
-    //  See Implementation agg_bspline.cpp
-    //------------------------------------------------------------------------
-    class bspline 
-    {
-    public:
-        bspline();
-        bspline(int num);
-        bspline(int num, const double* x, const double* y);
-
-        void   init(int num);
-        void   add_point(double x, double y);
-        void   prepare();
-
-        void   init(int num, const double* x, const double* y);
-
-        double get(double x) const;
-        double get_stateful(double x) const;
-    
-    private:
-        bspline(const bspline&);
-        const bspline& operator = (const bspline&);
-
-        static void bsearch(int n, const double *x, double x0, int *i);
-        double extrapolation_left(double x) const;
-        double extrapolation_right(double x) const;
-        double interpolation(double x, int i) const;
-
-        int               m_max;
-        int               m_num;
-        double*           m_x;
-        double*           m_y;
-        pod_array<double> m_am;
-        mutable int       m_last_idx;
-    };
-
-
-}
-
-#endif

Sources/libagg/agg-2.4/agg_clip_liang_barsky.h

@@ -1,333 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// Liang-Barsky clipping 
-//
-//----------------------------------------------------------------------------
-#ifndef AGG_CLIP_LIANG_BARSKY_INCLUDED
-#define AGG_CLIP_LIANG_BARSKY_INCLUDED
-
-#include "agg_basics.h"
-
-namespace agg
-{
-
-    //------------------------------------------------------------------------
-    enum clipping_flags_e
-    {
-        clipping_flags_x1_clipped = 4,
-        clipping_flags_x2_clipped = 1,
-        clipping_flags_y1_clipped = 8,
-        clipping_flags_y2_clipped = 2,
-        clipping_flags_x_clipped = clipping_flags_x1_clipped | clipping_flags_x2_clipped,
-        clipping_flags_y_clipped = clipping_flags_y1_clipped | clipping_flags_y2_clipped
-    };
-
-    //----------------------------------------------------------clipping_flags
-    // Determine the clipping code of the vertex according to the 
-    // Cyrus-Beck line clipping algorithm
-    //
-    //        |        |
-    //  0110  |  0010  | 0011
-    //        |        |
-    // -------+--------+-------- clip_box.y2
-    //        |        |
-    //  0100  |  0000  | 0001
-    //        |        |
-    // -------+--------+-------- clip_box.y1
-    //        |        |
-    //  1100  |  1000  | 1001
-    //        |        |
-    //  clip_box.x1  clip_box.x2
-    //
-    // 
-    template<class T>
-    inline unsigned clipping_flags(T x, T y, const rect_base<T>& clip_box)
-    {
-        return  (x > clip_box.x2) |
-               ((y > clip_box.y2) << 1) |
-               ((x < clip_box.x1) << 2) |
-               ((y < clip_box.y1) << 3);
-    }
-
-    //--------------------------------------------------------clipping_flags_x
-    template<class T>
-    inline unsigned clipping_flags_x(T x, const rect_base<T>& clip_box)
-    {
-        return  (x > clip_box.x2) | ((x < clip_box.x1) << 2);
-    }
-
-
-    //--------------------------------------------------------clipping_flags_y
-    template<class T>
-    inline unsigned clipping_flags_y(T y, const rect_base<T>& clip_box)
-    {
-        return ((y > clip_box.y2) << 1) | ((y < clip_box.y1) << 3);
-    }
-
-
-    //-------------------------------------------------------clip_liang_barsky
-    template<class T>
-    inline unsigned clip_liang_barsky(T x1, T y1, T x2, T y2,
-                                      const rect_base<T>& clip_box,
-                                      T* x, T* y)
-    {
-        const double nearzero = 1e-30;
-
-        double deltax = x2 - x1;
-        double deltay = y2 - y1; 
-        double xin;
-        double xout;
-        double yin;
-        double yout;
-        double tinx;
-        double tiny;
-        double toutx;
-        double touty;  
-        double tin1;
-        double tin2;
-        double tout1;
-        unsigned np = 0;
-
-        if(deltax == 0.0) 
-        {   
-            // bump off of the vertical
-            deltax = (x1 > clip_box.x1) ? -nearzero : nearzero;
-        }
-
-        if(deltay == 0.0) 
-        { 
-            // bump off of the horizontal 
-            deltay = (y1 > clip_box.y1) ? -nearzero : nearzero;
-        }
-        
-        if(deltax > 0.0) 
-        {                
-            // points to right
-            xin  = clip_box.x1;
-            xout = clip_box.x2;
-        }
-        else 
-        {
-            xin  = clip_box.x2;
-            xout = clip_box.x1;
-        }
-
-        if(deltay > 0.0) 
-        {
-            // points up
-            yin  = clip_box.y1;
-            yout = clip_box.y2;
-        }
-        else 
-        {
-            yin  = clip_box.y2;
-            yout = clip_box.y1;
-        }
-        
-        tinx = (xin - x1) / deltax;
-        tiny = (yin - y1) / deltay;
-        
-        if (tinx < tiny) 
-        {
-            // hits x first
-            tin1 = tinx;
-            tin2 = tiny;
-        }
-        else
-        {
-            // hits y first
-            tin1 = tiny;
-            tin2 = tinx;
-        }
-        
-        if(tin1 <= 1.0) 
-        {
-            if(0.0 < tin1) 
-            {
-                *x++ = (T)xin;
-                *y++ = (T)yin;
-                ++np;
-            }
-
-            if(tin2 <= 1.0)
-            {
-                toutx = (xout - x1) / deltax;
-                touty = (yout - y1) / deltay;
-                
-                tout1 = (toutx < touty) ? toutx : touty;
-                
-                if(tin2 > 0.0 || tout1 > 0.0) 
-                {
-                    if(tin2 <= tout1) 
-                    {
-                        if(tin2 > 0.0) 
-                        {
-                            if(tinx > tiny) 
-                            {
-                                *x++ = (T)xin;
-                                *y++ = (T)(y1 + tinx * deltay);
-                            }
-                            else 
-                            {
-                                *x++ = (T)(x1 + tiny * deltax);
-                                *y++ = (T)yin;
-                            }
-                            ++np;
-                        }
-
-                        if(tout1 < 1.0) 
-                        {
-                            if(toutx < touty) 
-                            {
-                                *x++ = (T)xout;
-                                *y++ = (T)(y1 + toutx * deltay);
-                            }
-                            else 
-                            {
-                                *x++ = (T)(x1 + touty * deltax);
-                                *y++ = (T)yout;
-                            }
-                        }
-                        else 
-                        {
-                            *x++ = x2;
-                            *y++ = y2;
-                        }
-                        ++np;
-                    }
-                    else 
-                    {
-                        if(tinx > tiny) 
-                        {
-                            *x++ = (T)xin;
-                            *y++ = (T)yout;
-                        }
-                        else 
-                        {
-                            *x++ = (T)xout;
-                            *y++ = (T)yin;
-                        }
-                        ++np;
-                    }
-                }
-            }
-        }
-        return np;
-    }
-
-
-    //----------------------------------------------------------------------------
-    template<class T>
-    bool clip_move_point(T x1, T y1, T x2, T y2, 
-                         const rect_base<T>& clip_box, 
-                         T* x, T* y, unsigned flags)
-    {
-       T bound;
-
-       if(flags & clipping_flags_x_clipped)
-       {
-           if(x1 == x2)
-           {
-               return false;
-           }
-           bound = (flags & clipping_flags_x1_clipped) ? clip_box.x1 : clip_box.x2;
-           *y = (T)(double(bound - x1) * (y2 - y1) / (x2 - x1) + y1);
-           *x = bound;
-       }
-
-       flags = clipping_flags_y(*y, clip_box);
-       if(flags & clipping_flags_y_clipped)
-       {
-           if(y1 == y2)
-           {
-               return false;
-           }
-           bound = (flags & clipping_flags_y1_clipped) ? clip_box.y1 : clip_box.y2;
-           *x = (T)(double(bound - y1) * (x2 - x1) / (y2 - y1) + x1);
-           *y = bound;
-       }
-       return true;
-    }
-
-    //-------------------------------------------------------clip_line_segment
-    // Returns: ret >= 4        - Fully clipped
-    //          (ret & 1) != 0  - First point has been moved
-    //          (ret & 2) != 0  - Second point has been moved
-    //
-    template<class T>
-    unsigned clip_line_segment(T* x1, T* y1, T* x2, T* y2,
-                               const rect_base<T>& clip_box)
-    {
-        unsigned f1 = clipping_flags(*x1, *y1, clip_box);
-        unsigned f2 = clipping_flags(*x2, *y2, clip_box);
-        unsigned ret = 0;
-
-        if((f2 | f1) == 0)
-        {
-            // Fully visible
-            return 0;
-        }
-
-        if((f1 & clipping_flags_x_clipped) != 0 && 
-           (f1 & clipping_flags_x_clipped) == (f2 & clipping_flags_x_clipped))
-        {
-            // Fully clipped
-            return 4;
-        }
-
-        if((f1 & clipping_flags_y_clipped) != 0 && 
-           (f1 & clipping_flags_y_clipped) == (f2 & clipping_flags_y_clipped))
-        {
-            // Fully clipped
-            return 4;
-        }
-
-        T tx1 = *x1;
-        T ty1 = *y1;
-        T tx2 = *x2;
-        T ty2 = *y2;
-        if(f1) 
-        {   
-            if(!clip_move_point(tx1, ty1, tx2, ty2, clip_box, x1, y1, f1)) 
-            {
-                return 4;
-            }
-            if(*x1 == *x2 && *y1 == *y2) 
-            {
-                return 4;
-            }
-            ret |= 1;
-        }
-        if(f2) 
-        {
-            if(!clip_move_point(tx1, ty1, tx2, ty2, clip_box, x2, y2, f2))
-            {
-                return 4;
-            }
-            if(*x1 == *x2 && *y1 == *y2) 
-            {
-                return 4;
-            }
-            ret |= 2;
-        }
-        return ret;
-    }
-
-
-}
-
-
-#endif

Sources/libagg/agg-2.4/agg_color_gray.h

@@ -1,414 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// Adaptation for high precision colors has been sponsored by 
-// Liberty Technology Systems, Inc., visit http://lib-sys.com
-//
-// Liberty Technology Systems, Inc. is the provider of
-// PostScript and PDF technology for software developers.
-// 
-//----------------------------------------------------------------------------
-//
-// color types gray8, gray16
-//
-//----------------------------------------------------------------------------
-
-#ifndef AGG_COLOR_GRAY_INCLUDED
-#define AGG_COLOR_GRAY_INCLUDED
-
-#include "agg_basics.h"
-#include "agg_color_rgba.h"
-
-namespace agg
-{
-
-    //===================================================================gray8
-    struct gray8
-    {
-        typedef int8u  value_type;
-        typedef int32u calc_type;
-        typedef int32  long_type;
-        enum base_scale_e
-        {
-            base_shift = 8,
-            base_scale = 1 << base_shift,
-            base_mask  = base_scale - 1
-        };
-        typedef gray8 self_type;
-
-        value_type v;
-        value_type a;
-
-        //--------------------------------------------------------------------
-        gray8() {}
-
-        //--------------------------------------------------------------------
-        gray8(unsigned v_, unsigned a_=base_mask) :
-            v(int8u(v_)), a(int8u(a_)) {}
-
-        //--------------------------------------------------------------------
-        gray8(const self_type& c, unsigned a_) :
-            v(c.v), a(value_type(a_)) {}
-
-        //--------------------------------------------------------------------
-        gray8(const rgba& c) :
-            v((value_type)uround((0.299*c.r + 0.587*c.g + 0.114*c.b) * double(base_mask))),
-            a((value_type)uround(c.a * double(base_mask))) {}
-
-        //--------------------------------------------------------------------
-        gray8(const rgba& c, double a_) :
-            v((value_type)uround((0.299*c.r + 0.587*c.g + 0.114*c.b) * double(base_mask))),
-            a((value_type)uround(a_ * double(base_mask))) {}
-
-        //--------------------------------------------------------------------
-        gray8(const rgba8& c) :
-            v((c.r*77 + c.g*150 + c.b*29) >> 8),
-            a(c.a) {}
-
-        //--------------------------------------------------------------------
-        gray8(const rgba8& c, unsigned a_) :
-            v((c.r*77 + c.g*150 + c.b*29) >> 8),
-            a(a_) {}
-
-        //--------------------------------------------------------------------
-        void clear()
-        {
-            v = a = 0;
-        }
-
-        //--------------------------------------------------------------------
-        const self_type& transparent()
-        {
-            a = 0;
-            return *this;
-        }
-
-        //--------------------------------------------------------------------
-        void opacity(double a_)
-        {
-            if(a_ < 0.0) a_ = 0.0;
-            if(a_ > 1.0) a_ = 1.0;
-            a = (value_type)uround(a_ * double(base_mask));
-        }
-
-        //--------------------------------------------------------------------
-        double opacity() const
-        {
-            return double(a) / double(base_mask);
-        }
-
-
-        //--------------------------------------------------------------------
-        const self_type& premultiply()
-        {
-            if(a == base_mask) return *this;
-            if(a == 0)
-            {
-                v = 0;
-                return *this;
-            }
-            v = value_type((calc_type(v) * a) >> base_shift);
-            return *this;
-        }
-
-        //--------------------------------------------------------------------
-        const self_type& premultiply(unsigned a_)
-        {
-            if(a == base_mask && a_ >= base_mask) return *this;
-            if(a == 0 || a_ == 0)
-            {
-                v = a = 0;
-                return *this;
-            }
-            calc_type v_ = (calc_type(v) * a_) / a;
-            v = value_type((v_ > a_) ? a_ : v_);
-            a = value_type(a_);
-            return *this;
-        }
-
-        //--------------------------------------------------------------------
-        const self_type& demultiply()
-        {
-            if(a == base_mask) return *this;
-            if(a == 0)
-            {
-                v = 0;
-                return *this;
-            }
-            calc_type v_ = (calc_type(v) * base_mask) / a;
-            v = value_type((v_ > base_mask) ? (value_type)base_mask : v_);
-            return *this;
-        }
-
-        //--------------------------------------------------------------------
-        self_type gradient(self_type c, double k) const
-        {
-            self_type ret;
-            calc_type ik = uround(k * base_scale);
-            ret.v = value_type(calc_type(v) + (((calc_type(c.v) - v) * ik) >> base_shift));
-            ret.a = value_type(calc_type(a) + (((calc_type(c.a) - a) * ik) >> base_shift));
-            return ret;
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE void add(const self_type& c, unsigned cover)
-        {
-            calc_type cv, ca;
-            if(cover == cover_mask)
-            {
-                if(c.a == base_mask) 
-                {
-                    *this = c;
-                }
-                else
-                {
-                    cv = v + c.v; v = (cv > calc_type(base_mask)) ? calc_type(base_mask) : cv;
-                    ca = a + c.a; a = (ca > calc_type(base_mask)) ? calc_type(base_mask) : ca;
-                }
-            }
-            else
-            {
-                cv = v + ((c.v * cover + cover_mask/2) >> cover_shift);
-                ca = a + ((c.a * cover + cover_mask/2) >> cover_shift);
-                v = (cv > calc_type(base_mask)) ? calc_type(base_mask) : cv;
-                a = (ca > calc_type(base_mask)) ? calc_type(base_mask) : ca;
-            }
-        }
-
-        //--------------------------------------------------------------------
-        static self_type no_color() { return self_type(0,0); }
-    };
-
-
-    //-------------------------------------------------------------gray8_pre
-    inline gray8 gray8_pre(unsigned v, unsigned a = gray8::base_mask)
-    {
-        return gray8(v,a).premultiply();
-    }
-    inline gray8 gray8_pre(const gray8& c, unsigned a)
-    {
-        return gray8(c,a).premultiply();
-    }
-    inline gray8 gray8_pre(const rgba& c)
-    {
-        return gray8(c).premultiply();
-    }
-    inline gray8 gray8_pre(const rgba& c, double a)
-    {
-        return gray8(c,a).premultiply();
-    }
-    inline gray8 gray8_pre(const rgba8& c)
-    {
-        return gray8(c).premultiply();
-    }
-    inline gray8 gray8_pre(const rgba8& c, unsigned a)
-    {
-        return gray8(c,a).premultiply();
-    }
-
-
-
-
-    //==================================================================gray16
-    struct gray16
-    {
-        typedef int16u value_type;
-        typedef int32u calc_type;
-        typedef int64  long_type;
-        enum base_scale_e
-        {
-            base_shift = 16,
-            base_scale = 1 << base_shift,
-            base_mask  = base_scale - 1
-        };
-        typedef gray16 self_type;
-
-        value_type v;
-        value_type a;
-
-        //--------------------------------------------------------------------
-        gray16() {}
-
-        //--------------------------------------------------------------------
-        gray16(unsigned v_, unsigned a_=base_mask) :
-            v(int16u(v_)), a(int16u(a_)) {}
-
-        //--------------------------------------------------------------------
-        gray16(const self_type& c, unsigned a_) :
-            v(c.v), a(value_type(a_)) {}
-
-        //--------------------------------------------------------------------
-        gray16(const rgba& c) :
-            v((value_type)uround((0.299*c.r + 0.587*c.g + 0.114*c.b) * double(base_mask))),
-            a((value_type)uround(c.a * double(base_mask))) {}
-
-        //--------------------------------------------------------------------
-        gray16(const rgba& c, double a_) :
-            v((value_type)uround((0.299*c.r + 0.587*c.g + 0.114*c.b) * double(base_mask))),
-            a((value_type)uround(a_ * double(base_mask))) {}
-
-        //--------------------------------------------------------------------
-        gray16(const rgba8& c) :
-            v(c.r*77 + c.g*150 + c.b*29),
-            a((value_type(c.a) << 8) | c.a) {}
-
-        //--------------------------------------------------------------------
-        gray16(const rgba8& c, unsigned a_) :
-            v(c.r*77 + c.g*150 + c.b*29),
-            a((value_type(a_) << 8) | c.a) {}
-
-        //--------------------------------------------------------------------
-        void clear()
-        {
-            v = a = 0;
-        }
-
-        //--------------------------------------------------------------------
-        const self_type& transparent()
-        {
-            a = 0;
-            return *this;
-        }
-
-        //--------------------------------------------------------------------
-        void opacity(double a_)
-        {
-            if(a_ < 0.0) a_ = 0.0;
-            if(a_ > 1.0) a_ = 1.0;
-            a = (value_type)uround(a_ * double(base_mask));
-        }
-
-        //--------------------------------------------------------------------
-        double opacity() const
-        {
-            return double(a) / double(base_mask);
-        }
-
-
-        //--------------------------------------------------------------------
-        const self_type& premultiply()
-        {
-            if(a == base_mask) return *this;
-            if(a == 0)
-            {
-                v = 0;
-                return *this;
-            }
-            v = value_type((calc_type(v) * a) >> base_shift);
-            return *this;
-        }
-
-        //--------------------------------------------------------------------
-        const self_type& premultiply(unsigned a_)
-        {
-            if(a == base_mask && a_ >= base_mask) return *this;
-            if(a == 0 || a_ == 0)
-            {
-                v = a = 0;
-                return *this;
-            }
-            calc_type v_ = (calc_type(v) * a_) / a;
-            v = value_type((v_ > a_) ? a_ : v_);
-            a = value_type(a_);
-            return *this;
-        }
-
-        //--------------------------------------------------------------------
-        const self_type& demultiply()
-        {
-            if(a == base_mask) return *this;
-            if(a == 0)
-            {
-                v = 0;
-                return *this;
-            }
-            calc_type v_ = (calc_type(v) * base_mask) / a;
-            v = value_type((v_ > base_mask) ? base_mask : v_);
-            return *this;
-        }
-
-        //--------------------------------------------------------------------
-        self_type gradient(self_type c, double k) const
-        {
-            self_type ret;
-            calc_type ik = uround(k * base_scale);
-            ret.v = value_type(calc_type(v) + (((calc_type(c.v) - v) * ik) >> base_shift));
-            ret.a = value_type(calc_type(a) + (((calc_type(c.a) - a) * ik) >> base_shift));
-            return ret;
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE void add(const self_type& c, unsigned cover)
-        {
-            calc_type cv, ca;
-            if(cover == cover_mask)
-            {
-                if(c.a == base_mask) 
-                {
-                    *this = c;
-                }
-                else
-                {
-                    cv = v + c.v; v = (cv > calc_type(base_mask)) ? calc_type(base_mask) : cv;
-                    ca = a + c.a; a = (ca > calc_type(base_mask)) ? calc_type(base_mask) : ca;
-                }
-            }
-            else
-            {
-                cv = v + ((c.v * cover + cover_mask/2) >> cover_shift);
-                ca = a + ((c.a * cover + cover_mask/2) >> cover_shift);
-                v = (cv > calc_type(base_mask)) ? calc_type(base_mask) : cv;
-                a = (ca > calc_type(base_mask)) ? calc_type(base_mask) : ca;
-            }
-        }
-
-        //--------------------------------------------------------------------
-        static self_type no_color() { return self_type(0,0); }
-    };
-
-
-    //------------------------------------------------------------gray16_pre
-    inline gray16 gray16_pre(unsigned v, unsigned a = gray16::base_mask)
-    {
-        return gray16(v,a).premultiply();
-    }
-    inline gray16 gray16_pre(const gray16& c, unsigned a)
-    {
-        return gray16(c,a).premultiply();
-    }
-    inline gray16 gray16_pre(const rgba& c)
-    {
-        return gray16(c).premultiply();
-    }
-    inline gray16 gray16_pre(const rgba& c, double a)
-    {
-        return gray16(c,a).premultiply();
-    }
-    inline gray16 gray16_pre(const rgba8& c)
-    {
-        return gray16(c).premultiply();
-    }
-    inline gray16 gray16_pre(const rgba8& c, unsigned a)
-    {
-        return gray16(c,a).premultiply();
-    }
-
-
-}
-
-
-
-
-#endif

Sources/libagg/agg-2.4/agg_color_rgba.h

@@ -1,743 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-//
-// Adaptation for high precision colors has been sponsored by 
-// Liberty Technology Systems, Inc., visit http://lib-sys.com
-//
-// Liberty Technology Systems, Inc. is the provider of
-// PostScript and PDF technology for software developers.
-// 
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-
-#ifndef AGG_COLOR_RGBA_INCLUDED
-#define AGG_COLOR_RGBA_INCLUDED
-
-#include <math.h>
-#include "agg_basics.h"
-
-namespace agg
-{
-    // Supported byte orders for RGB and RGBA pixel formats
-    //=======================================================================
-    struct order_rgb  { enum rgb_e  { R=0, G=1, B=2, rgb_tag }; };       //----order_rgb
-    struct order_bgr  { enum bgr_e  { B=0, G=1, R=2, rgb_tag }; };       //----order_bgr
-    struct order_rgba { enum rgba_e { R=0, G=1, B=2, A=3, rgba_tag }; }; //----order_rgba
-    struct order_argb { enum argb_e { A=0, R=1, G=2, B=3, rgba_tag }; }; //----order_argb
-    struct order_abgr { enum abgr_e { A=0, B=1, G=2, R=3, rgba_tag }; }; //----order_abgr
-    struct order_bgra { enum bgra_e { B=0, G=1, R=2, A=3, rgba_tag }; }; //----order_bgra
-
-    //====================================================================rgba
-    struct rgba
-    {
-        typedef double value_type;
-
-        double r;
-        double g;
-        double b;
-        double a;
-
-        //--------------------------------------------------------------------
-        rgba() {}
-
-        //--------------------------------------------------------------------
-        rgba(double r_, double g_, double b_, double a_=1.0) :
-            r(r_), g(g_), b(b_), a(a_) {}
-
-        //--------------------------------------------------------------------
-        rgba(const rgba& c, double a_) : r(c.r), g(c.g), b(c.b), a(a_) {}
-
-        //--------------------------------------------------------------------
-        void clear()
-        {
-            r = g = b = a = 0;
-        }
-
-        //--------------------------------------------------------------------
-        const rgba& transparent()
-        {
-            a = 0.0;
-            return *this;
-        }
-
-        //--------------------------------------------------------------------
-        const rgba& opacity(double a_)
-        {
-            if(a_ < 0.0) a_ = 0.0;
-            if(a_ > 1.0) a_ = 1.0;
-            a = a_;
-            return *this;
-        }
-
-        //--------------------------------------------------------------------
-        double opacity() const
-        {
-            return a;
-        }
-
-        //--------------------------------------------------------------------
-        const rgba& premultiply()
-        {
-            r *= a;
-            g *= a;
-            b *= a;
-            return *this;
-        }
-
-        //--------------------------------------------------------------------
-        const rgba& premultiply(double a_)
-        {
-            if(a <= 0.0 || a_ <= 0.0)
-            {
-                r = g = b = a = 0.0;
-                return *this;
-            }
-            a_ /= a;
-            r *= a_;
-            g *= a_;
-            b *= a_;
-            a  = a_;
-            return *this;
-        }
-
-        //--------------------------------------------------------------------
-        const rgba& demultiply()
-        {
-            if(a == 0)
-            {
-                r = g = b = 0;
-                return *this;
-            }
-            double a_ = 1.0 / a;
-            r *= a_;
-            g *= a_;
-            b *= a_;
-            return *this;
-        }
-
-
-        //--------------------------------------------------------------------
-        rgba gradient(rgba c, double k) const
-        {
-            rgba ret;
-            ret.r = r + (c.r - r) * k;
-            ret.g = g + (c.g - g) * k;
-            ret.b = b + (c.b - b) * k;
-            ret.a = a + (c.a - a) * k;
-            return ret;
-        }
-
-        //--------------------------------------------------------------------
-        static rgba no_color() { return rgba(0,0,0,0); }
-
-        //--------------------------------------------------------------------
-        static rgba from_wavelength(double wl, double gamma = 1.0);
-	
-        //--------------------------------------------------------------------
-        explicit rgba(double wavelen, double gamma=1.0)
-        {
-            *this = from_wavelength(wavelen, gamma);
-        }
-
-    };
-
-    //----------------------------------------------------------------rgba_pre
-    inline rgba rgba_pre(double r, double g, double b, double a=1.0)
-    {
-        return rgba(r, g, b, a).premultiply();
-    }
-    inline rgba rgba_pre(const rgba& c)
-    {
-        return rgba(c).premultiply();
-    }
-    inline rgba rgba_pre(const rgba& c, double a)
-    {
-        return rgba(c, a).premultiply();
-    }
-
-    //------------------------------------------------------------------------
-    inline rgba rgba::from_wavelength(double wl, double gamma)
-    {
-        rgba t(0.0, 0.0, 0.0);
-
-        if(wl >= 380.0 && wl <= 440.0)
-        {
-            t.r = -1.0 * (wl - 440.0) / (440.0 - 380.0);
-            t.b = 1.0;
-        }
-        else 
-        if(wl >= 440.0 && wl <= 490.0)
-        {
-            t.g = (wl - 440.0) / (490.0 - 440.0);
-            t.b = 1.0;
-        }
-        else
-        if(wl >= 490.0 && wl <= 510.0)
-        {
-            t.g = 1.0;
-            t.b = -1.0 * (wl - 510.0) / (510.0 - 490.0);
-        }
-        else
-        if(wl >= 510.0 && wl <= 580.0)
-        {
-            t.r = (wl - 510.0) / (580.0 - 510.0);
-            t.g = 1.0;
-        }
-        else
-        if(wl >= 580.0 && wl <= 645.0)
-        {
-            t.r = 1.0;
-            t.g = -1.0 * (wl - 645.0) / (645.0 - 580.0);
-        }
-        else
-        if(wl >= 645.0 && wl <= 780.0)
-        {
-            t.r = 1.0;
-        }
-
-        double s = 1.0;
-        if(wl > 700.0)       s = 0.3 + 0.7 * (780.0 - wl) / (780.0 - 700.0);
-        else if(wl <  420.0) s = 0.3 + 0.7 * (wl - 380.0) / (420.0 - 380.0);
-
-        t.r = pow(t.r * s, gamma);
-        t.g = pow(t.g * s, gamma);
-        t.b = pow(t.b * s, gamma);
-        return t;
-    }
-
-
-
-    
-    //===================================================================rgba8
-    struct rgba8
-    {
-        typedef int8u  value_type;
-        typedef int32u calc_type;
-        typedef int32  long_type;
-        enum base_scale_e
-        {
-            base_shift = 8,
-            base_scale = 1 << base_shift,
-            base_mask  = base_scale - 1
-        };
-        typedef rgba8 self_type;
-
-
-        value_type r;
-        value_type g;
-        value_type b;
-        value_type a;
-
-        //--------------------------------------------------------------------
-        rgba8() {}
-
-        //--------------------------------------------------------------------
-        rgba8(unsigned r_, unsigned g_, unsigned b_, unsigned a_=base_mask) :
-            r(value_type(r_)), 
-            g(value_type(g_)), 
-            b(value_type(b_)), 
-            a(value_type(a_)) {}
-
-        //--------------------------------------------------------------------
-        rgba8(const rgba& c, double a_) :
-            r((value_type)uround(c.r * double(base_mask))), 
-            g((value_type)uround(c.g * double(base_mask))), 
-            b((value_type)uround(c.b * double(base_mask))), 
-            a((value_type)uround(a_  * double(base_mask))) {}
-
-        //--------------------------------------------------------------------
-        rgba8(const self_type& c, unsigned a_) :
-            r(c.r), g(c.g), b(c.b), a(value_type(a_)) {}
-
-        //--------------------------------------------------------------------
-        rgba8(const rgba& c) :
-            r((value_type)uround(c.r * double(base_mask))), 
-            g((value_type)uround(c.g * double(base_mask))), 
-            b((value_type)uround(c.b * double(base_mask))), 
-            a((value_type)uround(c.a * double(base_mask))) {}
-
-        //--------------------------------------------------------------------
-        void clear()
-        {
-            r = g = b = a = 0;
-        }
-        
-        //--------------------------------------------------------------------
-        const self_type& transparent()
-        {
-            a = 0;
-            return *this;
-        }
-
-        //--------------------------------------------------------------------
-        const self_type& opacity(double a_)
-        {
-            if(a_ < 0.0) a_ = 0.0;
-            if(a_ > 1.0) a_ = 1.0;
-            a = (value_type)uround(a_ * double(base_mask));
-            return *this;
-        }
-
-        //--------------------------------------------------------------------
-        double opacity() const
-        {
-            return double(a) / double(base_mask);
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE const self_type& premultiply()
-        {
-            if(a == base_mask) return *this;
-            if(a == 0)
-            {
-                r = g = b = 0;
-                return *this;
-            }
-            r = value_type((calc_type(r) * a) >> base_shift);
-            g = value_type((calc_type(g) * a) >> base_shift);
-            b = value_type((calc_type(b) * a) >> base_shift);
-            return *this;
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE const self_type& premultiply(unsigned a_)
-        {
-            if(a == base_mask && a_ >= base_mask) return *this;
-            if(a == 0 || a_ == 0)
-            {
-                r = g = b = a = 0;
-                return *this;
-            }
-            calc_type r_ = (calc_type(r) * a_) / a;
-            calc_type g_ = (calc_type(g) * a_) / a;
-            calc_type b_ = (calc_type(b) * a_) / a;
-            r = value_type((r_ > a_) ? a_ : r_);
-            g = value_type((g_ > a_) ? a_ : g_);
-            b = value_type((b_ > a_) ? a_ : b_);
-            a = value_type(a_);
-            return *this;
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE const self_type& demultiply()
-        {
-            if(a == base_mask) return *this;
-            if(a == 0)
-            {
-                r = g = b = 0;
-                return *this;
-            }
-            calc_type r_ = (calc_type(r) * base_mask) / a;
-            calc_type g_ = (calc_type(g) * base_mask) / a;
-            calc_type b_ = (calc_type(b) * base_mask) / a;
-            r = value_type((r_ > calc_type(base_mask)) ? calc_type(base_mask) : r_);
-            g = value_type((g_ > calc_type(base_mask)) ? calc_type(base_mask) : g_);
-            b = value_type((b_ > calc_type(base_mask)) ? calc_type(base_mask) : b_);
-            return *this;
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE self_type gradient(const self_type& c, double k) const
-        {
-            self_type ret;
-            calc_type ik = uround(k * base_scale);
-            ret.r = value_type(calc_type(r) + (((calc_type(c.r) - r) * ik) >> base_shift));
-            ret.g = value_type(calc_type(g) + (((calc_type(c.g) - g) * ik) >> base_shift));
-            ret.b = value_type(calc_type(b) + (((calc_type(c.b) - b) * ik) >> base_shift));
-            ret.a = value_type(calc_type(a) + (((calc_type(c.a) - a) * ik) >> base_shift));
-            return ret;
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE void add(const self_type& c, unsigned cover)
-        {
-            calc_type cr, cg, cb, ca;
-            if(cover == cover_mask)
-            {
-                if(c.a == base_mask) 
-                {
-                    *this = c;
-                }
-                else
-                {
-                    cr = r + c.r; r = (cr > calc_type(base_mask)) ? calc_type(base_mask) : cr;
-                    cg = g + c.g; g = (cg > calc_type(base_mask)) ? calc_type(base_mask) : cg;
-                    cb = b + c.b; b = (cb > calc_type(base_mask)) ? calc_type(base_mask) : cb;
-                    ca = a + c.a; a = (ca > calc_type(base_mask)) ? calc_type(base_mask) : ca;
-                }
-            }
-            else
-            {
-                cr = r + ((c.r * cover + cover_mask/2) >> cover_shift);
-                cg = g + ((c.g * cover + cover_mask/2) >> cover_shift);
-                cb = b + ((c.b * cover + cover_mask/2) >> cover_shift);
-                ca = a + ((c.a * cover + cover_mask/2) >> cover_shift);
-                r = (cr > calc_type(base_mask)) ? calc_type(base_mask) : cr;
-                g = (cg > calc_type(base_mask)) ? calc_type(base_mask) : cg;
-                b = (cb > calc_type(base_mask)) ? calc_type(base_mask) : cb;
-                a = (ca > calc_type(base_mask)) ? calc_type(base_mask) : ca;
-            }
-        }
-
-        //--------------------------------------------------------------------
-        template<class GammaLUT>
-        AGG_INLINE void apply_gamma_dir(const GammaLUT& gamma)
-        {
-            r = gamma.dir(r);
-            g = gamma.dir(g);
-            b = gamma.dir(b);
-        }
-
-        //--------------------------------------------------------------------
-        template<class GammaLUT>
-        AGG_INLINE void apply_gamma_inv(const GammaLUT& gamma)
-        {
-            r = gamma.inv(r);
-            g = gamma.inv(g);
-            b = gamma.inv(b);
-        }
-
-        //--------------------------------------------------------------------
-        static self_type no_color() { return self_type(0,0,0,0); }
-
-        //--------------------------------------------------------------------
-        static self_type from_wavelength(double wl, double gamma = 1.0)
-        {
-            return self_type(rgba::from_wavelength(wl, gamma));
-        }
-    };
-
-
-    //-------------------------------------------------------------rgba8_pre
-    inline rgba8 rgba8_pre(unsigned r, unsigned g, unsigned b, 
-                           unsigned a = rgba8::base_mask)
-    {
-        return rgba8(r,g,b,a).premultiply();
-    }
-    inline rgba8 rgba8_pre(const rgba8& c)
-    {
-        return rgba8(c).premultiply();
-    }
-    inline rgba8 rgba8_pre(const rgba8& c, unsigned a)
-    {
-        return rgba8(c,a).premultiply();
-    }
-    inline rgba8 rgba8_pre(const rgba& c)
-    {
-        return rgba8(c).premultiply();
-    }
-    inline rgba8 rgba8_pre(const rgba& c, double a)
-    {
-        return rgba8(c,a).premultiply();
-    }
-
-
-    //-------------------------------------------------------------rgb8_packed
-    inline rgba8 rgb8_packed(unsigned v)
-    {
-        return rgba8((v >> 16) & 0xFF, (v >> 8) & 0xFF, v & 0xFF);
-    }
-
-    //-------------------------------------------------------------bgr8_packed
-    inline rgba8 bgr8_packed(unsigned v)
-    {
-        return rgba8(v & 0xFF, (v >> 8) & 0xFF, (v >> 16) & 0xFF);
-    }
-
-    //------------------------------------------------------------argb8_packed
-    inline rgba8 argb8_packed(unsigned v)
-    {
-        return rgba8((v >> 16) & 0xFF, (v >> 8) & 0xFF, v & 0xFF, v >> 24);
-    }
-
-    //---------------------------------------------------------rgba8_gamma_dir
-    template<class GammaLUT>
-    rgba8 rgba8_gamma_dir(rgba8 c, const GammaLUT& gamma)
-    {
-        return rgba8(gamma.dir(c.r), gamma.dir(c.g), gamma.dir(c.b), c.a);
-    }
-
-    //---------------------------------------------------------rgba8_gamma_inv
-    template<class GammaLUT>
-    rgba8 rgba8_gamma_inv(rgba8 c, const GammaLUT& gamma)
-    {
-        return rgba8(gamma.inv(c.r), gamma.inv(c.g), gamma.inv(c.b), c.a);
-    }
-
-
-
-
-
-    //==================================================================rgba16
-    struct rgba16
-    {
-        typedef int16u value_type;
-        typedef int32u calc_type;
-        typedef int64  long_type;
-        enum base_scale_e
-        {
-            base_shift = 16,
-            base_scale = 1 << base_shift,
-            base_mask  = base_scale - 1
-        };
-        typedef rgba16 self_type;
-
-        value_type r;
-        value_type g;
-        value_type b;
-        value_type a;
-
-        //--------------------------------------------------------------------
-        rgba16() {}
-
-        //--------------------------------------------------------------------
-        rgba16(unsigned r_, unsigned g_, unsigned b_, unsigned a_=base_mask) :
-            r(value_type(r_)), 
-            g(value_type(g_)), 
-            b(value_type(b_)), 
-            a(value_type(a_)) {}
-
-        //--------------------------------------------------------------------
-        rgba16(const self_type& c, unsigned a_) :
-            r(c.r), g(c.g), b(c.b), a(value_type(a_)) {}
-
-        //--------------------------------------------------------------------
-        rgba16(const rgba& c) :
-            r((value_type)uround(c.r * double(base_mask))), 
-            g((value_type)uround(c.g * double(base_mask))), 
-            b((value_type)uround(c.b * double(base_mask))), 
-            a((value_type)uround(c.a * double(base_mask))) {}
-
-        //--------------------------------------------------------------------
-        rgba16(const rgba& c, double a_) :
-            r((value_type)uround(c.r * double(base_mask))), 
-            g((value_type)uround(c.g * double(base_mask))), 
-            b((value_type)uround(c.b * double(base_mask))), 
-            a((value_type)uround(a_  * double(base_mask))) {}
-
-        //--------------------------------------------------------------------
-        rgba16(const rgba8& c) :
-            r(value_type((value_type(c.r) << 8) | c.r)), 
-            g(value_type((value_type(c.g) << 8) | c.g)), 
-            b(value_type((value_type(c.b) << 8) | c.b)), 
-            a(value_type((value_type(c.a) << 8) | c.a)) {}
-
-        //--------------------------------------------------------------------
-        rgba16(const rgba8& c, unsigned a_) :
-            r(value_type((value_type(c.r) << 8) | c.r)), 
-            g(value_type((value_type(c.g) << 8) | c.g)), 
-            b(value_type((value_type(c.b) << 8) | c.b)), 
-            a(value_type((             a_ << 8) | c.a)) {}
-
-        //--------------------------------------------------------------------
-        void clear()
-        {
-            r = g = b = a = 0;
-        }
-        
-        //--------------------------------------------------------------------
-        const self_type& transparent()
-        {
-            a = 0;
-            return *this;
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE const self_type& opacity(double a_)
-        {
-            if(a_ < 0.0) a_ = 0.0;
-            if(a_ > 1.0) a_ = 1.0;
-            a = (value_type)uround(a_ * double(base_mask));
-            return *this;
-        }
-
-        //--------------------------------------------------------------------
-        double opacity() const
-        {
-            return double(a) / double(base_mask);
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE const self_type& premultiply()
-        {
-            if(a == base_mask) return *this;
-            if(a == 0)
-            {
-                r = g = b = 0;
-                return *this;
-            }
-            r = value_type((calc_type(r) * a) >> base_shift);
-            g = value_type((calc_type(g) * a) >> base_shift);
-            b = value_type((calc_type(b) * a) >> base_shift);
-            return *this;
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE const self_type& premultiply(unsigned a_)
-        {
-            if(a == base_mask && a_ >= base_mask) return *this;
-            if(a == 0 || a_ == 0)
-            {
-                r = g = b = a = 0;
-                return *this;
-            }
-            calc_type r_ = (calc_type(r) * a_) / a;
-            calc_type g_ = (calc_type(g) * a_) / a;
-            calc_type b_ = (calc_type(b) * a_) / a;
-            r = value_type((r_ > a_) ? a_ : r_);
-            g = value_type((g_ > a_) ? a_ : g_);
-            b = value_type((b_ > a_) ? a_ : b_);
-            a = value_type(a_);
-            return *this;
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE const self_type& demultiply()
-        {
-            if(a == base_mask) return *this;
-            if(a == 0)
-            {
-                r = g = b = 0;
-                return *this;
-            }
-            calc_type r_ = (calc_type(r) * base_mask) / a;
-            calc_type g_ = (calc_type(g) * base_mask) / a;
-            calc_type b_ = (calc_type(b) * base_mask) / a;
-            r = value_type((r_ > calc_type(base_mask)) ? calc_type(base_mask) : r_);
-            g = value_type((g_ > calc_type(base_mask)) ? calc_type(base_mask) : g_);
-            b = value_type((b_ > calc_type(base_mask)) ? calc_type(base_mask) : b_);
-            return *this;
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE self_type gradient(const self_type& c, double k) const
-        {
-            self_type ret;
-            calc_type ik = uround(k * base_scale);
-            ret.r = value_type(calc_type(r) + (((calc_type(c.r) - r) * ik) >> base_shift));
-            ret.g = value_type(calc_type(g) + (((calc_type(c.g) - g) * ik) >> base_shift));
-            ret.b = value_type(calc_type(b) + (((calc_type(c.b) - b) * ik) >> base_shift));
-            ret.a = value_type(calc_type(a) + (((calc_type(c.a) - a) * ik) >> base_shift));
-            return ret;
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE void add(const self_type& c, unsigned cover)
-        {
-            calc_type cr, cg, cb, ca;
-            if(cover == cover_mask)
-            {
-                if(c.a == base_mask) 
-                {
-                    *this = c;
-                }
-                else
-                {
-                    cr = r + c.r; r = (cr > calc_type(base_mask)) ? calc_type(base_mask) : cr;
-                    cg = g + c.g; g = (cg > calc_type(base_mask)) ? calc_type(base_mask) : cg;
-                    cb = b + c.b; b = (cb > calc_type(base_mask)) ? calc_type(base_mask) : cb;
-                    ca = a + c.a; a = (ca > calc_type(base_mask)) ? calc_type(base_mask) : ca;
-                }
-            }
-            else
-            {
-                cr = r + ((c.r * cover + cover_mask) >> cover_shift);
-                cg = g + ((c.g * cover + cover_mask) >> cover_shift);
-                cb = b + ((c.b * cover + cover_mask) >> cover_shift);
-                ca = a + ((c.a * cover + cover_mask) >> cover_shift);
-                r = (cr > calc_type(base_mask)) ? calc_type(base_mask) : cr;
-                g = (cg > calc_type(base_mask)) ? calc_type(base_mask) : cg;
-                b = (cb > calc_type(base_mask)) ? calc_type(base_mask) : cb;
-                a = (ca > calc_type(base_mask)) ? calc_type(base_mask) : ca;
-            }
-        }
-
-        //--------------------------------------------------------------------
-        template<class GammaLUT>
-        AGG_INLINE void apply_gamma_dir(const GammaLUT& gamma)
-        {
-            r = gamma.dir(r);
-            g = gamma.dir(g);
-            b = gamma.dir(b);
-        }
-
-        //--------------------------------------------------------------------
-        template<class GammaLUT>
-        AGG_INLINE void apply_gamma_inv(const GammaLUT& gamma)
-        {
-            r = gamma.inv(r);
-            g = gamma.inv(g);
-            b = gamma.inv(b);
-        }
-
-        //--------------------------------------------------------------------
-        static self_type no_color() { return self_type(0,0,0,0); }
-
-        //--------------------------------------------------------------------
-        static self_type from_wavelength(double wl, double gamma = 1.0)
-        {
-            return self_type(rgba::from_wavelength(wl, gamma));
-        }
-    };
-
-
-
-    //--------------------------------------------------------------rgba16_pre
-    inline rgba16 rgba16_pre(unsigned r, unsigned g, unsigned b, 
-                             unsigned a = rgba16::base_mask)
-    {
-        return rgba16(r,g,b,a).premultiply();
-    }
-    inline rgba16 rgba16_pre(const rgba16& c, unsigned a)
-    {
-        return rgba16(c,a).premultiply();
-    }
-    inline rgba16 rgba16_pre(const rgba& c)
-    {
-        return rgba16(c).premultiply();
-    }
-    inline rgba16 rgba16_pre(const rgba& c, double a)
-    {
-        return rgba16(c,a).premultiply();
-    }
-    inline rgba16 rgba16_pre(const rgba8& c)
-    {
-        return rgba16(c).premultiply();
-    }
-    inline rgba16 rgba16_pre(const rgba8& c, unsigned a)
-    {
-        return rgba16(c,a).premultiply();
-    }
-
-
-    //------------------------------------------------------rgba16_gamma_dir
-    template<class GammaLUT>
-    rgba16 rgba16_gamma_dir(rgba16 c, const GammaLUT& gamma)
-    {
-        return rgba16(gamma.dir(c.r), gamma.dir(c.g), gamma.dir(c.b), c.a);
-    }
-
-    //------------------------------------------------------rgba16_gamma_inv
-    template<class GammaLUT>
-    rgba16 rgba16_gamma_inv(rgba16 c, const GammaLUT& gamma)
-    {
-        return rgba16(gamma.inv(c.r), gamma.inv(c.g), gamma.inv(c.b), c.a);
-    }
-
-
-}
-
-
-
-#endif

Sources/libagg/agg-2.4/agg_config.h

@@ -1,44 +0,0 @@
-#ifndef AGG_CONFIG_INCLUDED
-#define AGG_CONFIG_INCLUDED
-
-// This file can be used to redefine certain data types.
-
-//---------------------------------------
-// 1. Default basic types such as:
-// 
-// AGG_INT8
-// AGG_INT8U
-// AGG_INT16
-// AGG_INT16U
-// AGG_INT32
-// AGG_INT32U
-// AGG_INT64
-// AGG_INT64U
-//
-// Just replace this file with new defines if necessary. 
-// For example, if your compiler doesn't have a 64 bit integer type
-// you can still use AGG if you define the follows:
-//
-// #define AGG_INT64  int
-// #define AGG_INT64U unsigned
-//
-// It will result in overflow in 16 bit-per-component image/pattern resampling
-// but it won't result any crash and the rest of the library will remain 
-// fully functional.
-
-
-//---------------------------------------
-// 2. Default rendering_buffer type. Can be:
-//
-// Provides faster access for massive pixel operations, 
-// such as blur, image filtering:
-// #define AGG_RENDERING_BUFFER row_ptr_cache<int8u>
-// 
-// Provides cheaper creation and destruction (no mem allocs):
-// #define AGG_RENDERING_BUFFER row_accessor<int8u>
-//
-// You can still use both of them simultaneouslyin your applications 
-// This #define is used only for default rendering_buffer type,
-// in short hand typedefs like pixfmt_rgba32.
-
-#endif

Sources/libagg/agg-2.4/agg_conv_adaptor_vcgen.h

@@ -1,157 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-
-#ifndef AGG_CONV_ADAPTOR_VCGEN_INCLUDED
-#define AGG_CONV_ADAPTOR_VCGEN_INCLUDED
-
-#include "agg_basics.h"
-
-namespace agg
-{
-    //------------------------------------------------------------null_markers
-    struct null_markers
-    {
-        void remove_all() {}
-        void add_vertex(double, double, unsigned) {}
-        void prepare_src() {}
-
-        void rewind(unsigned) {}
-        unsigned vertex(double*, double*) { return path_cmd_stop; }
-    };
-
-
-    //------------------------------------------------------conv_adaptor_vcgen
-    template<class VertexSource, 
-             class Generator, 
-             class Markers=null_markers> class conv_adaptor_vcgen
-    {
-        enum status
-        {
-            initial,
-            accumulate,
-            generate
-        };
-
-    public:
-        explicit conv_adaptor_vcgen(VertexSource& source) :
-            m_source(&source), 
-            m_status(initial)
-        {}
-        void attach(VertexSource& source) { m_source = &source; }
-
-        Generator& generator() { return m_generator; }
-        const Generator& generator() const { return m_generator; }
-
-        Markers& markers() { return m_markers; }
-        const Markers& markers() const { return m_markers; }
-        
-        void rewind(unsigned path_id) 
-        { 
-            m_source->rewind(path_id); 
-            m_status = initial;
-        }
-
-        unsigned vertex(double* x, double* y);
-
-    private:
-        // Prohibit copying
-        conv_adaptor_vcgen(const conv_adaptor_vcgen<VertexSource, Generator, Markers>&);
-        const conv_adaptor_vcgen<VertexSource, Generator, Markers>& 
-            operator = (const conv_adaptor_vcgen<VertexSource, Generator, Markers>&);
-
-        VertexSource* m_source;
-        Generator     m_generator;
-        Markers       m_markers;
-        status        m_status;
-        unsigned      m_last_cmd;
-        double        m_start_x;
-        double        m_start_y;
-    };
-
-
-
-
-
-    //------------------------------------------------------------------------
-    template<class VertexSource, class Generator, class Markers> 
-    unsigned conv_adaptor_vcgen<VertexSource, Generator, Markers>::vertex(double* x, double* y)
-    {
-        unsigned cmd = path_cmd_stop;
-        bool done = false;
-        while(!done)
-        {
-            switch(m_status)
-            {
-            case initial:
-                m_markers.remove_all();
-                m_last_cmd = m_source->vertex(&m_start_x, &m_start_y);
-                m_status = accumulate;
-
-            case accumulate:
-                if(is_stop(m_last_cmd)) return path_cmd_stop;
-
-                m_generator.remove_all();
-                m_generator.add_vertex(m_start_x, m_start_y, path_cmd_move_to);
-                m_markers.add_vertex(m_start_x, m_start_y, path_cmd_move_to);
-
-                for(;;)
-                {
-                    cmd = m_source->vertex(x, y);
-                    if(is_vertex(cmd))
-                    {
-                        m_last_cmd = cmd;
-                        if(is_move_to(cmd))
-                        {
-                            m_start_x = *x;
-                            m_start_y = *y;
-                            break;
-                        }
-                        m_generator.add_vertex(*x, *y, cmd);
-                        m_markers.add_vertex(*x, *y, path_cmd_line_to);
-                    }
-                    else
-                    {
-                        if(is_stop(cmd))
-                        {
-                            m_last_cmd = path_cmd_stop;
-                            break;
-                        }
-                        if(is_end_poly(cmd))
-                        {
-                            m_generator.add_vertex(*x, *y, cmd);
-                            break;
-                        }
-                    }
-                }
-                m_generator.rewind(0);
-                m_status = generate;
-
-            case generate:
-                cmd = m_generator.vertex(x, y);
-                if(is_stop(cmd))
-                {
-                    m_status = accumulate;
-                    break;
-                }
-                done = true;
-                break;
-            }
-        }
-        return cmd;
-    }
-
-}
-
-#endif

Sources/libagg/agg-2.4/agg_conv_adaptor_vpgen.h

@@ -1,159 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-
-#ifndef AGG_CONV_ADAPTOR_VPGEN_INCLUDED
-#define AGG_CONV_ADAPTOR_VPGEN_INCLUDED
-
-#include "agg_basics.h"
-
-namespace agg
-{
-
-    //======================================================conv_adaptor_vpgen
-    template<class VertexSource, class VPGen> class conv_adaptor_vpgen
-    {
-    public:
-        explicit conv_adaptor_vpgen(VertexSource& source) : m_source(&source) {}
-        void attach(VertexSource& source) { m_source = &source; }
-
-        VPGen& vpgen() { return m_vpgen; }
-        const VPGen& vpgen() const { return m_vpgen; }
-
-        void rewind(unsigned path_id);
-        unsigned vertex(double* x, double* y);
-
-    private:
-        conv_adaptor_vpgen(const conv_adaptor_vpgen<VertexSource, VPGen>&);
-        const conv_adaptor_vpgen<VertexSource, VPGen>& 
-            operator = (const conv_adaptor_vpgen<VertexSource, VPGen>&);
-
-        VertexSource* m_source;
-        VPGen         m_vpgen;
-        double        m_start_x;
-        double        m_start_y;
-        unsigned      m_poly_flags;
-        int           m_vertices;
-    };
-
-
-
-    //------------------------------------------------------------------------
-    template<class VertexSource, class VPGen>
-    void conv_adaptor_vpgen<VertexSource, VPGen>::rewind(unsigned path_id) 
-    { 
-        m_source->rewind(path_id);
-        m_vpgen.reset();
-        m_start_x    = 0;
-        m_start_y    = 0;
-        m_poly_flags = 0;
-        m_vertices   = 0;
-    }
-
-
-    //------------------------------------------------------------------------
-    template<class VertexSource, class VPGen>
-    unsigned conv_adaptor_vpgen<VertexSource, VPGen>::vertex(double* x, double* y)
-    {
-        unsigned cmd = path_cmd_stop;
-        for(;;)
-        {
-            cmd = m_vpgen.vertex(x, y);
-            if(!is_stop(cmd)) break;
-
-            if(m_poly_flags && !m_vpgen.auto_unclose())
-            {
-                *x = 0.0;
-                *y = 0.0;
-                cmd = m_poly_flags;
-                m_poly_flags = 0;
-                break;
-            }
-
-            if(m_vertices < 0)
-            {
-                if(m_vertices < -1) 
-                {
-                    m_vertices = 0;
-                    return path_cmd_stop;
-                }
-                m_vpgen.move_to(m_start_x, m_start_y);
-                m_vertices = 1;
-                continue;
-            }
-
-            double tx, ty;
-            cmd = m_source->vertex(&tx, &ty);
-            if(is_vertex(cmd))
-            {
-                if(is_move_to(cmd)) 
-                {
-                    if(m_vpgen.auto_close() && m_vertices > 2)
-                    {
-                        m_vpgen.line_to(m_start_x, m_start_y);
-                        m_poly_flags = path_cmd_end_poly | path_flags_close;
-                        m_start_x    = tx;
-                        m_start_y    = ty;
-                        m_vertices   = -1;
-                        continue;
-                    }
-                    m_vpgen.move_to(tx, ty);
-                    m_start_x  = tx;
-                    m_start_y  = ty;
-                    m_vertices = 1;
-                }
-                else 
-                {
-                    m_vpgen.line_to(tx, ty);
-                    ++m_vertices;
-                }
-            }
-            else
-            {
-                if(is_end_poly(cmd))
-                {
-                    m_poly_flags = cmd;
-                    if(is_closed(cmd) || m_vpgen.auto_close())
-                    {
-                        if(m_vpgen.auto_close()) m_poly_flags |= path_flags_close;
-                        if(m_vertices > 2)
-                        {
-                            m_vpgen.line_to(m_start_x, m_start_y);
-                        }
-                        m_vertices = 0;
-                    }
-                }
-                else
-                {
-                    // path_cmd_stop
-                    if(m_vpgen.auto_close() && m_vertices > 2)
-                    {
-                        m_vpgen.line_to(m_start_x, m_start_y);
-                        m_poly_flags = path_cmd_end_poly | path_flags_close;
-                        m_vertices   = -2;
-                        continue;
-                    }
-                    break;
-                }
-            }
-        }
-        return cmd;
-    }
-
-
-}
-
-
-#endif
-

Sources/libagg/agg-2.4/agg_conv_bspline.h

@@ -1,48 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-#ifndef AGG_CONV_BSPLINE_INCLUDED
-#define AGG_CONV_BSPLINE_INCLUDED
-
-#include "agg_basics.h"
-#include "agg_vcgen_bspline.h"
-#include "agg_conv_adaptor_vcgen.h"
-
-
-namespace agg
-{
-
-    //---------------------------------------------------------conv_bspline
-    template<class VertexSource> 
-    struct conv_bspline : public conv_adaptor_vcgen<VertexSource, vcgen_bspline>
-    {
-        typedef conv_adaptor_vcgen<VertexSource, vcgen_bspline> base_type;
-
-        conv_bspline(VertexSource& vs) : 
-            conv_adaptor_vcgen<VertexSource, vcgen_bspline>(vs) {}
-
-        void   interpolation_step(double v) { base_type::generator().interpolation_step(v); }
-        double interpolation_step() const { return base_type::generator().interpolation_step(); }
-
-    private:
-        conv_bspline(const conv_bspline<VertexSource>&);
-        const conv_bspline<VertexSource>& 
-            operator = (const conv_bspline<VertexSource>&);
-    };
-
-}
-
-
-#endif
-

Sources/libagg/agg-2.4/agg_conv_clip_polygon.h

@@ -1,63 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// Polygon clipping converter
-// There an optimized Liang-Basky algorithm is used. 
-// The algorithm doesn't optimize the degenerate edges, i.e. it will never
-// break a closed polygon into two or more ones, instead, there will be 
-// degenerate edges coinciding with the respective clipping boundaries.
-// This is a sub-optimal solution, because that optimization would require 
-// extra, rather expensive math while the rasterizer tolerates it quite well, 
-// without any considerable overhead.
-//
-//----------------------------------------------------------------------------
-#ifndef AGG_CONV_CLIP_POLYGON_INCLUDED
-#define AGG_CONV_CLIP_POLYGON_INCLUDED
-
-#include "agg_basics.h"
-#include "agg_conv_adaptor_vpgen.h"
-#include "agg_vpgen_clip_polygon.h"
-
-namespace agg
-{
-
-    //=======================================================conv_clip_polygon
-    template<class VertexSource> 
-    struct conv_clip_polygon : public conv_adaptor_vpgen<VertexSource, vpgen_clip_polygon>
-    {
-        typedef conv_adaptor_vpgen<VertexSource, vpgen_clip_polygon> base_type;
-
-        conv_clip_polygon(VertexSource& vs) : 
-            conv_adaptor_vpgen<VertexSource, vpgen_clip_polygon>(vs) {}
-
-        void clip_box(double x1, double y1, double x2, double y2)
-        {
-            base_type::vpgen().clip_box(x1, y1, x2, y2);
-        }
-
-        double x1() const { return base_type::vpgen().x1(); }
-        double y1() const { return base_type::vpgen().y1(); }
-        double x2() const { return base_type::vpgen().x2(); }
-        double y2() const { return base_type::vpgen().y2(); }
-
-    private:
-        conv_clip_polygon(const conv_clip_polygon<VertexSource>&);
-        const conv_clip_polygon<VertexSource>& 
-            operator = (const conv_clip_polygon<VertexSource>&);
-    };
-
-}
-
-#endif

Sources/libagg/agg-2.4/agg_conv_clip_polyline.h

@@ -1,63 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// polyline clipping converter
-// There an optimized Liang-Basky algorithm is used. 
-// The algorithm doesn't optimize the degenerate edges, i.e. it will never
-// break a closed polyline into two or more ones, instead, there will be 
-// degenerate edges coinciding with the respective clipping boundaries.
-// This is a sub-optimal solution, because that optimization would require 
-// extra, rather expensive math while the rasterizer tolerates it quite well, 
-// without any considerable overhead.
-//
-//----------------------------------------------------------------------------
-#ifndef AGG_CONV_CLIP_polyline_INCLUDED
-#define AGG_CONV_CLIP_polyline_INCLUDED
-
-#include "agg_basics.h"
-#include "agg_conv_adaptor_vpgen.h"
-#include "agg_vpgen_clip_polyline.h"
-
-namespace agg
-{
-
-    //=======================================================conv_clip_polyline
-    template<class VertexSource> 
-    struct conv_clip_polyline : public conv_adaptor_vpgen<VertexSource, vpgen_clip_polyline>
-    {
-        typedef conv_adaptor_vpgen<VertexSource, vpgen_clip_polyline> base_type;
-
-        conv_clip_polyline(VertexSource& vs) : 
-            conv_adaptor_vpgen<VertexSource, vpgen_clip_polyline>(vs) {}
-
-        void clip_box(double x1, double y1, double x2, double y2)
-        {
-            base_type::vpgen().clip_box(x1, y1, x2, y2);
-        }
-
-        double x1() const { return base_type::vpgen().x1(); }
-        double y1() const { return base_type::vpgen().y1(); }
-        double x2() const { return base_type::vpgen().x2(); }
-        double y2() const { return base_type::vpgen().y2(); }
-
-    private:
-        conv_clip_polyline(const conv_clip_polyline<VertexSource>&);
-        const conv_clip_polyline<VertexSource>& 
-            operator = (const conv_clip_polyline<VertexSource>&);
-    };
-
-}
-
-#endif

Sources/libagg/agg-2.4/agg_conv_close_polygon.h

@@ -1,125 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-
-#ifndef AGG_CONV_CLOSE_POLYGON_INCLUDED
-#define AGG_CONV_CLOSE_POLYGON_INCLUDED
-
-#include "agg_basics.h"
-
-namespace agg
-{
-
-    //======================================================conv_close_polygon
-    template<class VertexSource> class conv_close_polygon
-    {
-    public:
-        explicit conv_close_polygon(VertexSource& vs) : m_source(&vs) {}
-        void attach(VertexSource& source) { m_source = &source; }
-
-        void rewind(unsigned path_id);
-        unsigned vertex(double* x, double* y);
-
-    private:
-        conv_close_polygon(const conv_close_polygon<VertexSource>&);
-        const conv_close_polygon<VertexSource>& 
-            operator = (const conv_close_polygon<VertexSource>&);
-
-        VertexSource* m_source;
-        unsigned      m_cmd[2];
-        double        m_x[2];
-        double        m_y[2];
-        unsigned      m_vertex;
-        bool          m_line_to;
-    };
-
-
-
-    //------------------------------------------------------------------------
-    template<class VertexSource> 
-    void conv_close_polygon<VertexSource>::rewind(unsigned path_id)
-    {
-        m_source->rewind(path_id);
-        m_vertex = 2;
-        m_line_to = false;
-    }
-
-
-    
-    //------------------------------------------------------------------------
-    template<class VertexSource> 
-    unsigned conv_close_polygon<VertexSource>::vertex(double* x, double* y)
-    {
-        unsigned cmd = path_cmd_stop;
-        for(;;)
-        {
-            if(m_vertex < 2)
-            {
-                *x = m_x[m_vertex];
-                *y = m_y[m_vertex];
-                cmd = m_cmd[m_vertex];
-                ++m_vertex;
-                break;
-            }
-
-            cmd = m_source->vertex(x, y);
-
-            if(is_end_poly(cmd))
-            {
-                cmd |= path_flags_close;
-                break;
-            }
-
-            if(is_stop(cmd))
-            {
-                if(m_line_to)
-                {
-                    m_cmd[0]  = path_cmd_end_poly | path_flags_close;
-                    m_cmd[1]  = path_cmd_stop;
-                    m_vertex  = 0;
-                    m_line_to = false;
-                    continue;
-                }
-                break;
-            }
-
-            if(is_move_to(cmd))
-            {
-                if(m_line_to)
-                {
-                    m_x[0]    = 0.0;
-                    m_y[0]    = 0.0;
-                    m_cmd[0]  = path_cmd_end_poly | path_flags_close;
-                    m_x[1]    = *x;
-                    m_y[1]    = *y;
-                    m_cmd[1]  = cmd;
-                    m_vertex  = 0;
-                    m_line_to = false;
-                    continue;
-                }
-                break;
-            }
-
-            if(is_vertex(cmd))
-            {
-                m_line_to = true;
-                break;
-            }
-        }
-        return cmd;
-    }
-
-}
-
-#endif

Sources/libagg/agg-2.4/agg_conv_concat.h

@@ -1,73 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-
-#ifndef AGG_CONV_CONCAT_INCLUDED
-#define AGG_CONV_CONCAT_INCLUDED
-
-#include "agg_basics.h"
-
-namespace agg
-{
-    //=============================================================conv_concat
-    // Concatenation of two paths. Usually used to combine lines or curves 
-    // with markers such as arrowheads
-    template<class VS1, class VS2> class conv_concat
-    {
-    public:
-        conv_concat(VS1& source1, VS2& source2) :
-            m_source1(&source1), m_source2(&source2), m_status(2) {}
-        void attach1(VS1& source) { m_source1 = &source; }
-        void attach2(VS2& source) { m_source2 = &source; }
-
-
-        void rewind(unsigned path_id)
-        { 
-            m_source1->rewind(path_id);
-            m_source2->rewind(0);
-            m_status = 0;
-        }
-
-        unsigned vertex(double* x, double* y)
-        {
-            unsigned cmd;
-            if(m_status == 0)
-            {
-                cmd = m_source1->vertex(x, y);
-                if(!is_stop(cmd)) return cmd;
-                m_status = 1;
-            }
-            if(m_status == 1)
-            {
-                cmd = m_source2->vertex(x, y);
-                if(!is_stop(cmd)) return cmd;
-                m_status = 2;
-            }
-            return path_cmd_stop;
-        }
-
-    private:
-        conv_concat(const conv_concat<VS1, VS2>&);
-        const conv_concat<VS1, VS2>& 
-            operator = (const conv_concat<VS1, VS2>&);
-
-        VS1* m_source1;
-        VS2* m_source2;
-        int  m_status;
-
-    };
-}
-
-
-#endif

Sources/libagg/agg-2.4/agg_conv_contour.h

@@ -1,65 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// conv_stroke
-//
-//----------------------------------------------------------------------------
-#ifndef AGG_CONV_CONTOUR_INCLUDED
-#define AGG_CONV_CONTOUR_INCLUDED
-
-#include "agg_basics.h"
-#include "agg_vcgen_contour.h"
-#include "agg_conv_adaptor_vcgen.h"
-
-namespace agg
-{
-
-    //-----------------------------------------------------------conv_contour
-    template<class VertexSource> 
-    struct conv_contour : public conv_adaptor_vcgen<VertexSource, vcgen_contour>
-    {
-        typedef conv_adaptor_vcgen<VertexSource, vcgen_contour> base_type;
-
-        conv_contour(VertexSource& vs) : 
-            conv_adaptor_vcgen<VertexSource, vcgen_contour>(vs)
-        {
-        }
-
-        void line_join(line_join_e lj) { base_type::generator().line_join(lj); }
-        void inner_join(inner_join_e ij) { base_type::generator().inner_join(ij); }
-        void width(double w) { base_type::generator().width(w); }
-        void miter_limit(double ml) { base_type::generator().miter_limit(ml); }
-        void miter_limit_theta(double t) { base_type::generator().miter_limit_theta(t); }
-        void inner_miter_limit(double ml) { base_type::generator().inner_miter_limit(ml); }
-        void approximation_scale(double as) { base_type::generator().approximation_scale(as); }
-        void auto_detect_orientation(bool v) { base_type::generator().auto_detect_orientation(v); }
-
-        line_join_e line_join() const { return base_type::generator().line_join(); }
-        inner_join_e inner_join() const { return base_type::generator().inner_join(); }
-        double width() const { return base_type::generator().width(); }
-        double miter_limit() const { return base_type::generator().miter_limit(); }
-        double inner_miter_limit() const { return base_type::generator().inner_miter_limit(); }
-        double approximation_scale() const { return base_type::generator().approximation_scale(); }
-        bool auto_detect_orientation() const { return base_type::generator().auto_detect_orientation(); }
-
-    private:
-        conv_contour(const conv_contour<VertexSource>&);
-        const conv_contour<VertexSource>& 
-            operator = (const conv_contour<VertexSource>&);
-    };
-
-}
-
-#endif

Sources/libagg/agg-2.4/agg_conv_curve.h

@@ -1,201 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// classes conv_curve
-//
-//----------------------------------------------------------------------------
-
-#ifndef AGG_CONV_CURVE_INCLUDED
-#define AGG_CONV_CURVE_INCLUDED
-
-#include "agg_basics.h"
-#include "agg_curves.h"
-
-namespace agg
-{
-
-
-    //---------------------------------------------------------------conv_curve
-    // Curve converter class. Any path storage can have Bezier curves defined 
-    // by their control points. There're two types of curves supported: curve3 
-    // and curve4. Curve3 is a conic Bezier curve with 2 endpoints and 1 control
-    // point. Curve4 has 2 control points (4 points in total) and can be used
-    // to interpolate more complicated curves. Curve4, unlike curve3 can be used 
-    // to approximate arcs, both circular and elliptical. Curves are approximated 
-    // with straight lines and one of the approaches is just to store the whole 
-    // sequence of vertices that approximate our curve. It takes additional 
-    // memory, and at the same time the consecutive vertices can be calculated 
-    // on demand. 
-    //
-    // Initially, path storages are not suppose to keep all the vertices of the
-    // curves (although, nothing prevents us from doing so). Instead, path_storage
-    // keeps only vertices, needed to calculate a curve on demand. Those vertices
-    // are marked with special commands. So, if the path_storage contains curves 
-    // (which are not real curves yet), and we render this storage directly, 
-    // all we will see is only 2 or 3 straight line segments (for curve3 and 
-    // curve4 respectively). If we need to see real curves drawn we need to 
-    // include this class into the conversion pipeline. 
-    //
-    // Class conv_curve recognizes commands path_cmd_curve3 and path_cmd_curve4 
-    // and converts these vertices into a move_to/line_to sequence. 
-    //-----------------------------------------------------------------------
-    template<class VertexSource, 
-             class Curve3=curve3, 
-             class Curve4=curve4> class conv_curve
-    {
-    public:
-        typedef Curve3 curve3_type;
-        typedef Curve4 curve4_type;
-        typedef conv_curve<VertexSource, Curve3, Curve4> self_type;
-
-        explicit conv_curve(VertexSource& source) :
-          m_source(&source), m_last_x(0.0), m_last_y(0.0) {}
-        void attach(VertexSource& source) { m_source = &source; }
-
-        void approximation_method(curve_approximation_method_e v) 
-        { 
-            m_curve3.approximation_method(v);
-            m_curve4.approximation_method(v);
-        }
-
-        curve_approximation_method_e approximation_method() const 
-        { 
-            return m_curve4.approximation_method();
-        }
-
-        void approximation_scale(double s) 
-        { 
-            m_curve3.approximation_scale(s); 
-            m_curve4.approximation_scale(s); 
-        }
-
-        double approximation_scale() const 
-        { 
-            return m_curve4.approximation_scale();  
-        }
-
-        void angle_tolerance(double v) 
-        { 
-            m_curve3.angle_tolerance(v); 
-            m_curve4.angle_tolerance(v); 
-        }
-
-        double angle_tolerance() const 
-        { 
-            return m_curve4.angle_tolerance();  
-        }
-
-        void cusp_limit(double v) 
-        { 
-            m_curve3.cusp_limit(v); 
-            m_curve4.cusp_limit(v); 
-        }
-
-        double cusp_limit() const 
-        { 
-            return m_curve4.cusp_limit();  
-        }
-
-        void     rewind(unsigned path_id); 
-        unsigned vertex(double* x, double* y);
-
-    private:
-        conv_curve(const self_type&);
-        const self_type& operator = (const self_type&);
-
-        VertexSource* m_source;
-        double        m_last_x;
-        double        m_last_y;
-        curve3_type   m_curve3;
-        curve4_type   m_curve4;
-    };
-
-
-
-    //------------------------------------------------------------------------
-    template<class VertexSource, class Curve3, class Curve4>
-    void conv_curve<VertexSource, Curve3, Curve4>::rewind(unsigned path_id)
-    {
-        m_source->rewind(path_id);
-        m_last_x = 0.0;
-        m_last_y = 0.0;
-        m_curve3.reset();
-        m_curve4.reset();
-    }
-
-
-    //------------------------------------------------------------------------
-    template<class VertexSource, class Curve3, class Curve4>
-    unsigned conv_curve<VertexSource, Curve3, Curve4>::vertex(double* x, double* y)
-    {
-        if(!is_stop(m_curve3.vertex(x, y)))
-        {
-            m_last_x = *x;
-            m_last_y = *y;
-            return path_cmd_line_to;
-        }
-
-        if(!is_stop(m_curve4.vertex(x, y)))
-        {
-            m_last_x = *x;
-            m_last_y = *y;
-            return path_cmd_line_to;
-        }
-
-        double ct2_x;
-        double ct2_y;
-        double end_x;
-        double end_y;
-
-        unsigned cmd = m_source->vertex(x, y);
-        switch(cmd)
-        {
-        case path_cmd_curve3:
-            m_source->vertex(&end_x, &end_y);
-
-            m_curve3.init(m_last_x, m_last_y, 
-                          *x,       *y, 
-                          end_x,     end_y);
-
-            m_curve3.vertex(x, y);    // First call returns path_cmd_move_to
-            m_curve3.vertex(x, y);    // This is the first vertex of the curve
-            cmd = path_cmd_line_to;
-            break;
-
-        case path_cmd_curve4:
-            m_source->vertex(&ct2_x, &ct2_y);
-            m_source->vertex(&end_x, &end_y);
-
-            m_curve4.init(m_last_x, m_last_y, 
-                          *x,       *y, 
-                          ct2_x,    ct2_y, 
-                          end_x,    end_y);
-
-            m_curve4.vertex(x, y);    // First call returns path_cmd_move_to
-            m_curve4.vertex(x, y);    // This is the first vertex of the curve
-            cmd = path_cmd_line_to;
-            break;
-        }
-        m_last_x = *x;
-        m_last_y = *y;
-        return cmd;
-    }
-
-
-}
-
-
-
-#endif

Sources/libagg/agg-2.4/agg_conv_dash.h

@@ -1,68 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// conv_dash
-//
-//----------------------------------------------------------------------------
-#ifndef AGG_CONV_DASH_INCLUDED
-#define AGG_CONV_DASH_INCLUDED
-
-#include "agg_basics.h"
-#include "agg_vcgen_dash.h"
-#include "agg_conv_adaptor_vcgen.h"
-
-namespace agg
-{
-
-    //---------------------------------------------------------------conv_dash
-    template<class VertexSource, class Markers=null_markers> 
-    struct conv_dash : public conv_adaptor_vcgen<VertexSource, vcgen_dash, Markers>
-    {
-        typedef Markers marker_type;
-        typedef conv_adaptor_vcgen<VertexSource, vcgen_dash, Markers> base_type;
-
-        conv_dash(VertexSource& vs) : 
-            conv_adaptor_vcgen<VertexSource, vcgen_dash, Markers>(vs)
-        {
-        }
-
-        void remove_all_dashes() 
-        { 
-            base_type::generator().remove_all_dashes(); 
-        }
-
-        void add_dash(double dash_len, double gap_len) 
-        { 
-            base_type::generator().add_dash(dash_len, gap_len); 
-        }
-
-        void dash_start(double ds) 
-        { 
-            base_type::generator().dash_start(ds); 
-        }
-
-        void shorten(double s) { base_type::generator().shorten(s); }
-        double shorten() const { return base_type::generator().shorten(); }
-
-    private:
-        conv_dash(const conv_dash<VertexSource, Markers>&);
-        const conv_dash<VertexSource, Markers>& 
-            operator = (const conv_dash<VertexSource, Markers>&);
-    };
-
-
-}
-
-#endif

Sources/libagg/agg-2.4/agg_conv_gpc.h

@@ -1,432 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// General Polygon Clipper based on the GPC library by Alan Murta 
-// Union, Intersection, XOR, A-B, B-A
-// Contact the author if you intend to use it in commercial applications!
-// http://www.cs.man.ac.uk/aig/staff/alan/software/
-// Alan Murta (email: gpc@cs.man.ac.uk)
-//
-//----------------------------------------------------------------------------
-
-#ifndef AGG_CONV_GPC_INCLUDED
-#define AGG_CONV_GPC_INCLUDED
-
-#include <math.h>
-#include "agg_basics.h"
-#include "agg_array.h"
-
-extern "C" 
-{ 
-#include "gpc.h" 
-}
-
-namespace agg
-{
-    enum gpc_op_e
-    {
-        gpc_or,
-        gpc_and,
-        gpc_xor,
-        gpc_a_minus_b,
-        gpc_b_minus_a
-    };
-
-
-    //================================================================conv_gpc
-    template<class VSA, class VSB> class conv_gpc
-    {
-        enum status
-        {
-            status_move_to,
-            status_line_to,
-            status_stop
-        };
-
-        struct contour_header_type
-        {
-            int num_vertices;
-            int hole_flag;
-            gpc_vertex* vertices;
-        };
-
-        typedef pod_bvector<gpc_vertex, 8>          vertex_array_type;
-        typedef pod_bvector<contour_header_type, 6> contour_header_array_type;
-
-
-    public:
-        typedef VSA source_a_type;
-        typedef VSB source_b_type;
-        typedef conv_gpc<source_a_type, source_b_type> self_type;
-
-        ~conv_gpc()
-        {
-            free_gpc_data();
-        }
-
-        conv_gpc(source_a_type& a, source_b_type& b, gpc_op_e op = gpc_or) :
-            m_src_a(&a),
-            m_src_b(&b),
-            m_status(status_move_to),
-            m_vertex(-1),
-            m_contour(-1),
-            m_operation(op)
-        {
-            memset(&m_poly_a, 0, sizeof(m_poly_a));
-            memset(&m_poly_b, 0, sizeof(m_poly_b));
-            memset(&m_result, 0, sizeof(m_result));
-        }
-
-        void attach1(VSA& source) { m_src_a = &source; }
-        void attach2(VSB& source) { m_src_b = &source; }
-
-        void operation(gpc_op_e v) { m_operation = v; }
-
-        // Vertex Source Interface
-        void     rewind(unsigned path_id);
-        unsigned vertex(double* x, double* y);
-
-    private:
-        conv_gpc(const conv_gpc<VSA, VSB>&);
-        const conv_gpc<VSA, VSB>& operator = (const conv_gpc<VSA, VSB>&);
-
-        //--------------------------------------------------------------------
-        void free_polygon(gpc_polygon& p);
-        void free_result();
-        void free_gpc_data();
-        void start_contour();
-        void add_vertex(double x, double y);
-        void end_contour(unsigned orientation);
-        void make_polygon(gpc_polygon& p);
-        void start_extracting();
-        bool next_contour();
-        bool next_vertex(double* x, double* y);
-
-
-        //--------------------------------------------------------------------
-        template<class VS> void add(VS& src, gpc_polygon& p)
-        {
-            unsigned cmd;
-            double x, y;
-            double start_x = 0.0;
-            double start_y = 0.0;
-            bool line_to = false;
-            unsigned orientation = 0;
-
-            m_contour_accumulator.remove_all();
-
-            while(!is_stop(cmd = src.vertex(&x, &y)))
-            {
-                if(is_vertex(cmd))
-                {
-                    if(is_move_to(cmd))
-                    {
-                        if(line_to)
-                        {
-                            end_contour(orientation);
-                            orientation = 0;
-                        }
-                        start_contour();
-                        start_x = x;
-                        start_y = y;
-                    }
-                    add_vertex(x, y);
-                    line_to = true;
-                }
-                else
-                {
-                    if(is_end_poly(cmd))
-                    {
-                        orientation = get_orientation(cmd);
-                        if(line_to && is_closed(cmd))
-                        {
-                            add_vertex(start_x, start_y);
-                        }
-                    }
-                }
-            }
-            if(line_to)
-            {
-                end_contour(orientation);
-            }
-            make_polygon(p);
-        }
-
-
-    private:
-        //--------------------------------------------------------------------
-        source_a_type*             m_src_a;
-        source_b_type*             m_src_b;
-        status                     m_status;
-        int                        m_vertex;
-        int                        m_contour;
-        gpc_op_e                   m_operation;
-        vertex_array_type          m_vertex_accumulator;
-        contour_header_array_type  m_contour_accumulator;
-        gpc_polygon                m_poly_a;
-        gpc_polygon                m_poly_b;
-        gpc_polygon                m_result;
-    };
-
-
-
-
-
-    //------------------------------------------------------------------------
-    template<class VSA, class VSB> 
-    void conv_gpc<VSA, VSB>::free_polygon(gpc_polygon& p)
-    {
-        int i;
-        for(i = 0; i < p.num_contours; i++)
-        {
-            pod_allocator<gpc_vertex>::deallocate(p.contour[i].vertex, 
-                                                  p.contour[i].num_vertices);
-        }
-        pod_allocator<gpc_vertex_list>::deallocate(p.contour, p.num_contours);
-        memset(&p, 0, sizeof(gpc_polygon));
-    }
-
-
-    //------------------------------------------------------------------------
-    template<class VSA, class VSB> 
-    void conv_gpc<VSA, VSB>::free_result()
-    {
-        if(m_result.contour)
-        {
-            gpc_free_polygon(&m_result);
-        }
-        memset(&m_result, 0, sizeof(m_result));
-    }
-
-
-    //------------------------------------------------------------------------
-    template<class VSA, class VSB> 
-    void conv_gpc<VSA, VSB>::free_gpc_data()
-    {
-        free_polygon(m_poly_a);
-        free_polygon(m_poly_b);
-        free_result();
-    }
-
-
-    //------------------------------------------------------------------------
-    template<class VSA, class VSB> 
-    void conv_gpc<VSA, VSB>::start_contour()
-    {
-        contour_header_type h;
-        memset(&h, 0, sizeof(h));
-        m_contour_accumulator.add(h);
-        m_vertex_accumulator.remove_all();
-    }
-
-
-    //------------------------------------------------------------------------
-    template<class VSA, class VSB> 
-    inline void conv_gpc<VSA, VSB>::add_vertex(double x, double y)
-    {
-        gpc_vertex v;
-        v.x = x;
-        v.y = y;
-        m_vertex_accumulator.add(v);
-    }
-
-
-    //------------------------------------------------------------------------
-    template<class VSA, class VSB> 
-    void conv_gpc<VSA, VSB>::end_contour(unsigned orientation)
-    {
-        if(m_contour_accumulator.size())
-        {
-            if(m_vertex_accumulator.size() > 2)
-            {
-                contour_header_type& h = 
-                    m_contour_accumulator[m_contour_accumulator.size() - 1];
-
-                h.num_vertices = m_vertex_accumulator.size();
-                h.hole_flag = 0;
-
-                // TO DO: Clarify the "holes"
-                //if(is_cw(orientation)) h.hole_flag = 1;
-
-                h.vertices = pod_allocator<gpc_vertex>::allocate(h.num_vertices);
-                gpc_vertex* d = h.vertices;
-                int i;
-                for(i = 0; i < h.num_vertices; i++)
-                {
-                    const gpc_vertex& s = m_vertex_accumulator[i];
-                    d->x = s.x;
-                    d->y = s.y;
-                    ++d;
-                }
-            }
-            else
-            {
-                m_vertex_accumulator.remove_last();
-            }
-        }
-    }
-
-
-    //------------------------------------------------------------------------
-    template<class VSA, class VSB> 
-    void conv_gpc<VSA, VSB>::make_polygon(gpc_polygon& p)
-    {
-        free_polygon(p);
-        if(m_contour_accumulator.size())
-        {
-            p.num_contours = m_contour_accumulator.size();
-
-            p.hole = 0;
-            p.contour = pod_allocator<gpc_vertex_list>::allocate(p.num_contours);
-
-            int i;
-            gpc_vertex_list* pv = p.contour;
-            for(i = 0; i < p.num_contours; i++)
-            {
-                const contour_header_type& h = m_contour_accumulator[i];
-                pv->num_vertices = h.num_vertices;
-                pv->vertex = h.vertices;
-                ++pv;
-            }
-        }
-    }
-
-
-    //------------------------------------------------------------------------
-    template<class VSA, class VSB> 
-    void conv_gpc<VSA, VSB>::start_extracting()
-    {
-        m_status = status_move_to;
-        m_contour = -1;
-        m_vertex = -1;
-    }
-
-
-    //------------------------------------------------------------------------
-    template<class VSA, class VSB> 
-    bool conv_gpc<VSA, VSB>::next_contour()
-    {
-        if(++m_contour < m_result.num_contours)
-        {
-            m_vertex = -1;
-            return true;
-        }
-        return false;
-    }
-
-
-    //------------------------------------------------------------------------
-    template<class VSA, class VSB> 
-    inline bool conv_gpc<VSA, VSB>::next_vertex(double* x, double* y)
-    {
-        const gpc_vertex_list& vlist = m_result.contour[m_contour];
-        if(++m_vertex < vlist.num_vertices)
-        {
-            const gpc_vertex& v = vlist.vertex[m_vertex];
-            *x = v.x;
-            *y = v.y;
-            return true;
-        }
-        return false;
-    }
-
-
-    //------------------------------------------------------------------------
-    template<class VSA, class VSB> 
-    void conv_gpc<VSA, VSB>::rewind(unsigned path_id)
-    {
-        free_result();
-        m_src_a->rewind(path_id);
-        m_src_b->rewind(path_id);
-        add(*m_src_a, m_poly_a);
-        add(*m_src_b, m_poly_b);
-        switch(m_operation)
-        {
-           case gpc_or:
-                gpc_polygon_clip(GPC_UNION,
-                                 &m_poly_a,
-                                 &m_poly_b,
-                                 &m_result);
-               break;
-
-           case gpc_and:
-                gpc_polygon_clip(GPC_INT,
-                                 &m_poly_a,
-                                 &m_poly_b,
-                                 &m_result);
-               break;
-
-           case gpc_xor:
-                gpc_polygon_clip(GPC_XOR,
-                                 &m_poly_a,
-                                 &m_poly_b,
-                                 &m_result);
-               break;
-
-           case gpc_a_minus_b:
-                gpc_polygon_clip(GPC_DIFF,
-                                 &m_poly_a,
-                                 &m_poly_b,
-                                 &m_result);
-               break;
-
-           case gpc_b_minus_a:
-                gpc_polygon_clip(GPC_DIFF,
-                                 &m_poly_b,
-                                 &m_poly_a,
-                                 &m_result);
-               break;
-        }
-        start_extracting();
-    }
-
-
-    //------------------------------------------------------------------------
-    template<class VSA, class VSB> 
-    unsigned conv_gpc<VSA, VSB>::vertex(double* x, double* y)
-    {
-        if(m_status == status_move_to)
-        {
-            if(next_contour()) 
-            {
-                if(next_vertex(x, y))
-                {
-                    m_status = status_line_to;
-                    return path_cmd_move_to;
-                }
-                m_status = status_stop;
-                return path_cmd_end_poly | path_flags_close;
-            }
-        }
-        else
-        {
-            if(next_vertex(x, y))
-            {
-                return path_cmd_line_to;
-            }
-            else
-            {
-                m_status = status_move_to;
-            }
-            return path_cmd_end_poly | path_flags_close;
-        }
-        return path_cmd_stop;
-    }
-
-   
-}
-
-
-#endif

Sources/libagg/agg-2.4/agg_conv_marker.h

@@ -1,148 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// conv_marker
-//
-//----------------------------------------------------------------------------
-#ifndef AGG_CONV_MARKER_INCLUDED
-#define AGG_CONV_MARKER_INCLUDED
-
-#include "agg_basics.h"
-#include "agg_trans_affine.h"
-
-namespace agg
-{
-    //-------------------------------------------------------------conv_marker
-    template<class MarkerLocator, class MarkerShapes>
-    class conv_marker
-    {
-    public:
-        conv_marker(MarkerLocator& ml, MarkerShapes& ms);
-
-        trans_affine& transform() { return m_transform; }
-        const trans_affine& transform() const { return m_transform; }
-
-        void rewind(unsigned path_id);
-        unsigned vertex(double* x, double* y);
-
-    private:
-        conv_marker(const conv_marker<MarkerLocator, MarkerShapes>&);
-        const conv_marker<MarkerLocator, MarkerShapes>& 
-            operator = (const conv_marker<MarkerLocator, MarkerShapes>&);
-
-        enum status_e 
-        {
-            initial,
-            markers,
-            polygon,
-            stop
-        };
-
-        MarkerLocator* m_marker_locator;
-        MarkerShapes*  m_marker_shapes;
-        trans_affine   m_transform;
-        trans_affine   m_mtx;
-        status_e       m_status;
-        unsigned       m_marker;
-        unsigned       m_num_markers;
-    };
-
-
-    //------------------------------------------------------------------------
-    template<class MarkerLocator, class MarkerShapes> 
-    conv_marker<MarkerLocator, MarkerShapes>::conv_marker(MarkerLocator& ml, MarkerShapes& ms) :
-        m_marker_locator(&ml),
-        m_marker_shapes(&ms),
-        m_status(initial),
-        m_marker(0),
-        m_num_markers(1)
-    {
-    }
-
-
-    //------------------------------------------------------------------------
-    template<class MarkerLocator, class MarkerShapes> 
-    void conv_marker<MarkerLocator, MarkerShapes>::rewind(unsigned)
-    {
-        m_status = initial;
-        m_marker = 0;
-        m_num_markers = 1;
-    }
-
-
-    //------------------------------------------------------------------------
-    template<class MarkerLocator, class MarkerShapes> 
-    unsigned conv_marker<MarkerLocator, MarkerShapes>::vertex(double* x, double* y)
-    {
-        unsigned cmd = path_cmd_move_to;
-        double x1, y1, x2, y2;
-
-        while(!is_stop(cmd))
-        {
-            switch(m_status)
-            {
-            case initial:
-                if(m_num_markers == 0)
-                {
-                   cmd = path_cmd_stop;
-                   break;
-                }
-                m_marker_locator->rewind(m_marker);
-                ++m_marker;
-                m_num_markers = 0;
-                m_status = markers;
-
-            case markers:
-                if(is_stop(m_marker_locator->vertex(&x1, &y1)))
-                {
-                    m_status = initial;
-                    break;
-                }
-                if(is_stop(m_marker_locator->vertex(&x2, &y2)))
-                {
-                    m_status = initial;
-                    break;
-                }
-                ++m_num_markers;
-                m_mtx = m_transform;
-                m_mtx *= trans_affine_rotation(atan2(y2 - y1, x2 - x1));
-                m_mtx *= trans_affine_translation(x1, y1);
-                m_marker_shapes->rewind(m_marker - 1);
-                m_status = polygon;
-
-            case polygon:
-                cmd = m_marker_shapes->vertex(x, y);
-                if(is_stop(cmd))
-                {
-                    cmd = path_cmd_move_to;
-                    m_status = markers;
-                    break;
-                }
-                m_mtx.transform(x, y);
-                return cmd;
-
-            case stop:
-                cmd = path_cmd_stop;
-                break;
-            }
-        }
-        return cmd;
-    }
-
-}
-
-
-#endif
-

Sources/libagg/agg-2.4/agg_conv_marker_adaptor.h

@@ -1,51 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-
-#ifndef AGG_CONV_MARKER_ADAPTOR_INCLUDED
-#define AGG_CONV_MARKER_ADAPTOR_INCLUDED
-
-#include "agg_basics.h"
-#include "agg_conv_adaptor_vcgen.h"
-#include "agg_vcgen_vertex_sequence.h"
-
-namespace agg
-{
-
-    //=====================================================conv_marker_adaptor
-    template<class VertexSource, class Markers=null_markers>
-    struct conv_marker_adaptor : 
-    public conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence, Markers>
-    {
-        typedef Markers marker_type;
-        typedef conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence, Markers> base_type;
-
-        conv_marker_adaptor(VertexSource& vs) : 
-            conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence, Markers>(vs)
-        {
-        }
-
-        void shorten(double s) { base_type::generator().shorten(s); }
-        double shorten() const { return base_type::generator().shorten(); }
-
-    private:
-        conv_marker_adaptor(const conv_marker_adaptor<VertexSource, Markers>&);
-        const conv_marker_adaptor<VertexSource, Markers>& 
-            operator = (const conv_marker_adaptor<VertexSource, Markers>&);
-    };
-
-
-}
-
-#endif

Sources/libagg/agg-2.4/agg_conv_segmentator.h

@@ -1,48 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-
-#ifndef AGG_CONV_SEGMENTATOR_INCLUDED
-#define AGG_CONV_SEGMENTATOR_INCLUDED
-
-#include "agg_basics.h"
-#include "agg_conv_adaptor_vpgen.h"
-#include "agg_vpgen_segmentator.h"
-
-namespace agg
-{
-
-    //========================================================conv_segmentator
-    template<class VertexSource> 
-    struct conv_segmentator : public conv_adaptor_vpgen<VertexSource, vpgen_segmentator>
-    {
-        typedef conv_adaptor_vpgen<VertexSource, vpgen_segmentator> base_type;
-
-        conv_segmentator(VertexSource& vs) : 
-            conv_adaptor_vpgen<VertexSource, vpgen_segmentator>(vs) {}
-
-        void approximation_scale(double s) { base_type::vpgen().approximation_scale(s);        }
-        double approximation_scale() const { return base_type::vpgen().approximation_scale();  }
-
-    private:
-        conv_segmentator(const conv_segmentator<VertexSource>&);
-        const conv_segmentator<VertexSource>& 
-            operator = (const conv_segmentator<VertexSource>&);
-    };
-
-
-}
-
-#endif
-

Sources/libagg/agg-2.4/agg_conv_shorten_path.h

@@ -1,50 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-
-#ifndef AGG_CONV_SHORTEN_PATH_INCLUDED
-#define AGG_CONV_SHORTEN_PATH_INCLUDED
-
-#include "agg_basics.h"
-#include "agg_conv_adaptor_vcgen.h"
-#include "agg_vcgen_vertex_sequence.h"
-
-namespace agg
-{
-
-    //=======================================================conv_shorten_path
-    template<class VertexSource>  class conv_shorten_path : 
-    public conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence>
-    {
-    public:
-        typedef conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence> base_type;
-
-        conv_shorten_path(VertexSource& vs) : 
-            conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence>(vs)
-        {
-        }
-
-        void shorten(double s) { base_type::generator().shorten(s); }
-        double shorten() const { return base_type::generator().shorten(); }
-
-    private:
-        conv_shorten_path(const conv_shorten_path<VertexSource>&);
-        const conv_shorten_path<VertexSource>& 
-            operator = (const conv_shorten_path<VertexSource>&);
-    };
-
-
-}
-
-#endif

Sources/libagg/agg-2.4/agg_conv_smooth_poly1.h

@@ -1,80 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// Smooth polygon generator
-//
-//----------------------------------------------------------------------------
-#ifndef AGG_CONV_SMOOTH_POLY1_INCLUDED
-#define AGG_CONV_SMOOTH_POLY1_INCLUDED
-
-#include "agg_basics.h"
-#include "agg_vcgen_smooth_poly1.h"
-#include "agg_conv_adaptor_vcgen.h"
-#include "agg_conv_curve.h"
-
-
-namespace agg
-{
-
-    //-------------------------------------------------------conv_smooth_poly1
-    template<class VertexSource> 
-    struct conv_smooth_poly1 : 
-    public conv_adaptor_vcgen<VertexSource, vcgen_smooth_poly1>
-    {
-        typedef conv_adaptor_vcgen<VertexSource, vcgen_smooth_poly1> base_type;
-
-        conv_smooth_poly1(VertexSource& vs) : 
-            conv_adaptor_vcgen<VertexSource, vcgen_smooth_poly1>(vs)
-        {
-        }
-
-        void   smooth_value(double v) { base_type::generator().smooth_value(v); }
-        double smooth_value() const { return base_type::generator().smooth_value(); }
-
-    private:
-        conv_smooth_poly1(const conv_smooth_poly1<VertexSource>&);
-        const conv_smooth_poly1<VertexSource>& 
-            operator = (const conv_smooth_poly1<VertexSource>&);
-    };
-
-
-
-    //-------------------------------------------------conv_smooth_poly1_curve
-    template<class VertexSource> 
-    struct conv_smooth_poly1_curve : 
-    public conv_curve<conv_smooth_poly1<VertexSource> >
-    {
-        conv_smooth_poly1_curve(VertexSource& vs) :
-            conv_curve<conv_smooth_poly1<VertexSource> >(m_smooth),
-            m_smooth(vs)
-        {
-        }
-
-        void   smooth_value(double v) { m_smooth.generator().smooth_value(v); }
-        double smooth_value() const { return m_smooth.generator().smooth_value(); }
-
-    private:
-        conv_smooth_poly1_curve(const conv_smooth_poly1_curve<VertexSource>&);
-        const conv_smooth_poly1_curve<VertexSource>& 
-            operator = (const conv_smooth_poly1_curve<VertexSource>&);
-
-        conv_smooth_poly1<VertexSource> m_smooth;
-    };
-
-}
-
-
-#endif
-

Sources/libagg/agg-2.4/agg_conv_stroke.h

@@ -1,73 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// conv_stroke
-//
-//----------------------------------------------------------------------------
-#ifndef AGG_CONV_STROKE_INCLUDED
-#define AGG_CONV_STROKE_INCLUDED
-
-#include "agg_basics.h"
-#include "agg_vcgen_stroke.h"
-#include "agg_conv_adaptor_vcgen.h"
-
-namespace agg
-{
-
-    //-------------------------------------------------------------conv_stroke
-    template<class VertexSource, class Markers=null_markers> 
-    struct conv_stroke : 
-    public conv_adaptor_vcgen<VertexSource, vcgen_stroke, Markers>
-    {
-        typedef Markers marker_type;
-        typedef conv_adaptor_vcgen<VertexSource, vcgen_stroke, Markers> base_type;
-
-        conv_stroke(VertexSource& vs) : 
-            conv_adaptor_vcgen<VertexSource, vcgen_stroke, Markers>(vs)
-        {
-        }
-
-        void line_cap(line_cap_e lc)     { base_type::generator().line_cap(lc);  }
-        void line_join(line_join_e lj)   { base_type::generator().line_join(lj); }
-        void inner_join(inner_join_e ij) { base_type::generator().inner_join(ij); }
-
-        line_cap_e   line_cap()   const { return base_type::generator().line_cap();  }
-        line_join_e  line_join()  const { return base_type::generator().line_join(); }
-        inner_join_e inner_join() const { return base_type::generator().inner_join(); }
-
-        void width(double w) { base_type::generator().width(w); }
-        void miter_limit(double ml) { base_type::generator().miter_limit(ml); }
-        void miter_limit_theta(double t) { base_type::generator().miter_limit_theta(t); }
-        void inner_miter_limit(double ml) { base_type::generator().inner_miter_limit(ml); }
-        void approximation_scale(double as) { base_type::generator().approximation_scale(as); }
-
-        double width() const { return base_type::generator().width(); }
-        double miter_limit() const { return base_type::generator().miter_limit(); }
-        double inner_miter_limit() const { return base_type::generator().inner_miter_limit(); }
-        double approximation_scale() const { return base_type::generator().approximation_scale(); }
-
-        void shorten(double s) { base_type::generator().shorten(s); }
-        double shorten() const { return base_type::generator().shorten(); }
-
-    private:
-       conv_stroke(const conv_stroke<VertexSource, Markers>&);
-       const conv_stroke<VertexSource, Markers>& 
-           operator = (const conv_stroke<VertexSource, Markers>&);
-
-    };
-
-}
-
-#endif

Sources/libagg/agg-2.4/agg_conv_transform.h

@@ -1,68 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// class conv_transform
-//
-//----------------------------------------------------------------------------
-#ifndef AGG_CONV_TRANSFORM_INCLUDED
-#define AGG_CONV_TRANSFORM_INCLUDED
-
-#include "agg_basics.h"
-#include "agg_trans_affine.h"
-
-namespace agg
-{
-
-    //----------------------------------------------------------conv_transform
-    template<class VertexSource, class Transformer=trans_affine> class conv_transform
-    {
-    public:
-        conv_transform(VertexSource& source, const Transformer& tr) :
-            m_source(&source), m_trans(&tr) {}
-        void attach(VertexSource& source) { m_source = &source; }
-
-        void rewind(unsigned path_id) 
-        { 
-            m_source->rewind(path_id); 
-        }
-
-        unsigned vertex(double* x, double* y)
-        {
-            unsigned cmd = m_source->vertex(x, y);
-            if(is_vertex(cmd))
-            {
-                m_trans->transform(x, y);
-            }
-            return cmd;
-        }
-
-        void transformer(const Transformer& tr)
-        {
-            m_trans = &tr;
-        }
-
-    private:
-        conv_transform(const conv_transform<VertexSource>&);
-        const conv_transform<VertexSource>& 
-            operator = (const conv_transform<VertexSource>&);
-
-        VertexSource*      m_source;
-        const Transformer* m_trans;
-    };
-
-
-}
-
-#endif

Sources/libagg/agg-2.4/agg_conv_unclose_polygon.h

@@ -1,52 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-
-#ifndef AGG_CONV_UNCLOSE_POLYGON_INCLUDED
-#define AGG_CONV_UNCLOSE_POLYGON_INCLUDED
-
-#include "agg_basics.h"
-
-namespace agg
-{
-    //====================================================conv_unclose_polygon
-    template<class VertexSource> class conv_unclose_polygon
-    {
-    public:
-        explicit conv_unclose_polygon(VertexSource& vs) : m_source(&vs) {}
-        void attach(VertexSource& source) { m_source = &source; }
-
-        void rewind(unsigned path_id)
-        {
-            m_source->rewind(path_id);
-        }
-
-        unsigned vertex(double* x, double* y)
-        {
-            unsigned cmd = m_source->vertex(x, y);
-            if(is_end_poly(cmd)) cmd &= ~path_flags_close;
-            return cmd;
-        }
-
-    private:
-        conv_unclose_polygon(const conv_unclose_polygon<VertexSource>&);
-        const conv_unclose_polygon<VertexSource>& 
-            operator = (const conv_unclose_polygon<VertexSource>&);
-
-        VertexSource* m_source;
-    };
-
-}
-
-#endif

Sources/libagg/agg-2.4/agg_curves.cpp

@@ -1,611 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-
-#include <math.h>
-#include "agg_curves.h"
-#include "agg_math.h"
-
-namespace agg
-{
-
-    //------------------------------------------------------------------------
-    const double curve_distance_epsilon                  = 1e-30;
-    const double curve_collinearity_epsilon              = 1e-30;
-    const double curve_angle_tolerance_epsilon           = 0.01;
-    enum curve_recursion_limit_e { curve_recursion_limit = 32 };
-
-
-
-    //------------------------------------------------------------------------
-    void curve3_inc::approximation_scale(double s) 
-    { 
-        m_scale = s;
-    }
-
-    //------------------------------------------------------------------------
-    double curve3_inc::approximation_scale() const 
-    { 
-        return m_scale;
-    }
-
-    //------------------------------------------------------------------------
-    void curve3_inc::init(double x1, double y1, 
-                          double x2, double y2, 
-                          double x3, double y3)
-    {
-        m_start_x = x1;
-        m_start_y = y1;
-        m_end_x   = x3;
-        m_end_y   = y3;
-
-        double dx1 = x2 - x1;
-        double dy1 = y2 - y1;
-        double dx2 = x3 - x2;
-        double dy2 = y3 - y2;
-
-        double len = sqrt(dx1 * dx1 + dy1 * dy1) + sqrt(dx2 * dx2 + dy2 * dy2); 
-
-        m_num_steps = uround(len * 0.25 * m_scale);
-
-        if(m_num_steps < 4)
-        {
-            m_num_steps = 4;   
-        }
-
-        double subdivide_step  = 1.0 / m_num_steps;
-        double subdivide_step2 = subdivide_step * subdivide_step;
-
-        double tmpx = (x1 - x2 * 2.0 + x3) * subdivide_step2;
-        double tmpy = (y1 - y2 * 2.0 + y3) * subdivide_step2;
-
-        m_saved_fx = m_fx = x1;
-        m_saved_fy = m_fy = y1;
-        
-        m_saved_dfx = m_dfx = tmpx + (x2 - x1) * (2.0 * subdivide_step);
-        m_saved_dfy = m_dfy = tmpy + (y2 - y1) * (2.0 * subdivide_step);
-
-        m_ddfx = tmpx * 2.0;
-        m_ddfy = tmpy * 2.0;
-
-        m_step = m_num_steps;
-    }
-
-    //------------------------------------------------------------------------
-    void curve3_inc::rewind(unsigned)
-    {
-        if(m_num_steps == 0)
-        {
-            m_step = -1;
-            return;
-        }
-        m_step = m_num_steps;
-        m_fx   = m_saved_fx;
-        m_fy   = m_saved_fy;
-        m_dfx  = m_saved_dfx;
-        m_dfy  = m_saved_dfy;
-    }
-
-    //------------------------------------------------------------------------
-    unsigned curve3_inc::vertex(double* x, double* y)
-    {
-        if(m_step < 0) return path_cmd_stop;
-        if(m_step == m_num_steps)
-        {
-            *x = m_start_x;
-            *y = m_start_y;
-            --m_step;
-            return path_cmd_move_to;
-        }
-        if(m_step == 0)
-        {
-            *x = m_end_x;
-            *y = m_end_y;
-            --m_step;
-            return path_cmd_line_to;
-        }
-        m_fx  += m_dfx; 
-        m_fy  += m_dfy;
-        m_dfx += m_ddfx; 
-        m_dfy += m_ddfy; 
-        *x = m_fx;
-        *y = m_fy;
-        --m_step;
-        return path_cmd_line_to;
-    }
-
-    //------------------------------------------------------------------------
-    void curve3_div::init(double x1, double y1, 
-                          double x2, double y2, 
-                          double x3, double y3)
-    {
-        m_points.remove_all();
-        m_distance_tolerance_square = 0.5 / m_approximation_scale;
-        m_distance_tolerance_square *= m_distance_tolerance_square;
-        bezier(x1, y1, x2, y2, x3, y3);
-        m_count = 0;
-    }
-
-    //------------------------------------------------------------------------
-    void curve3_div::recursive_bezier(double x1, double y1, 
-                                      double x2, double y2, 
-                                      double x3, double y3,
-                                      unsigned level)
-    {
-        if(level > curve_recursion_limit) 
-        {
-            return;
-        }
-
-        // Calculate all the mid-points of the line segments
-        //----------------------
-        double x12   = (x1 + x2) / 2;                
-        double y12   = (y1 + y2) / 2;
-        double x23   = (x2 + x3) / 2;
-        double y23   = (y2 + y3) / 2;
-        double x123  = (x12 + x23) / 2;
-        double y123  = (y12 + y23) / 2;
-
-        double dx = x3-x1;
-        double dy = y3-y1;
-        double d = fabs(((x2 - x3) * dy - (y2 - y3) * dx));
-        double da;
-
-        if(d > curve_collinearity_epsilon)
-        { 
-            // Regular case
-            //-----------------
-            if(d * d <= m_distance_tolerance_square * (dx*dx + dy*dy))
-            {
-                // If the curvature doesn't exceed the distance_tolerance value
-                // we tend to finish subdivisions.
-                //----------------------
-                if(m_angle_tolerance < curve_angle_tolerance_epsilon)
-                {
-                    m_points.add(point_d(x123, y123));
-                    return;
-                }
-
-                // Angle & Cusp Condition
-                //----------------------
-                da = fabs(atan2(y3 - y2, x3 - x2) - atan2(y2 - y1, x2 - x1));
-                if(da >= pi) da = 2*pi - da;
-
-                if(da < m_angle_tolerance)
-                {
-                    // Finally we can stop the recursion
-                    //----------------------
-                    m_points.add(point_d(x123, y123));
-                    return;                 
-                }
-            }
-        }
-        else
-        {
-            // Collinear case
-            //------------------
-            da = dx*dx + dy*dy;
-            if(da == 0)
-            {
-                d = calc_sq_distance(x1, y1, x2, y2);
-            }
-            else
-            {
-                d = ((x2 - x1)*dx + (y2 - y1)*dy) / da;
-                if(d > 0 && d < 1)
-                {
-                    // Simple collinear case, 1---2---3
-                    // We can leave just two endpoints
-                    return;
-                }
-                     if(d <= 0) d = calc_sq_distance(x2, y2, x1, y1);
-                else if(d >= 1) d = calc_sq_distance(x2, y2, x3, y3);
-                else            d = calc_sq_distance(x2, y2, x1 + d*dx, y1 + d*dy);
-            }
-            if(d < m_distance_tolerance_square)
-            {
-                m_points.add(point_d(x2, y2));
-                return;
-            }
-        }
-
-        // Continue subdivision
-        //----------------------
-        recursive_bezier(x1, y1, x12, y12, x123, y123, level + 1); 
-        recursive_bezier(x123, y123, x23, y23, x3, y3, level + 1); 
-    }
-
-    //------------------------------------------------------------------------
-    void curve3_div::bezier(double x1, double y1, 
-                            double x2, double y2, 
-                            double x3, double y3)
-    {
-        m_points.add(point_d(x1, y1));
-        recursive_bezier(x1, y1, x2, y2, x3, y3, 0);
-        m_points.add(point_d(x3, y3));
-    }
-
-
-
-
-
-    //------------------------------------------------------------------------
-    void curve4_inc::approximation_scale(double s) 
-    { 
-        m_scale = s;
-    }
-
-    //------------------------------------------------------------------------
-    double curve4_inc::approximation_scale() const 
-    { 
-        return m_scale;
-    }
-
-    //------------------------------------------------------------------------
-    static double MSC60_fix_ICE(double v) { return v; }
-
-    //------------------------------------------------------------------------
-    void curve4_inc::init(double x1, double y1, 
-                          double x2, double y2, 
-                          double x3, double y3,
-                          double x4, double y4)
-    {
-        m_start_x = x1;
-        m_start_y = y1;
-        m_end_x   = x4;
-        m_end_y   = y4;
-
-        double dx1 = x2 - x1;
-        double dy1 = y2 - y1;
-        double dx2 = x3 - x2;
-        double dy2 = y3 - y2;
-        double dx3 = x4 - x3;
-        double dy3 = y4 - y3;
-
-        double len = (sqrt(dx1 * dx1 + dy1 * dy1) + 
-                      sqrt(dx2 * dx2 + dy2 * dy2) + 
-                      sqrt(dx3 * dx3 + dy3 * dy3)) * 0.25 * m_scale;
-
-#if defined(_MSC_VER) && _MSC_VER <= 1200
-        m_num_steps = uround(MSC60_fix_ICE(len));
-#else
-        m_num_steps = uround(len);
-#endif
-
-        if(m_num_steps < 4)
-        {
-            m_num_steps = 4;   
-        }
-
-        double subdivide_step  = 1.0 / m_num_steps;
-        double subdivide_step2 = subdivide_step * subdivide_step;
-        double subdivide_step3 = subdivide_step * subdivide_step * subdivide_step;
-
-        double pre1 = 3.0 * subdivide_step;
-        double pre2 = 3.0 * subdivide_step2;
-        double pre4 = 6.0 * subdivide_step2;
-        double pre5 = 6.0 * subdivide_step3;
-	
-        double tmp1x = x1 - x2 * 2.0 + x3;
-        double tmp1y = y1 - y2 * 2.0 + y3;
-
-        double tmp2x = (x2 - x3) * 3.0 - x1 + x4;
-        double tmp2y = (y2 - y3) * 3.0 - y1 + y4;
-
-        m_saved_fx = m_fx = x1;
-        m_saved_fy = m_fy = y1;
-
-        m_saved_dfx = m_dfx = (x2 - x1) * pre1 + tmp1x * pre2 + tmp2x * subdivide_step3;
-        m_saved_dfy = m_dfy = (y2 - y1) * pre1 + tmp1y * pre2 + tmp2y * subdivide_step3;
-
-        m_saved_ddfx = m_ddfx = tmp1x * pre4 + tmp2x * pre5;
-        m_saved_ddfy = m_ddfy = tmp1y * pre4 + tmp2y * pre5;
-
-        m_dddfx = tmp2x * pre5;
-        m_dddfy = tmp2y * pre5;
-
-        m_step = m_num_steps;
-    }
-
-    //------------------------------------------------------------------------
-    void curve4_inc::rewind(unsigned)
-    {
-        if(m_num_steps == 0)
-        {
-            m_step = -1;
-            return;
-        }
-        m_step = m_num_steps;
-        m_fx   = m_saved_fx;
-        m_fy   = m_saved_fy;
-        m_dfx  = m_saved_dfx;
-        m_dfy  = m_saved_dfy;
-        m_ddfx = m_saved_ddfx;
-        m_ddfy = m_saved_ddfy;
-    }
-
-    //------------------------------------------------------------------------
-    unsigned curve4_inc::vertex(double* x, double* y)
-    {
-        if(m_step < 0) return path_cmd_stop;
-        if(m_step == m_num_steps)
-        {
-            *x = m_start_x;
-            *y = m_start_y;
-            --m_step;
-            return path_cmd_move_to;
-        }
-
-        if(m_step == 0)
-        {
-            *x = m_end_x;
-            *y = m_end_y;
-            --m_step;
-            return path_cmd_line_to;
-        }
-
-        m_fx   += m_dfx;
-        m_fy   += m_dfy;
-        m_dfx  += m_ddfx; 
-        m_dfy  += m_ddfy; 
-        m_ddfx += m_dddfx; 
-        m_ddfy += m_dddfy; 
-
-        *x = m_fx;
-        *y = m_fy;
-        --m_step;
-        return path_cmd_line_to;
-    }
-
-
-
-
-    //------------------------------------------------------------------------
-    void curve4_div::init(double x1, double y1, 
-                          double x2, double y2, 
-                          double x3, double y3,
-                          double x4, double y4)
-    {
-        m_points.remove_all();
-        m_distance_tolerance_square = 0.5 / m_approximation_scale;
-        m_distance_tolerance_square *= m_distance_tolerance_square;
-        bezier(x1, y1, x2, y2, x3, y3, x4, y4);
-        m_count = 0;
-    }
-
-    //------------------------------------------------------------------------
-    void curve4_div::recursive_bezier(double x1, double y1, 
-                                      double x2, double y2, 
-                                      double x3, double y3, 
-                                      double x4, double y4,
-                                      unsigned level)
-    {
-        if(level > curve_recursion_limit) 
-        {
-            return;
-        }
-
-        // Calculate all the mid-points of the line segments
-        //----------------------
-        double x12   = (x1 + x2) / 2;
-        double y12   = (y1 + y2) / 2;
-        double x23   = (x2 + x3) / 2;
-        double y23   = (y2 + y3) / 2;
-        double x34   = (x3 + x4) / 2;
-        double y34   = (y3 + y4) / 2;
-        double x123  = (x12 + x23) / 2;
-        double y123  = (y12 + y23) / 2;
-        double x234  = (x23 + x34) / 2;
-        double y234  = (y23 + y34) / 2;
-        double x1234 = (x123 + x234) / 2;
-        double y1234 = (y123 + y234) / 2;
-
-
-        // Try to approximate the full cubic curve by a single straight line
-        //------------------
-        double dx = x4-x1;
-        double dy = y4-y1;
-
-        double d2 = fabs(((x2 - x4) * dy - (y2 - y4) * dx));
-        double d3 = fabs(((x3 - x4) * dy - (y3 - y4) * dx));
-        double da1, da2, k;
-
-        switch((int(d2 > curve_collinearity_epsilon) << 1) +
-                int(d3 > curve_collinearity_epsilon))
-        {
-        case 0:
-            // All collinear OR p1==p4
-            //----------------------
-            k = dx*dx + dy*dy;
-            if(k == 0)
-            {
-                d2 = calc_sq_distance(x1, y1, x2, y2);
-                d3 = calc_sq_distance(x4, y4, x3, y3);
-            }
-            else
-            {
-                k   = 1 / k;
-                da1 = x2 - x1;
-                da2 = y2 - y1;
-                d2  = k * (da1*dx + da2*dy);
-                da1 = x3 - x1;
-                da2 = y3 - y1;
-                d3  = k * (da1*dx + da2*dy);
-                if(d2 > 0 && d2 < 1 && d3 > 0 && d3 < 1)
-                {
-                    // Simple collinear case, 1---2---3---4
-                    // We can leave just two endpoints
-                    return;
-                }
-                     if(d2 <= 0) d2 = calc_sq_distance(x2, y2, x1, y1);
-                else if(d2 >= 1) d2 = calc_sq_distance(x2, y2, x4, y4);
-                else             d2 = calc_sq_distance(x2, y2, x1 + d2*dx, y1 + d2*dy);
-
-                     if(d3 <= 0) d3 = calc_sq_distance(x3, y3, x1, y1);
-                else if(d3 >= 1) d3 = calc_sq_distance(x3, y3, x4, y4);
-                else             d3 = calc_sq_distance(x3, y3, x1 + d3*dx, y1 + d3*dy);
-            }
-            if(d2 > d3)
-            {
-                if(d2 < m_distance_tolerance_square)
-                {
-                    m_points.add(point_d(x2, y2));
-                    return;
-                }
-            }
-            else
-            {
-                if(d3 < m_distance_tolerance_square)
-                {
-                    m_points.add(point_d(x3, y3));
-                    return;
-                }
-            }
-            break;
-
-        case 1:
-            // p1,p2,p4 are collinear, p3 is significant
-            //----------------------
-            if(d3 * d3 <= m_distance_tolerance_square * (dx*dx + dy*dy))
-            {
-                if(m_angle_tolerance < curve_angle_tolerance_epsilon)
-                {
-                    m_points.add(point_d(x23, y23));
-                    return;
-                }
-
-                // Angle Condition
-                //----------------------
-                da1 = fabs(atan2(y4 - y3, x4 - x3) - atan2(y3 - y2, x3 - x2));
-                if(da1 >= pi) da1 = 2*pi - da1;
-
-                if(da1 < m_angle_tolerance)
-                {
-                    m_points.add(point_d(x2, y2));
-                    m_points.add(point_d(x3, y3));
-                    return;
-                }
-
-                if(m_cusp_limit != 0.0)
-                {
-                    if(da1 > m_cusp_limit)
-                    {
-                        m_points.add(point_d(x3, y3));
-                        return;
-                    }
-                }
-            }
-            break;
-
-        case 2:
-            // p1,p3,p4 are collinear, p2 is significant
-            //----------------------
-            if(d2 * d2 <= m_distance_tolerance_square * (dx*dx + dy*dy))
-            {
-                if(m_angle_tolerance < curve_angle_tolerance_epsilon)
-                {
-                    m_points.add(point_d(x23, y23));
-                    return;
-                }
-
-                // Angle Condition
-                //----------------------
-                da1 = fabs(atan2(y3 - y2, x3 - x2) - atan2(y2 - y1, x2 - x1));
-                if(da1 >= pi) da1 = 2*pi - da1;
-
-                if(da1 < m_angle_tolerance)
-                {
-                    m_points.add(point_d(x2, y2));
-                    m_points.add(point_d(x3, y3));
-                    return;
-                }
-
-                if(m_cusp_limit != 0.0)
-                {
-                    if(da1 > m_cusp_limit)
-                    {
-                        m_points.add(point_d(x2, y2));
-                        return;
-                    }
-                }
-            }
-            break;
-
-        case 3: 
-            // Regular case
-            //-----------------
-            if((d2 + d3)*(d2 + d3) <= m_distance_tolerance_square * (dx*dx + dy*dy))
-            {
-                // If the curvature doesn't exceed the distance_tolerance value
-                // we tend to finish subdivisions.
-                //----------------------
-                if(m_angle_tolerance < curve_angle_tolerance_epsilon)
-                {
-                    m_points.add(point_d(x23, y23));
-                    return;
-                }
-
-                // Angle & Cusp Condition
-                //----------------------
-                k   = atan2(y3 - y2, x3 - x2);
-                da1 = fabs(k - atan2(y2 - y1, x2 - x1));
-                da2 = fabs(atan2(y4 - y3, x4 - x3) - k);
-                if(da1 >= pi) da1 = 2*pi - da1;
-                if(da2 >= pi) da2 = 2*pi - da2;
-
-                if(da1 + da2 < m_angle_tolerance)
-                {
-                    // Finally we can stop the recursion
-                    //----------------------
-                    m_points.add(point_d(x23, y23));
-                    return;
-                }
-
-                if(m_cusp_limit != 0.0)
-                {
-                    if(da1 > m_cusp_limit)
-                    {
-                        m_points.add(point_d(x2, y2));
-                        return;
-                    }
-
-                    if(da2 > m_cusp_limit)
-                    {
-                        m_points.add(point_d(x3, y3));
-                        return;
-                    }
-                }
-            }
-            break;
-        }
-
-        // Continue subdivision
-        //----------------------
-        recursive_bezier(x1, y1, x12, y12, x123, y123, x1234, y1234, level + 1); 
-        recursive_bezier(x1234, y1234, x234, y234, x34, y34, x4, y4, level + 1); 
-    }
-
-    //------------------------------------------------------------------------
-    void curve4_div::bezier(double x1, double y1, 
-                            double x2, double y2, 
-                            double x3, double y3, 
-                            double x4, double y4)
-    {
-        m_points.add(point_d(x1, y1));
-        recursive_bezier(x1, y1, x2, y2, x3, y3, x4, y4, 0);
-        m_points.add(point_d(x4, y4));
-    }
-
-}
-

Sources/libagg/agg-2.4/agg_curves.h

@@ -1,693 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-// Copyright (C) 2005 Tony Juricic (tonygeek@yahoo.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-
-#ifndef AGG_CURVES_INCLUDED
-#define AGG_CURVES_INCLUDED
-
-#include "agg_array.h"
-
-namespace agg
-{
-
-    // See Implementation agg_curves.cpp
-
-    //--------------------------------------------curve_approximation_method_e
-    enum curve_approximation_method_e
-    {
-        curve_inc,
-        curve_div
-    };
-    
-    //--------------------------------------------------------------curve3_inc
-    class curve3_inc
-    {
-    public:
-        curve3_inc() :
-          m_num_steps(0), m_step(0), m_scale(1.0) { }
-
-        curve3_inc(double x1, double y1, 
-                   double x2, double y2, 
-                   double x3, double y3) :
-            m_num_steps(0), m_step(0), m_scale(1.0) 
-        { 
-            init(x1, y1, x2, y2, x3, y3);
-        }
-
-        void reset() { m_num_steps = 0; m_step = -1; }
-        void init(double x1, double y1, 
-                  double x2, double y2, 
-                  double x3, double y3);
-
-        void approximation_method(curve_approximation_method_e) {}
-        curve_approximation_method_e approximation_method() const { return curve_inc; }
-
-        void approximation_scale(double s);
-        double approximation_scale() const;
-
-        void angle_tolerance(double) {}
-        double angle_tolerance() const { return 0.0; }
-
-        void cusp_limit(double) {}
-        double cusp_limit() const { return 0.0; }
-
-        void     rewind(unsigned path_id);
-        unsigned vertex(double* x, double* y);
-
-    private:
-        int      m_num_steps;
-        int      m_step;
-        double   m_scale;
-        double   m_start_x; 
-        double   m_start_y;
-        double   m_end_x; 
-        double   m_end_y;
-        double   m_fx; 
-        double   m_fy;
-        double   m_dfx; 
-        double   m_dfy;
-        double   m_ddfx; 
-        double   m_ddfy;
-        double   m_saved_fx; 
-        double   m_saved_fy;
-        double   m_saved_dfx; 
-        double   m_saved_dfy;
-    };
-
-
-
-
-
-    //-------------------------------------------------------------curve3_div
-    class curve3_div
-    {
-    public:
-        curve3_div() : 
-            m_approximation_scale(1.0),
-            m_angle_tolerance(0.0),
-            m_count(0)
-        {}
-
-        curve3_div(double x1, double y1, 
-                   double x2, double y2, 
-                   double x3, double y3) :
-            m_approximation_scale(1.0),
-            m_angle_tolerance(0.0),
-            m_count(0)
-        { 
-            init(x1, y1, x2, y2, x3, y3);
-        }
-
-        void reset() { m_points.remove_all(); m_count = 0; }
-        void init(double x1, double y1, 
-                  double x2, double y2, 
-                  double x3, double y3);
-
-        void approximation_method(curve_approximation_method_e) {}
-        curve_approximation_method_e approximation_method() const { return curve_div; }
-
-        void approximation_scale(double s) { m_approximation_scale = s; }
-        double approximation_scale() const { return m_approximation_scale;  }
-
-        void angle_tolerance(double a) { m_angle_tolerance = a; }
-        double angle_tolerance() const { return m_angle_tolerance;  }
-
-        void cusp_limit(double) {}
-        double cusp_limit() const { return 0.0; }
-
-        void rewind(unsigned)
-        {
-            m_count = 0;
-        }
-
-        unsigned vertex(double* x, double* y)
-        {
-            if(m_count >= m_points.size()) return path_cmd_stop;
-            const point_d& p = m_points[m_count++];
-            *x = p.x;
-            *y = p.y;
-            return (m_count == 1) ? path_cmd_move_to : path_cmd_line_to;
-        }
-
-    private:
-        void bezier(double x1, double y1, 
-                    double x2, double y2, 
-                    double x3, double y3);
-        void recursive_bezier(double x1, double y1, 
-                              double x2, double y2, 
-                              double x3, double y3,
-                              unsigned level);
-
-        double               m_approximation_scale;
-        double               m_distance_tolerance_square;
-        double               m_angle_tolerance;
-        unsigned             m_count;
-        pod_bvector<point_d> m_points;
-    };
-
-
-
-
-
-
-
-    //-------------------------------------------------------------curve4_points
-    struct curve4_points
-    {
-        double cp[8];
-        curve4_points() {}
-        curve4_points(double x1, double y1,
-                      double x2, double y2,
-                      double x3, double y3,
-                      double x4, double y4)
-        {
-            cp[0] = x1; cp[1] = y1; cp[2] = x2; cp[3] = y2;
-            cp[4] = x3; cp[5] = y3; cp[6] = x4; cp[7] = y4;
-        }
-        void init(double x1, double y1,
-                  double x2, double y2,
-                  double x3, double y3,
-                  double x4, double y4)
-        {
-            cp[0] = x1; cp[1] = y1; cp[2] = x2; cp[3] = y2;
-            cp[4] = x3; cp[5] = y3; cp[6] = x4; cp[7] = y4;
-        }
-        double  operator [] (unsigned i) const { return cp[i]; }
-        double& operator [] (unsigned i)       { return cp[i]; }
-    };
-
-
-
-    //-------------------------------------------------------------curve4_inc
-    class curve4_inc
-    {
-    public:
-        curve4_inc() :
-            m_num_steps(0), m_step(0), m_scale(1.0) { }
-
-        curve4_inc(double x1, double y1, 
-                   double x2, double y2, 
-                   double x3, double y3,
-                   double x4, double y4) :
-            m_num_steps(0), m_step(0), m_scale(1.0) 
-        { 
-            init(x1, y1, x2, y2, x3, y3, x4, y4);
-        }
-
-        curve4_inc(const curve4_points& cp) :
-            m_num_steps(0), m_step(0), m_scale(1.0) 
-        { 
-            init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
-        }
-
-        void reset() { m_num_steps = 0; m_step = -1; }
-        void init(double x1, double y1, 
-                  double x2, double y2, 
-                  double x3, double y3,
-                  double x4, double y4);
-
-        void init(const curve4_points& cp)
-        {
-            init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
-        }
-
-        void approximation_method(curve_approximation_method_e) {}
-        curve_approximation_method_e approximation_method() const { return curve_inc; }
-
-        void approximation_scale(double s);
-        double approximation_scale() const;
-
-        void angle_tolerance(double) {}
-        double angle_tolerance() const { return 0.0; }
-
-        void cusp_limit(double) {}
-        double cusp_limit() const { return 0.0; }
-
-        void     rewind(unsigned path_id);
-        unsigned vertex(double* x, double* y);
-
-    private:
-        int      m_num_steps;
-        int      m_step;
-        double   m_scale;
-        double   m_start_x; 
-        double   m_start_y;
-        double   m_end_x; 
-        double   m_end_y;
-        double   m_fx; 
-        double   m_fy;
-        double   m_dfx; 
-        double   m_dfy;
-        double   m_ddfx; 
-        double   m_ddfy;
-        double   m_dddfx; 
-        double   m_dddfy;
-        double   m_saved_fx; 
-        double   m_saved_fy;
-        double   m_saved_dfx; 
-        double   m_saved_dfy;
-        double   m_saved_ddfx; 
-        double   m_saved_ddfy;
-    };
-
-
-
-    //-------------------------------------------------------catrom_to_bezier
-    inline curve4_points catrom_to_bezier(double x1, double y1, 
-                                          double x2, double y2, 
-                                          double x3, double y3,
-                                          double x4, double y4)
-    {
-        // Trans. matrix Catmull-Rom to Bezier
-        //
-        //  0       1       0       0
-        //  -1/6    1       1/6     0
-        //  0       1/6     1       -1/6
-        //  0       0       1       0
-        //
-        return curve4_points(
-            x2,
-            y2,
-            (-x1 + 6*x2 + x3) / 6,
-            (-y1 + 6*y2 + y3) / 6,
-            ( x2 + 6*x3 - x4) / 6,
-            ( y2 + 6*y3 - y4) / 6,
-            x3,
-            y3);
-    }
-
-
-    //-----------------------------------------------------------------------
-    inline curve4_points
-    catrom_to_bezier(const curve4_points& cp)
-    {
-        return catrom_to_bezier(cp[0], cp[1], cp[2], cp[3], 
-                                cp[4], cp[5], cp[6], cp[7]);
-    }
-
-
-
-    //-----------------------------------------------------ubspline_to_bezier
-    inline curve4_points ubspline_to_bezier(double x1, double y1, 
-                                            double x2, double y2, 
-                                            double x3, double y3,
-                                            double x4, double y4)
-    {
-        // Trans. matrix Uniform BSpline to Bezier
-        //
-        //  1/6     4/6     1/6     0
-        //  0       4/6     2/6     0
-        //  0       2/6     4/6     0
-        //  0       1/6     4/6     1/6
-        //
-        return curve4_points(
-            (x1 + 4*x2 + x3) / 6,
-            (y1 + 4*y2 + y3) / 6,
-            (4*x2 + 2*x3) / 6,
-            (4*y2 + 2*y3) / 6,
-            (2*x2 + 4*x3) / 6,
-            (2*y2 + 4*y3) / 6,
-            (x2 + 4*x3 + x4) / 6,
-            (y2 + 4*y3 + y4) / 6);
-    }
-
-
-    //-----------------------------------------------------------------------
-    inline curve4_points 
-    ubspline_to_bezier(const curve4_points& cp)
-    {
-        return ubspline_to_bezier(cp[0], cp[1], cp[2], cp[3], 
-                                  cp[4], cp[5], cp[6], cp[7]);
-    }
-
-
-
-
-    //------------------------------------------------------hermite_to_bezier
-    inline curve4_points hermite_to_bezier(double x1, double y1, 
-                                           double x2, double y2, 
-                                           double x3, double y3,
-                                           double x4, double y4)
-    {
-        // Trans. matrix Hermite to Bezier
-        //
-        //  1       0       0       0
-        //  1       0       1/3     0
-        //  0       1       0       -1/3
-        //  0       1       0       0
-        //
-        return curve4_points(
-            x1,
-            y1,
-            (3*x1 + x3) / 3,
-            (3*y1 + y3) / 3,
-            (3*x2 - x4) / 3,
-            (3*y2 - y4) / 3,
-            x2,
-            y2);
-    }
-
-
-
-    //-----------------------------------------------------------------------
-    inline curve4_points 
-    hermite_to_bezier(const curve4_points& cp)
-    {
-        return hermite_to_bezier(cp[0], cp[1], cp[2], cp[3], 
-                                 cp[4], cp[5], cp[6], cp[7]);
-    }
-
-
-    //-------------------------------------------------------------curve4_div
-    class curve4_div
-    {
-    public:
-        curve4_div() : 
-            m_approximation_scale(1.0),
-            m_angle_tolerance(0.0),
-            m_cusp_limit(0.0),
-            m_count(0)
-        {}
-
-        curve4_div(double x1, double y1, 
-                   double x2, double y2, 
-                   double x3, double y3,
-                   double x4, double y4) :
-            m_approximation_scale(1.0),
-            m_angle_tolerance(0.0),
-            m_cusp_limit(0.0),
-            m_count(0)
-        { 
-            init(x1, y1, x2, y2, x3, y3, x4, y4);
-        }
-
-        curve4_div(const curve4_points& cp) :
-            m_approximation_scale(1.0),
-            m_angle_tolerance(0.0),
-            m_count(0)
-        { 
-            init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
-        }
-
-        void reset() { m_points.remove_all(); m_count = 0; }
-        void init(double x1, double y1, 
-                  double x2, double y2, 
-                  double x3, double y3,
-                  double x4, double y4);
-
-        void init(const curve4_points& cp)
-        {
-            init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
-        }
-
-        void approximation_method(curve_approximation_method_e) {}
-
-        curve_approximation_method_e approximation_method() const 
-        { 
-            return curve_div; 
-        }
-
-        void approximation_scale(double s) { m_approximation_scale = s; }
-        double approximation_scale() const { return m_approximation_scale;  }
-
-        void angle_tolerance(double a) { m_angle_tolerance = a; }
-        double angle_tolerance() const { return m_angle_tolerance;  }
-
-        void cusp_limit(double v) 
-        { 
-            m_cusp_limit = (v == 0.0) ? 0.0 : pi - v; 
-        }
-
-        double cusp_limit() const 
-        { 
-            return (m_cusp_limit == 0.0) ? 0.0 : pi - m_cusp_limit; 
-        }
-
-        void rewind(unsigned)
-        {
-            m_count = 0;
-        }
-
-        unsigned vertex(double* x, double* y)
-        {
-            if(m_count >= m_points.size()) return path_cmd_stop;
-            const point_d& p = m_points[m_count++];
-            *x = p.x;
-            *y = p.y;
-            return (m_count == 1) ? path_cmd_move_to : path_cmd_line_to;
-        }
-
-    private:
-        void bezier(double x1, double y1, 
-                    double x2, double y2, 
-                    double x3, double y3, 
-                    double x4, double y4);
-
-        void recursive_bezier(double x1, double y1, 
-                              double x2, double y2, 
-                              double x3, double y3, 
-                              double x4, double y4,
-                              unsigned level);
-
-        double               m_approximation_scale;
-        double               m_distance_tolerance_square;
-        double               m_angle_tolerance;
-        double               m_cusp_limit;
-        unsigned             m_count;
-        pod_bvector<point_d> m_points;
-    };
-
-
-    //-----------------------------------------------------------------curve3
-    class curve3
-    {
-    public:
-        curve3() : m_approximation_method(curve_div) {}
-        curve3(double x1, double y1, 
-               double x2, double y2, 
-               double x3, double y3) :
-            m_approximation_method(curve_div)
-        { 
-            init(x1, y1, x2, y2, x3, y3);
-        }
-
-        void reset() 
-        { 
-            m_curve_inc.reset();
-            m_curve_div.reset();
-        }
-
-        void init(double x1, double y1, 
-                  double x2, double y2, 
-                  double x3, double y3)
-        {
-            if(m_approximation_method == curve_inc) 
-            {
-                m_curve_inc.init(x1, y1, x2, y2, x3, y3);
-            }
-            else
-            {
-                m_curve_div.init(x1, y1, x2, y2, x3, y3);
-            }
-        }
-
-        void approximation_method(curve_approximation_method_e v) 
-        { 
-            m_approximation_method = v; 
-        }
-
-        curve_approximation_method_e approximation_method() const 
-        { 
-            return m_approximation_method; 
-        }
-
-        void approximation_scale(double s) 
-        { 
-            m_curve_inc.approximation_scale(s);
-            m_curve_div.approximation_scale(s);
-        }
-
-        double approximation_scale() const 
-        { 
-            return m_curve_inc.approximation_scale(); 
-        }
-
-        void angle_tolerance(double a) 
-        { 
-            m_curve_div.angle_tolerance(a); 
-        }
-
-        double angle_tolerance() const 
-        { 
-            return m_curve_div.angle_tolerance(); 
-        }
-
-        void cusp_limit(double v) 
-        { 
-            m_curve_div.cusp_limit(v); 
-        }
-
-        double cusp_limit() const 
-        { 
-            return m_curve_div.cusp_limit();  
-        }
-
-        void rewind(unsigned path_id)
-        {
-            if(m_approximation_method == curve_inc) 
-            {
-                m_curve_inc.rewind(path_id);
-            }
-            else
-            {
-                m_curve_div.rewind(path_id);
-            }
-        }
-
-        unsigned vertex(double* x, double* y)
-        {
-            if(m_approximation_method == curve_inc) 
-            {
-                return m_curve_inc.vertex(x, y);
-            }
-            return m_curve_div.vertex(x, y);
-        }
-
-    private:
-        curve3_inc m_curve_inc;
-        curve3_div m_curve_div;
-        curve_approximation_method_e m_approximation_method;
-    };
-
-
-
-
-
-    //-----------------------------------------------------------------curve4
-    class curve4
-    {
-    public:
-        curve4() : m_approximation_method(curve_div) {}
-        curve4(double x1, double y1, 
-               double x2, double y2, 
-               double x3, double y3,
-               double x4, double y4) : 
-            m_approximation_method(curve_div)
-        { 
-            init(x1, y1, x2, y2, x3, y3, x4, y4);
-        }
-
-        curve4(const curve4_points& cp) :
-            m_approximation_method(curve_div)
-        { 
-            init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
-        }
-
-        void reset() 
-        { 
-            m_curve_inc.reset();
-            m_curve_div.reset();
-        }
-
-        void init(double x1, double y1, 
-                  double x2, double y2, 
-                  double x3, double y3,
-                  double x4, double y4)
-        {
-            if(m_approximation_method == curve_inc) 
-            {
-                m_curve_inc.init(x1, y1, x2, y2, x3, y3, x4, y4);
-            }
-            else
-            {
-                m_curve_div.init(x1, y1, x2, y2, x3, y3, x4, y4);
-            }
-        }
-
-        void init(const curve4_points& cp)
-        {
-            init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
-        }
-
-        void approximation_method(curve_approximation_method_e v) 
-        { 
-            m_approximation_method = v; 
-        }
-
-        curve_approximation_method_e approximation_method() const 
-        { 
-            return m_approximation_method; 
-        }
-
-        void approximation_scale(double s) 
-        { 
-            m_curve_inc.approximation_scale(s);
-            m_curve_div.approximation_scale(s);
-        }
-        double approximation_scale() const { return m_curve_inc.approximation_scale(); }
-
-        void angle_tolerance(double v) 
-        { 
-            m_curve_div.angle_tolerance(v); 
-        }
-
-        double angle_tolerance() const 
-        { 
-            return m_curve_div.angle_tolerance();  
-        }
-
-        void cusp_limit(double v) 
-        { 
-            m_curve_div.cusp_limit(v); 
-        }
-
-        double cusp_limit() const 
-        { 
-            return m_curve_div.cusp_limit();  
-        }
-
-        void rewind(unsigned path_id)
-        {
-            if(m_approximation_method == curve_inc) 
-            {
-                m_curve_inc.rewind(path_id);
-            }
-            else
-            {
-                m_curve_div.rewind(path_id);
-            }
-        }
-
-        unsigned vertex(double* x, double* y)
-        {
-            if(m_approximation_method == curve_inc) 
-            {
-                return m_curve_inc.vertex(x, y);
-            }
-            return m_curve_div.vertex(x, y);
-        }
-
-    private:
-        curve4_inc m_curve_inc;
-        curve4_div m_curve_div;
-        curve_approximation_method_e m_approximation_method;
-    };
-
-
-
-
-}
-
-#endif

Sources/libagg/agg-2.4/agg_dda_line.h

@@ -1,290 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// classes dda_line_interpolator, dda2_line_interpolator
-//
-//----------------------------------------------------------------------------
-
-#ifndef AGG_DDA_LINE_INCLUDED
-#define AGG_DDA_LINE_INCLUDED
-
-#include <stdlib.h>
-#include "agg_basics.h"
-
-namespace agg
-{
-
-    //===================================================dda_line_interpolator
-    template<int FractionShift, int YShift=0> class dda_line_interpolator
-    {
-    public:
-        //--------------------------------------------------------------------
-        dda_line_interpolator() {}
-
-        //--------------------------------------------------------------------
-        dda_line_interpolator(int y1, int y2, unsigned count) :
-            m_y(y1),
-            m_inc(((y2 - y1) << FractionShift) / int(count)),
-            m_dy(0)
-        {
-        }
-
-        //--------------------------------------------------------------------
-        void operator ++ ()
-        {
-            m_dy += m_inc;
-        }
-
-        //--------------------------------------------------------------------
-        void operator -- ()
-        {
-            m_dy -= m_inc;
-        }
-
-        //--------------------------------------------------------------------
-        void operator += (unsigned n)
-        {
-            m_dy += m_inc * n;
-        }
-
-        //--------------------------------------------------------------------
-        void operator -= (unsigned n)
-        {
-            m_dy -= m_inc * n;
-        }
-
-
-        //--------------------------------------------------------------------
-        int y()  const { return m_y + (m_dy >> (FractionShift-YShift)); }
-        int dy() const { return m_dy; }
-
-
-    private:
-        int m_y;
-        int m_inc;
-        int m_dy;
-    };
-
-
-
-
-
-    //=================================================dda2_line_interpolator
-    class dda2_line_interpolator
-    {
-    public:
-        typedef int save_data_type;
-        enum save_size_e { save_size = 2 };
-
-        //--------------------------------------------------------------------
-        dda2_line_interpolator() {}
-
-        //-------------------------------------------- Forward-adjusted line
-        dda2_line_interpolator(int y1, int y2, int count) :
-            m_cnt(count <= 0 ? 1 : count),
-            m_lft((y2 - y1) / m_cnt),
-            m_rem((y2 - y1) % m_cnt),
-            m_mod(m_rem),
-            m_y(y1)
-        {
-            if(m_mod <= 0)
-            {
-                m_mod += count;
-                m_rem += count;
-                m_lft--;
-            }
-            m_mod -= count;
-        }
-
-        //-------------------------------------------- Backward-adjusted line
-        dda2_line_interpolator(int y1, int y2, int count, int) :
-            m_cnt(count <= 0 ? 1 : count),
-            m_lft((y2 - y1) / m_cnt),
-            m_rem((y2 - y1) % m_cnt),
-            m_mod(m_rem),
-            m_y(y1)
-        {
-            if(m_mod <= 0)
-            {
-                m_mod += count;
-                m_rem += count;
-                m_lft--;
-            }
-        }
-
-        //-------------------------------------------- Backward-adjusted line
-        dda2_line_interpolator(int y, int count) :
-            m_cnt(count <= 0 ? 1 : count),
-            m_lft(y / m_cnt),
-            m_rem(y % m_cnt),
-            m_mod(m_rem),
-            m_y(0)
-        {
-            if(m_mod <= 0)
-            {
-                m_mod += count;
-                m_rem += count;
-                m_lft--;
-            }
-        }
-
-
-        //--------------------------------------------------------------------
-        void save(save_data_type* data) const
-        {
-            data[0] = m_mod;
-            data[1] = m_y;
-        }
-
-        //--------------------------------------------------------------------
-        void load(const save_data_type* data)
-        {
-            m_mod = data[0];
-            m_y   = data[1];
-        }
-
-        //--------------------------------------------------------------------
-        void operator++()
-        {
-            m_mod += m_rem;
-            m_y += m_lft;
-            if(m_mod > 0)
-            {
-                m_mod -= m_cnt;
-                m_y++;
-            }
-        }
-
-        //--------------------------------------------------------------------
-        void operator--()
-        {
-            if(m_mod <= m_rem)
-            {
-                m_mod += m_cnt;
-                m_y--;
-            }
-            m_mod -= m_rem;
-            m_y -= m_lft;
-        }
-
-        //--------------------------------------------------------------------
-        void adjust_forward()
-        {
-            m_mod -= m_cnt;
-        }
-
-        //--------------------------------------------------------------------
-        void adjust_backward()
-        {
-            m_mod += m_cnt;
-        }
-
-        //--------------------------------------------------------------------
-        int mod() const { return m_mod; }
-        int rem() const { return m_rem; }
-        int lft() const { return m_lft; }
-
-        //--------------------------------------------------------------------
-        int y() const { return m_y; }
-
-    private:
-        int m_cnt;
-        int m_lft;
-        int m_rem;
-        int m_mod;
-        int m_y;
-    };
-
-
-
-
-
-
-
-    //---------------------------------------------line_bresenham_interpolator
-    class line_bresenham_interpolator
-    {
-    public:
-        enum subpixel_scale_e
-        {
-            subpixel_shift = 8,
-            subpixel_scale = 1 << subpixel_shift,
-            subpixel_mask  = subpixel_scale - 1
-        };
-
-        //--------------------------------------------------------------------
-        static int line_lr(int v) { return v >> subpixel_shift; }
-
-        //--------------------------------------------------------------------
-        line_bresenham_interpolator(int x1, int y1, int x2, int y2) :
-            m_x1_lr(line_lr(x1)),
-            m_y1_lr(line_lr(y1)),
-            m_x2_lr(line_lr(x2)),
-            m_y2_lr(line_lr(y2)),
-            m_ver(abs(m_x2_lr - m_x1_lr) < abs(m_y2_lr - m_y1_lr)),
-            m_len(m_ver ? abs(m_y2_lr - m_y1_lr) : 
-                          abs(m_x2_lr - m_x1_lr)),
-            m_inc(m_ver ? ((y2 > y1) ? 1 : -1) : ((x2 > x1) ? 1 : -1)),
-            m_interpolator(m_ver ? x1 : y1, 
-                           m_ver ? x2 : y2, 
-                           m_len)
-        {
-        }
-    
-        //--------------------------------------------------------------------
-        bool     is_ver() const { return m_ver; }
-        unsigned len()    const { return m_len; }
-        int      inc()    const { return m_inc; }
-
-        //--------------------------------------------------------------------
-        void hstep()
-        {
-            ++m_interpolator;
-            m_x1_lr += m_inc;
-        }
-
-        //--------------------------------------------------------------------
-        void vstep()
-        {
-            ++m_interpolator;
-            m_y1_lr += m_inc;
-        }
-
-        //--------------------------------------------------------------------
-        int x1() const { return m_x1_lr; }
-        int y1() const { return m_y1_lr; }
-        int x2() const { return line_lr(m_interpolator.y()); }
-        int y2() const { return line_lr(m_interpolator.y()); }
-        int x2_hr() const { return m_interpolator.y(); }
-        int y2_hr() const { return m_interpolator.y(); }
-
-    private:
-        int                    m_x1_lr;
-        int                    m_y1_lr;
-        int                    m_x2_lr;
-        int                    m_y2_lr;
-        bool                   m_ver;
-        unsigned               m_len;
-        int                    m_inc;
-        dda2_line_interpolator m_interpolator;
-
-    };
-
-
-}
-
-
-
-#endif

Sources/libagg/agg-2.4/agg_ellipse.h

@@ -1,123 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// class ellipse
-//
-//----------------------------------------------------------------------------
-
-#ifndef AGG_ELLIPSE_INCLUDED
-#define AGG_ELLIPSE_INCLUDED
-
-#include "agg_basics.h"
-#include <math.h>
-
-namespace agg
-{
-
-    //----------------------------------------------------------------ellipse
-    class ellipse
-    {
-    public:
-        ellipse() : 
-            m_x(0.0), m_y(0.0), m_rx(1.0), m_ry(1.0), m_scale(1.0), 
-            m_num(4), m_step(0), m_cw(false) {}
-
-        ellipse(double x, double y, double rx, double ry, 
-                unsigned num_steps=0, bool cw=false) :
-            m_x(x), m_y(y), m_rx(rx), m_ry(ry), m_scale(1.0), 
-            m_num(num_steps), m_step(0), m_cw(cw) 
-        {
-            if(m_num == 0) calc_num_steps();
-        }
-
-        void init(double x, double y, double rx, double ry, 
-                  unsigned num_steps=0, bool cw=false);
-
-        void approximation_scale(double scale);
-        void rewind(unsigned path_id);
-        unsigned vertex(double* x, double* y);
-
-    private:
-        void calc_num_steps();
-
-        double m_x;
-        double m_y;
-        double m_rx;
-        double m_ry;
-        double m_scale;
-        unsigned m_num;
-        unsigned m_step;
-        bool m_cw;
-    };
-
-    //------------------------------------------------------------------------
-    inline void ellipse::init(double x, double y, double rx, double ry, 
-                              unsigned num_steps, bool cw)
-    {
-        m_x = x;
-        m_y = y;
-        m_rx = rx;
-        m_ry = ry;
-        m_num = num_steps;
-        m_step = 0;
-        m_cw = cw;
-        if(m_num == 0) calc_num_steps();
-    }
-
-    //------------------------------------------------------------------------
-    inline void ellipse::approximation_scale(double scale)
-    {   
-        m_scale = scale;
-        calc_num_steps();
-    }
-
-    //------------------------------------------------------------------------
-    inline void ellipse::calc_num_steps()
-    {
-        double ra = (fabs(m_rx) + fabs(m_ry)) / 2;
-        double da = acos(ra / (ra + 0.125 / m_scale)) * 2;
-        m_num = uround(2*pi / da);
-    }
-
-    //------------------------------------------------------------------------
-    inline void ellipse::rewind(unsigned)
-    {
-        m_step = 0;
-    }
-
-    //------------------------------------------------------------------------
-    inline unsigned ellipse::vertex(double* x, double* y)
-    {
-        if(m_step == m_num) 
-        {
-            ++m_step;
-            return path_cmd_end_poly | path_flags_close | path_flags_ccw;
-        }
-        if(m_step > m_num) return path_cmd_stop;
-        double angle = double(m_step) / double(m_num) * 2.0 * pi;
-        if(m_cw) angle = 2.0 * pi - angle;
-        *x = m_x + cos(angle) * m_rx;
-        *y = m_y + sin(angle) * m_ry;
-        m_step++;
-        return ((m_step == 1) ? path_cmd_move_to : path_cmd_line_to);
-    }
-
-}
-
-
-
-#endif
-
-

Sources/libagg/agg-2.4/agg_ellipse_bresenham.h

@@ -1,113 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// Simple Bresenham interpolator for ellipsees
-//
-//----------------------------------------------------------------------------
-
-#ifndef AGG_ELLIPSE_BRESENHAM_INCLUDED
-#define AGG_ELLIPSE_BRESENHAM_INCLUDED
-
-
-#include "agg_basics.h"
-
-
-namespace agg
-{
-
-    //------------------------------------------ellipse_bresenham_interpolator
-    class ellipse_bresenham_interpolator
-    {
-    public:
-        ellipse_bresenham_interpolator(int rx, int ry) :
-            m_rx2(rx * rx),
-            m_ry2(ry * ry),
-            m_two_rx2(m_rx2 << 1),
-            m_two_ry2(m_ry2 << 1),
-            m_dx(0),
-            m_dy(0),
-            m_inc_x(0),
-            m_inc_y(-ry * m_two_rx2),
-            m_cur_f(0)
-        {}
-        
-        int dx() const { return m_dx; }
-        int dy() const { return m_dy; }
-
-        void operator++ ()
-        {
-            int  mx, my, mxy, min_m;
-            int  fx, fy, fxy;
-
-            mx = fx = m_cur_f + m_inc_x + m_ry2;
-            if(mx < 0) mx = -mx;
-
-            my = fy = m_cur_f + m_inc_y + m_rx2;
-            if(my < 0) my = -my;
-
-            mxy = fxy = m_cur_f + m_inc_x + m_ry2 + m_inc_y + m_rx2;
-            if(mxy < 0) mxy = -mxy;
-
-            min_m = mx; 
-            bool flag = true;
-
-            if(min_m > my)  
-            { 
-                min_m = my; 
-                flag = false; 
-            }
-
-            m_dx = m_dy = 0;
-
-            if(min_m > mxy) 
-            { 
-                m_inc_x += m_two_ry2;
-                m_inc_y += m_two_rx2;
-                m_cur_f = fxy;
-                m_dx = 1; 
-                m_dy = 1;
-                return;
-            }
-
-            if(flag) 
-            {
-                m_inc_x += m_two_ry2;
-                m_cur_f = fx;
-                m_dx = 1;
-                return;
-            }
-
-            m_inc_y += m_two_rx2;
-            m_cur_f = fy;
-            m_dy = 1;
-        }
-
-    private:
-        int m_rx2;
-        int m_ry2;
-        int m_two_rx2;
-        int m_two_ry2;
-        int m_dx;
-        int m_dy;
-        int m_inc_x;
-        int m_inc_y;
-        int m_cur_f;
-
-    };
-
-}
-
-#endif
-

Sources/libagg/agg-2.4/agg_embedded_raster_fonts.h

@@ -1,59 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-
-#ifndef AGG_EMBEDDED_RASTER_FONTS_INCLUDED
-#define AGG_EMBEDDED_RASTER_FONTS_INCLUDED
-
-#include "agg_basics.h"
-
-namespace agg
-{
-    extern const int8u gse4x6[];
-    extern const int8u gse4x8[];
-    extern const int8u gse5x7[];
-    extern const int8u gse5x9[];
-    extern const int8u gse6x12[];
-    extern const int8u gse6x9[];
-    extern const int8u gse7x11[];
-    extern const int8u gse7x11_bold[];
-    extern const int8u gse7x15[];
-    extern const int8u gse7x15_bold[];
-    extern const int8u gse8x16[];
-    extern const int8u gse8x16_bold[];
-    extern const int8u mcs11_prop[];
-    extern const int8u mcs11_prop_condensed[];
-    extern const int8u mcs12_prop[];
-    extern const int8u mcs13_prop[];
-    extern const int8u mcs5x10_mono[];
-    extern const int8u mcs5x11_mono[];
-    extern const int8u mcs6x10_mono[];
-    extern const int8u mcs6x11_mono[];
-    extern const int8u mcs7x12_mono_high[];
-    extern const int8u mcs7x12_mono_low[];
-    extern const int8u verdana12[];
-    extern const int8u verdana12_bold[];
-    extern const int8u verdana13[];
-    extern const int8u verdana13_bold[];
-    extern const int8u verdana14[];
-    extern const int8u verdana14_bold[];
-    extern const int8u verdana16[];
-    extern const int8u verdana16_bold[];
-    extern const int8u verdana17[];
-    extern const int8u verdana17_bold[];
-    extern const int8u verdana18[];
-    extern const int8u verdana18_bold[];
-}
-
-#endif

Sources/libagg/agg-2.4/agg_font_cache_manager.h

@@ -1,409 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-
-#ifndef AGG_FONT_CACHE_MANAGER_INCLUDED
-#define AGG_FONT_CACHE_MANAGER_INCLUDED
-
-#include <string.h>
-#include "agg_array.h"
-
-namespace agg
-{
-
-    //---------------------------------------------------------glyph_data_type
-    enum glyph_data_type
-    {
-        glyph_data_invalid = 0,
-        glyph_data_mono    = 1,
-        glyph_data_gray8   = 2,
-        glyph_data_outline = 3
-    };
-
-
-    //-------------------------------------------------------------glyph_cache
-    struct glyph_cache
-    {
-        unsigned        glyph_index;
-        int8u*          data;
-        unsigned        data_size;
-        glyph_data_type data_type;
-        rect_i          bounds;
-        double          advance_x;
-        double          advance_y;
-    };
-
-
-    //--------------------------------------------------------------font_cache
-    class font_cache
-    {
-    public:
-        enum block_size_e { block_size = 16384-16 };
-
-        //--------------------------------------------------------------------
-        font_cache() : 
-            m_allocator(block_size),
-            m_font_signature(0)
-        {}
-
-        //--------------------------------------------------------------------
-        void signature(const char* font_signature)
-        {
-            m_font_signature = (char*)m_allocator.allocate(strlen(font_signature) + 1);
-            strcpy(m_font_signature, font_signature);
-            memset(m_glyphs, 0, sizeof(m_glyphs));
-        }
-
-        //--------------------------------------------------------------------
-        bool font_is(const char* font_signature) const
-        {
-            return strcmp(font_signature, m_font_signature) == 0;
-        }
-
-        //--------------------------------------------------------------------
-        const glyph_cache* find_glyph(unsigned glyph_code) const
-        {
-            unsigned msb = (glyph_code >> 8) & 0xFF;
-            if(m_glyphs[msb]) 
-            {
-                return m_glyphs[msb][glyph_code & 0xFF];
-            }
-            return 0;
-        }
-
-        //--------------------------------------------------------------------
-        glyph_cache* cache_glyph(unsigned        glyph_code, 
-                                 unsigned        glyph_index,
-                                 unsigned        data_size,
-                                 glyph_data_type data_type,
-                                 const rect_i&   bounds,
-                                 double          advance_x,
-                                 double          advance_y)
-        {
-            unsigned msb = (glyph_code >> 8) & 0xFF;
-            if(m_glyphs[msb] == 0)
-            {
-                m_glyphs[msb] = 
-                    (glyph_cache**)m_allocator.allocate(sizeof(glyph_cache*) * 256, 
-                                                        sizeof(glyph_cache*));
-                memset(m_glyphs[msb], 0, sizeof(glyph_cache*) * 256);
-            }
-
-            unsigned lsb = glyph_code & 0xFF;
-            if(m_glyphs[msb][lsb]) return 0; // Already exists, do not overwrite
-
-            glyph_cache* glyph = 
-                (glyph_cache*)m_allocator.allocate(sizeof(glyph_cache),
-                                                   sizeof(double));
-
-            glyph->glyph_index        = glyph_index;
-            glyph->data               = m_allocator.allocate(data_size);
-            glyph->data_size          = data_size;
-            glyph->data_type          = data_type;
-            glyph->bounds             = bounds;
-            glyph->advance_x          = advance_x;
-            glyph->advance_y          = advance_y;
-            return m_glyphs[msb][lsb] = glyph;
-        }
-
-    private:
-        block_allocator m_allocator;
-        glyph_cache**   m_glyphs[256];
-        char*           m_font_signature;
-    };
-
-
-
-
-
-
-    
-    //---------------------------------------------------------font_cache_pool
-    class font_cache_pool
-    {
-    public:
-        //--------------------------------------------------------------------
-        ~font_cache_pool()
-        {
-            unsigned i;
-            for(i = 0; i < m_num_fonts; ++i)
-            {
-                obj_allocator<font_cache>::deallocate(m_fonts[i]);
-            }
-            pod_allocator<font_cache*>::deallocate(m_fonts, m_max_fonts);
-        }
-
-        //--------------------------------------------------------------------
-        font_cache_pool(unsigned max_fonts=32) : 
-            m_fonts(pod_allocator<font_cache*>::allocate(max_fonts)),
-            m_max_fonts(max_fonts),
-            m_num_fonts(0),
-            m_cur_font(0)
-        {}
-
-
-        //--------------------------------------------------------------------
-        void font(const char* font_signature, bool reset_cache = false)
-        {
-            int idx = find_font(font_signature);
-            if(idx >= 0)
-            {
-                if(reset_cache)
-                {
-                    obj_allocator<font_cache>::deallocate(m_fonts[idx]);
-                    m_fonts[idx] = obj_allocator<font_cache>::allocate();
-                    m_fonts[idx]->signature(font_signature);
-                }
-                m_cur_font = m_fonts[idx];
-            }
-            else
-            {
-                if(m_num_fonts >= m_max_fonts)
-                {
-                    obj_allocator<font_cache>::deallocate(m_fonts[0]);
-                    memcpy(m_fonts, 
-                           m_fonts + 1, 
-                           (m_max_fonts - 1) * sizeof(font_cache*));
-                    m_num_fonts = m_max_fonts - 1;
-                }
-                m_fonts[m_num_fonts] = obj_allocator<font_cache>::allocate();
-                m_fonts[m_num_fonts]->signature(font_signature);
-                m_cur_font = m_fonts[m_num_fonts];
-                ++m_num_fonts;
-            }
-        }
-
-        //--------------------------------------------------------------------
-        const font_cache* font() const
-        {
-            return m_cur_font;
-        }
-
-        //--------------------------------------------------------------------
-        const glyph_cache* find_glyph(unsigned glyph_code) const
-        {
-            if(m_cur_font) return m_cur_font->find_glyph(glyph_code);
-            return 0;
-        }
-
-        //--------------------------------------------------------------------
-        glyph_cache* cache_glyph(unsigned        glyph_code, 
-                                 unsigned        glyph_index,
-                                 unsigned        data_size,
-                                 glyph_data_type data_type,
-                                 const rect_i&   bounds,
-                                 double          advance_x,
-                                 double          advance_y)
-        {
-            if(m_cur_font) 
-            {
-                return m_cur_font->cache_glyph(glyph_code,
-                                               glyph_index,
-                                               data_size,
-                                               data_type,
-                                               bounds,
-                                               advance_x,
-                                               advance_y);
-            }
-            return 0;
-        }
-
-
-        //--------------------------------------------------------------------
-        int find_font(const char* font_signature)
-        {
-            unsigned i;
-            for(i = 0; i < m_num_fonts; i++)
-            {
-                if(m_fonts[i]->font_is(font_signature)) return int(i);
-            }
-            return -1;
-        }
-
-    private:
-        font_cache** m_fonts;
-        unsigned     m_max_fonts;
-        unsigned     m_num_fonts;
-        font_cache*  m_cur_font;
-    };
-
-
-
-
-    //------------------------------------------------------------------------
-    enum glyph_rendering
-    {
-        glyph_ren_native_mono,
-        glyph_ren_native_gray8,
-        glyph_ren_outline,
-        glyph_ren_agg_mono,
-        glyph_ren_agg_gray8
-    };
-
-
-
-
-    //------------------------------------------------------font_cache_manager
-    template<class FontEngine> class font_cache_manager
-    {
-    public:
-        typedef FontEngine font_engine_type;
-        typedef font_cache_manager<FontEngine> self_type;
-        typedef typename font_engine_type::path_adaptor_type   path_adaptor_type;
-        typedef typename font_engine_type::gray8_adaptor_type  gray8_adaptor_type;
-        typedef typename gray8_adaptor_type::embedded_scanline gray8_scanline_type;
-        typedef typename font_engine_type::mono_adaptor_type   mono_adaptor_type;
-        typedef typename mono_adaptor_type::embedded_scanline  mono_scanline_type;
-
-        //--------------------------------------------------------------------
-        font_cache_manager(font_engine_type& engine, unsigned max_fonts=32) :
-            m_fonts(max_fonts),
-            m_engine(engine),
-            m_change_stamp(-1),
-            m_prev_glyph(0),
-            m_last_glyph(0)
-        {}
-
-        //--------------------------------------------------------------------
-        void reset_last_glyph()
-        {
-            m_prev_glyph = m_last_glyph = 0;
-        }
-
-        //--------------------------------------------------------------------
-        const glyph_cache* glyph(unsigned glyph_code)
-        {
-            synchronize();
-            const glyph_cache* gl = m_fonts.find_glyph(glyph_code);
-            if(gl) 
-            {
-                m_prev_glyph = m_last_glyph;
-                return m_last_glyph = gl;
-            }
-            else
-            {
-                if(m_engine.prepare_glyph(glyph_code))
-                {
-                    m_prev_glyph = m_last_glyph;
-                    m_last_glyph = m_fonts.cache_glyph(glyph_code, 
-                                                       m_engine.glyph_index(),
-                                                       m_engine.data_size(),
-                                                       m_engine.data_type(),
-                                                       m_engine.bounds(),
-                                                       m_engine.advance_x(),
-                                                       m_engine.advance_y());
-                    m_engine.write_glyph_to(m_last_glyph->data);
-                    return m_last_glyph;
-                }
-            }
-            return 0;
-        }
-
-        //--------------------------------------------------------------------
-        void init_embedded_adaptors(const glyph_cache* gl, 
-                                    double x, double y, 
-                                    double scale=1.0)
-        {
-            if(gl)
-            {
-                switch(gl->data_type)
-                {
-                default: return;
-                case glyph_data_mono:
-                    m_mono_adaptor.init(gl->data, gl->data_size, x, y);
-                    break;
-
-                case glyph_data_gray8:
-                    m_gray8_adaptor.init(gl->data, gl->data_size, x, y);
-                    break;
-
-                case glyph_data_outline:
-                    m_path_adaptor.init(gl->data, gl->data_size, x, y, scale);
-                    break;
-                }
-            }
-        }
-
-
-        //--------------------------------------------------------------------
-        path_adaptor_type&   path_adaptor()   { return m_path_adaptor;   }
-        gray8_adaptor_type&  gray8_adaptor()  { return m_gray8_adaptor;  }
-        gray8_scanline_type& gray8_scanline() { return m_gray8_scanline; }
-        mono_adaptor_type&   mono_adaptor()   { return m_mono_adaptor;   }
-        mono_scanline_type&  mono_scanline()  { return m_mono_scanline;  }
-
-        //--------------------------------------------------------------------
-        const glyph_cache* perv_glyph() const { return m_prev_glyph; }
-        const glyph_cache* last_glyph() const { return m_last_glyph; }
-
-        //--------------------------------------------------------------------
-        bool add_kerning(double* x, double* y)
-        {
-            if(m_prev_glyph && m_last_glyph)
-            {
-                return m_engine.add_kerning(m_prev_glyph->glyph_index, 
-                                            m_last_glyph->glyph_index,
-                                            x, y);
-            }
-            return false;
-        }
-
-        //--------------------------------------------------------------------
-        void precache(unsigned from, unsigned to)
-        {
-            for(; from <= to; ++from) glyph(from);
-        }
-
-        //--------------------------------------------------------------------
-        void reset_cache()
-        {
-            m_fonts.font(m_engine.font_signature(), true);
-            m_change_stamp = m_engine.change_stamp();
-            m_prev_glyph = m_last_glyph = 0;
-        }
-
-    private:
-        //--------------------------------------------------------------------
-        font_cache_manager(const self_type&);
-        const self_type& operator = (const self_type&);
-
-        //--------------------------------------------------------------------
-        void synchronize()
-        {
-            if(m_change_stamp != m_engine.change_stamp())
-            {
-                m_fonts.font(m_engine.font_signature());
-                m_change_stamp = m_engine.change_stamp();
-                m_prev_glyph = m_last_glyph = 0;
-            }
-        }
-
-        font_cache_pool     m_fonts;
-        font_engine_type&   m_engine;
-        int                 m_change_stamp;
-        double              m_dx;
-        double              m_dy;
-        const glyph_cache*  m_prev_glyph;
-        const glyph_cache*  m_last_glyph;
-        path_adaptor_type   m_path_adaptor;
-        gray8_adaptor_type  m_gray8_adaptor;
-        gray8_scanline_type m_gray8_scanline;
-        mono_adaptor_type   m_mono_adaptor;
-        mono_scanline_type  m_mono_scanline;
-    };
-
-}
-
-#endif
-

Sources/libagg/agg-2.4/agg_font_freetype.h

@@ -1,196 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// See implementation agg_font_freetype.cpp
-//
-//----------------------------------------------------------------------------
-
-#ifndef AGG_FONT_FREETYPE_INCLUDED
-#define AGG_FONT_FREETYPE_INCLUDED
-
-#include <ft2build.h>
-#include FT_FREETYPE_H
-
-
-#include "agg_scanline_storage_aa.h"
-#include "agg_scanline_storage_bin.h"
-#include "agg_scanline_u.h"
-#include "agg_scanline_bin.h"
-#include "agg_path_storage_integer.h"
-#include "agg_rasterizer_scanline_aa.h"
-#include "agg_conv_curve.h"
-#include "agg_font_cache_manager.h"
-#include "agg_trans_affine.h"
-
-namespace agg
-{
-
-
-    //-----------------------------------------------font_engine_freetype_base
-    class font_engine_freetype_base
-    {
-    public:
-        //--------------------------------------------------------------------
-        typedef serialized_scanlines_adaptor_aa<int8u>    gray8_adaptor_type;
-        typedef serialized_scanlines_adaptor_bin          mono_adaptor_type;
-        typedef scanline_storage_aa8                      scanlines_aa_type;
-        typedef scanline_storage_bin                      scanlines_bin_type;
-
-        //--------------------------------------------------------------------
-        ~font_engine_freetype_base();
-        font_engine_freetype_base(bool flag32, unsigned max_faces = 32);
-
-        // Set font parameters
-        //--------------------------------------------------------------------
-        void resolution(unsigned dpi);
-        bool load_font(const char* font_name, unsigned face_index, glyph_rendering ren_type,
-                       const char* font_mem = 0, const long font_mem_size = 0);
-        bool attach(const char* file_name);
-        bool char_map(FT_Encoding map);
-        bool height(double h);
-        bool width(double w);
-        void hinting(bool h);
-        void flip_y(bool f);
-        void transform(const trans_affine& affine);
-
-        // Set Gamma
-        //--------------------------------------------------------------------
-        template<class GammaF> void gamma(const GammaF& f)
-        {
-            m_rasterizer.gamma(f);
-        }
-
-        // Accessors
-        //--------------------------------------------------------------------
-        int         last_error()   const { return m_last_error; }
-        unsigned    resolution()   const { return m_resolution; }
-        const char* name()         const { return m_name;       }
-        unsigned    num_faces()    const;
-        FT_Encoding char_map()     const { return m_char_map;   }
-        double      height()       const { return double(m_height) / 64.0;    }
-        double      width()        const { return double(m_width) / 64.0;     }
-        double      ascender()     const;
-        double      descender()    const;
-        bool        hinting()      const { return m_hinting;    }
-        bool        flip_y()       const { return m_flip_y;     }
-
-
-        // Interface mandatory to implement for font_cache_manager
-        //--------------------------------------------------------------------
-        const char*     font_signature() const { return m_signature;    }
-        int             change_stamp()   const { return m_change_stamp; }
-
-        bool            prepare_glyph(unsigned glyph_code);
-        unsigned        glyph_index() const { return m_glyph_index; }
-        unsigned        data_size()   const { return m_data_size;   }
-        glyph_data_type data_type()   const { return m_data_type;   }
-        const rect_i&   bounds()      const { return m_bounds;      }
-        double          advance_x()   const { return m_advance_x;   }
-        double          advance_y()   const { return m_advance_y;   }
-        void            write_glyph_to(int8u* data) const;
-        bool            add_kerning(unsigned first, unsigned second,
-                                    double* x, double* y);
-
-    private:
-        font_engine_freetype_base(const font_engine_freetype_base&);
-        const font_engine_freetype_base& operator = (const font_engine_freetype_base&);
-
-        void update_char_size();
-        void update_signature();
-        int  find_face(const char* face_name) const;
-
-        bool            m_flag32;
-        int             m_change_stamp;
-        int             m_last_error;
-        char*           m_name;
-        unsigned        m_name_len;
-        unsigned        m_face_index;
-        FT_Encoding     m_char_map;
-        char*           m_signature;
-        unsigned        m_height;
-        unsigned        m_width;
-        bool            m_hinting;
-        bool            m_flip_y;
-        bool            m_library_initialized;
-        FT_Library      m_library;    // handle to library    
-        FT_Face*        m_faces;      // A pool of font faces
-        char**          m_face_names; 
-        unsigned        m_num_faces;
-        unsigned        m_max_faces;
-        FT_Face         m_cur_face;  // handle to the current face object
-        int             m_resolution;
-        glyph_rendering m_glyph_rendering;
-        unsigned        m_glyph_index;
-        unsigned        m_data_size;
-        glyph_data_type m_data_type;
-        rect_i          m_bounds;
-        double          m_advance_x;
-        double          m_advance_y;
-        trans_affine    m_affine;
-
-        path_storage_integer<int16, 6>              m_path16;
-        path_storage_integer<int32, 6>              m_path32;
-        conv_curve<path_storage_integer<int16, 6> > m_curves16;
-        conv_curve<path_storage_integer<int32, 6> > m_curves32;
-        scanline_u8              m_scanline_aa;
-        scanline_bin             m_scanline_bin;
-        scanlines_aa_type        m_scanlines_aa;
-        scanlines_bin_type       m_scanlines_bin;
-        rasterizer_scanline_aa<> m_rasterizer;
-    };
-
-
-
-
-    //------------------------------------------------font_engine_freetype_int16
-    // This class uses values of type int16 (10.6 format) for the vector cache. 
-    // The vector cache is compact, but when rendering glyphs of height
-    // more that 200 there integer overflow can occur.
-    //
-    class font_engine_freetype_int16 : public font_engine_freetype_base
-    {
-    public:
-        typedef serialized_integer_path_adaptor<int16, 6>     path_adaptor_type;
-        typedef font_engine_freetype_base::gray8_adaptor_type gray8_adaptor_type;
-        typedef font_engine_freetype_base::mono_adaptor_type  mono_adaptor_type;
-        typedef font_engine_freetype_base::scanlines_aa_type  scanlines_aa_type;
-        typedef font_engine_freetype_base::scanlines_bin_type scanlines_bin_type;
-
-        font_engine_freetype_int16(unsigned max_faces = 32) : 
-            font_engine_freetype_base(false, max_faces) {}
-    };
-
-    //------------------------------------------------font_engine_freetype_int32
-    // This class uses values of type int32 (26.6 format) for the vector cache. 
-    // The vector cache is twice larger than in font_engine_freetype_int16, 
-    // but it allows you to render glyphs of very large sizes.
-    //
-    class font_engine_freetype_int32 : public font_engine_freetype_base
-    {
-    public:
-        typedef serialized_integer_path_adaptor<int32, 6>     path_adaptor_type;
-        typedef font_engine_freetype_base::gray8_adaptor_type gray8_adaptor_type;
-        typedef font_engine_freetype_base::mono_adaptor_type  mono_adaptor_type;
-        typedef font_engine_freetype_base::scanlines_aa_type  scanlines_aa_type;
-        typedef font_engine_freetype_base::scanlines_bin_type scanlines_bin_type;
-
-        font_engine_freetype_int32(unsigned max_faces = 32) : 
-            font_engine_freetype_base(true, max_faces) {}
-    };
-
-
-}
-
-#endif

Sources/libagg/agg-2.4/agg_gamma_functions.h

@@ -1,123 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-
-#ifndef AGG_GAMMA_FUNCTIONS_INCLUDED
-#define AGG_GAMMA_FUNCTIONS_INCLUDED
-
-#include <math.h>
-#include "agg_basics.h"
-
-namespace agg
-{
-    //===============================================================gamma_none
-    struct gamma_none
-    {
-        double operator()(double x) const { return x; }
-    };
-
-
-    //==============================================================gamma_power
-    class gamma_power
-    {
-    public:
-        gamma_power() : m_gamma(1.0) {}
-        gamma_power(double g) : m_gamma(g) {}
-
-        void gamma(double g) { m_gamma = g; }
-        double gamma() const { return m_gamma; }
-
-        double operator() (double x) const
-        {
-            return pow(x, m_gamma);
-        }
-
-    private:
-        double m_gamma;
-    };
-
-
-    //==========================================================gamma_threshold
-    class gamma_threshold
-    {
-    public:
-        gamma_threshold() : m_threshold(0.5) {}
-        gamma_threshold(double t) : m_threshold(t) {}
-
-        void threshold(double t) { m_threshold = t; }
-        double threshold() const { return m_threshold; }
-
-        double operator() (double x) const
-        {
-            return (x < m_threshold) ? 0.0 : 1.0;
-        }
-
-    private:
-        double m_threshold;
-    };
-
-
-    //============================================================gamma_linear
-    class gamma_linear
-    {
-    public:
-        gamma_linear() : m_start(0.0), m_end(1.0) {}
-        gamma_linear(double s, double e) : m_start(s), m_end(e) {}
-
-        void set(double s, double e) { m_start = s; m_end = e; }
-        void start(double s) { m_start = s; }
-        void end(double e) { m_end = e; }
-        double start() const { return m_start; }
-        double end() const { return m_end; }
-
-        double operator() (double x) const
-        {
-            if(x < m_start) return 0.0;
-            if(x > m_end) return 1.0;
-            return (x - m_start) / (m_end - m_start);
-        }
-
-    private:
-        double m_start;
-        double m_end;
-    };
-
-
-    //==========================================================gamma_multiply
-    class gamma_multiply
-    {
-    public:
-        gamma_multiply() : m_mul(1.0) {}
-        gamma_multiply(double v) : m_mul(v) {}
-
-        void value(double v) { m_mul = v; }
-        double value() const { return m_mul; }
-
-        double operator() (double x) const
-        {
-            double y = x * m_mul;
-            if(y > 1.0) y = 1.0;
-            return y;
-        }
-
-    private:
-        double m_mul;
-    };
-
-}
-
-#endif
-
-
-

Sources/libagg/agg-2.4/agg_gamma_lut.h

@@ -1,121 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-
-#ifndef AGG_GAMMA_LUT_INCLUDED
-#define AGG_GAMMA_LUT_INCLUDED
-
-#include <math.h>
-#include "agg_basics.h"
-
-namespace agg
-{
-    template<class LoResT=int8u, 
-             class HiResT=int8u, 
-             unsigned GammaShift=8, 
-             unsigned HiResShift=8> class gamma_lut
-    {
-    public:
-        typedef gamma_lut<LoResT, HiResT, GammaShift, HiResShift> self_type;
-
-        enum gamma_scale_e
-        {
-            gamma_shift = GammaShift,
-            gamma_size  = 1 << gamma_shift,
-            gamma_mask  = gamma_size - 1
-        };
-
-        enum hi_res_scale_e
-        {
-            hi_res_shift = HiResShift,
-            hi_res_size  = 1 << hi_res_shift,
-            hi_res_mask  = hi_res_size - 1
-        };
-
-        ~gamma_lut()
-        {
-            pod_allocator<LoResT>::deallocate(m_inv_gamma, hi_res_size);
-            pod_allocator<HiResT>::deallocate(m_dir_gamma, gamma_size);
-        }
-
-        gamma_lut() : 
-            m_gamma(1.0), 
-            m_dir_gamma(pod_allocator<HiResT>::allocate(gamma_size)),
-            m_inv_gamma(pod_allocator<LoResT>::allocate(hi_res_size))
-        {
-            unsigned i;
-            for(i = 0; i < gamma_size; i++)
-            {
-                m_dir_gamma[i] = HiResT(i << (hi_res_shift - gamma_shift));
-            }
-
-            for(i = 0; i < hi_res_size; i++)
-            {
-                m_inv_gamma[i] = LoResT(i >> (hi_res_shift - gamma_shift));
-            }
-        }
-
-        gamma_lut(double g) :
-            m_gamma(1.0), 
-            m_dir_gamma(pod_allocator<HiResT>::allocate(gamma_size)),
-            m_inv_gamma(pod_allocator<LoResT>::allocate(hi_res_size))
-        {
-            gamma(g);
-        }
-
-        void gamma(double g) 
-        {
-            m_gamma = g;
-
-            unsigned i;
-            for(i = 0; i < gamma_size; i++)
-            {
-                m_dir_gamma[i] = (HiResT)
-                    uround(pow(i / double(gamma_mask), m_gamma) * double(hi_res_mask));
-            }
-
-            double inv_g = 1.0 / g;
-            for(i = 0; i < hi_res_size; i++)
-            {
-                m_inv_gamma[i] = (LoResT)
-                    uround(pow(i / double(hi_res_mask), inv_g) * double(gamma_mask));
-            }
-        }
-
-        double gamma() const
-        {
-            return m_gamma;
-        }
-
-        HiResT dir(LoResT v) const 
-        { 
-            return m_dir_gamma[unsigned(v)]; 
-        }
-
-        LoResT inv(HiResT v) const 
-        { 
-            return m_inv_gamma[unsigned(v)];
-        }
-
-    private:
-        gamma_lut(const self_type&);
-        const self_type& operator = (const self_type&);
-
-        double m_gamma;
-        HiResT* m_dir_gamma;
-        LoResT* m_inv_gamma;
-    };
-}
-
-#endif

Sources/libagg/agg-2.4/agg_glyph_raster_bin.h

@@ -1,155 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-
-#ifndef AGG_GLYPH_RASTER_BIN_INCLUDED
-#define AGG_GLYPH_RASTER_BIN_INCLUDED
-
-#include <string.h>
-#include "agg_basics.h"
-
-namespace agg
-{
-
-    //========================================================glyph_raster_bin
-    template<class ColorT> class glyph_raster_bin
-    {
-    public:
-        typedef ColorT color_type;
-
-        //--------------------------------------------------------------------
-        struct glyph_rect
-        {
-            int x1,y1,x2,y2;
-            double dx, dy;
-        };
-
-        //--------------------------------------------------------------------
-        glyph_raster_bin(const int8u* font) :
-            m_font(font),
-            m_big_endian(false)
-        {
-            int t = 1;
-            if(*(char*)&t == 0) m_big_endian = true;
-            memset(m_span, 0, sizeof(m_span));
-        }
-
-        //--------------------------------------------------------------------
-        const int8u* font() const { return m_font; }
-        void font(const int8u* f) { m_font = f; }
-
-        //--------------------------------------------------------------------
-        double height()    const { return m_font[0]; }
-        double base_line() const { return m_font[1]; }
-
-        //--------------------------------------------------------------------
-        template<class CharT>
-        double width(const CharT* str) const
-        {
-            unsigned start_char = m_font[2];
-            unsigned num_chars = m_font[3];
-
-            unsigned w = 0;
-            while(*str)
-            {
-                unsigned glyph = *str;
-                const int8u* bits = m_font + 4 + num_chars * 2 + 
-                                    value(m_font + 4 + (glyph - start_char) * 2);
-                w += *bits;
-                ++str;
-            }
-            return w;
-        }
-
-        //--------------------------------------------------------------------
-        void prepare(glyph_rect* r, double x, double y, unsigned glyph, bool flip)
-        {
-            unsigned start_char = m_font[2];
-            unsigned num_chars = m_font[3];
-
-            m_bits = m_font + 4 + num_chars * 2 + 
-                     value(m_font + 4 + (glyph - start_char) * 2);
-
-            m_glyph_width = *m_bits++;
-            m_glyph_byte_width = (m_glyph_width + 7) >> 3;
-
-            r->x1 = int(x);
-            r->x2 = r->x1 + m_glyph_width - 1;
-            if(flip)
-            {
-                r->y1 = int(y) - m_font[0] + m_font[1];
-                r->y2 = r->y1 + m_font[0] - 1;
-            }
-            else
-            {
-                r->y1 = int(y) - m_font[1] + 1;
-                r->y2 = r->y1 + m_font[0] - 1;
-            }
-            r->dx = m_glyph_width; 
-            r->dy = 0;
-        }
-
-        //--------------------------------------------------------------------
-        const cover_type* span(unsigned i)
-        {
-            i = m_font[0] - i - 1;
-            const int8u* bits = m_bits + i * m_glyph_byte_width;
-            unsigned j;
-            unsigned val = *bits;
-            unsigned nb = 0;
-            for(j = 0; j < m_glyph_width; ++j)
-            {
-                m_span[j] = (cover_type)((val & 0x80) ? cover_full : cover_none);
-                val <<= 1;
-                if(++nb >= 8)
-                {
-                    val = *++bits;
-                    nb = 0;
-                }
-            }
-            return m_span;
-        }
-
-    private:
-        //--------------------------------------------------------------------
-        int16u value(const int8u* p) const
-        {
-            int16u v;
-            if(m_big_endian)
-            {
-                 *(int8u*)&v      = p[1];
-                *((int8u*)&v + 1) = p[0];
-            }
-            else
-            {
-                 *(int8u*)&v      = p[0];
-                *((int8u*)&v + 1) = p[1];
-            }
-            return v;
-        }
-
-
-        //--------------------------------------------------------------------
-        const int8u* m_font;
-        bool m_big_endian;
-        cover_type m_span[32];
-        const int8u* m_bits;
-        unsigned m_glyph_width;
-        unsigned m_glyph_byte_width;
-    };
-
-
-}
-
-#endif

Sources/libagg/agg-2.4/agg_gradient_lut.h

@@ -1,244 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-
-#ifndef AGG_GRADIENT_LUT_INCLUDED
-#define AGG_GRADIENT_LUT_INCLUDED
-
-#include "agg_array.h"
-#include "agg_dda_line.h"
-#include "agg_color_rgba.h"
-#include "agg_color_gray.h"
-
-namespace agg
-{
-
-    //======================================================color_interpolator
-    template<class ColorT> struct color_interpolator
-    {
-    public:
-        typedef ColorT color_type;
-
-        color_interpolator(const color_type& c1, 
-                           const color_type& c2, 
-                           unsigned len) :
-            m_c1(c1),
-            m_c2(c2),
-            m_len(len),
-            m_count(0)
-        {}
-
-        void operator ++ ()
-        {
-            ++m_count;
-        }
-
-        color_type color() const
-        {
-            return m_c1.gradient(m_c2, double(m_count) / m_len);
-        }
-
-    private:
-        color_type m_c1;
-        color_type m_c2;
-        unsigned   m_len;
-        unsigned   m_count;
-    };
-
-    //========================================================================
-    // Fast specialization for rgba8
-    template<> struct color_interpolator<rgba8>
-    {
-    public:
-        typedef rgba8 color_type;
-
-        color_interpolator(const color_type& c1, 
-                           const color_type& c2, 
-                           unsigned len) :
-            r(c1.r, c2.r, len),
-            g(c1.g, c2.g, len),
-            b(c1.b, c2.b, len),
-            a(c1.a, c2.a, len)
-        {}
-
-        void operator ++ ()
-        {
-            ++r; ++g; ++b; ++a;
-        }
-
-        color_type color() const
-        {
-            return color_type(r.y(), g.y(), b.y(), a.y());
-        }
-
-    private:
-        agg::dda_line_interpolator<14> r, g, b, a;
-    };
-
-    //========================================================================
-    // Fast specialization for gray8
-    template<> struct color_interpolator<gray8>
-    {
-    public:
-        typedef gray8 color_type;
-
-        color_interpolator(const color_type& c1, 
-                           const color_type& c2, 
-                           unsigned len) :
-            v(c1.v, c2.v, len),
-            a(c1.a, c2.a, len)
-        {}
-
-        void operator ++ ()
-        {
-            ++v; ++a;
-        }
-
-        color_type color() const
-        {
-            return color_type(v.y(), a.y());
-        }
-
-    private:
-        agg::dda_line_interpolator<14> v,a;
-    };
-
-    //============================================================gradient_lut
-    template<class ColorInterpolator, 
-             unsigned ColorLutSize=256> class gradient_lut
-    {
-    public:
-        typedef ColorInterpolator interpolator_type;
-        typedef typename interpolator_type::color_type color_type;
-        enum { color_lut_size = ColorLutSize };
-
-        //--------------------------------------------------------------------
-        gradient_lut() : m_color_lut(color_lut_size) {}
-
-        // Build Gradient Lut
-        // First, call remove_all(), then add_color() at least twice, 
-        // then build_lut(). Argument "offset" in add_color must be 
-        // in range [0...1] and defines a color stop as it is described 
-        // in SVG specification, section Gradients and Patterns. 
-        // The simplest linear gradient is:
-        //    gradient_lut.add_color(0.0, start_color);
-        //    gradient_lut.add_color(1.0, end_color);
-        //--------------------------------------------------------------------
-        void remove_all();
-        void add_color(double offset, const color_type& color);
-        void build_lut();
-
-        // Size-index Interface. This class can be used directly as the 
-        // ColorF in span_gradient. All it needs is two access methods 
-        // size() and operator [].
-        //--------------------------------------------------------------------
-        static unsigned size() 
-        { 
-            return color_lut_size; 
-        }
-        const color_type& operator [] (unsigned i) const 
-        { 
-            return m_color_lut[i]; 
-        }
-
-    private:
-        //--------------------------------------------------------------------
-        struct color_point
-        {
-            double     offset;
-            color_type color;
-
-            color_point() {}
-            color_point(double off, const color_type& c) : 
-                offset(off), color(c)
-            {
-                if(offset < 0.0) offset = 0.0;
-                if(offset > 1.0) offset = 1.0;
-            }
-        };
-        typedef agg::pod_bvector<color_point, 4> color_profile_type;
-        typedef agg::pod_array<color_type>       color_lut_type;
-
-        static bool offset_less(const color_point& a, const color_point& b)
-        {
-            return a.offset < b.offset;
-        }
-        static bool offset_equal(const color_point& a, const color_point& b)
-        {
-            return a.offset == b.offset;
-        }
-
-        //--------------------------------------------------------------------
-        color_profile_type  m_color_profile;
-        color_lut_type      m_color_lut;
-    };
-
-
-
-    //------------------------------------------------------------------------
-    template<class T, unsigned S>
-    void gradient_lut<T,S>::remove_all()
-    { 
-        m_color_profile.remove_all(); 
-    }
-
-    //------------------------------------------------------------------------
-    template<class T, unsigned S>
-    void gradient_lut<T,S>::add_color(double offset, const color_type& color)
-    {
-        m_color_profile.add(color_point(offset, color));
-    }
-
-    //------------------------------------------------------------------------
-    template<class T, unsigned S>
-    void gradient_lut<T,S>::build_lut()
-    {
-        quick_sort(m_color_profile, offset_less);
-        m_color_profile.cut_at(remove_duplicates(m_color_profile, offset_equal));
-        if(m_color_profile.size() >= 2)
-        {
-            unsigned i;
-            unsigned start = uround(m_color_profile[0].offset * color_lut_size);
-            unsigned end;
-            color_type c = m_color_profile[0].color;
-            for(i = 0; i < start; i++) 
-            {
-                m_color_lut[i] = c;
-            }
-            for(i = 1; i < m_color_profile.size(); i++)
-            {
-                end  = uround(m_color_profile[i].offset * color_lut_size);
-                interpolator_type ci(m_color_profile[i-1].color, 
-                                     m_color_profile[i  ].color, 
-                                     end - start + 1);
-                while(start < end)
-                {
-                    m_color_lut[start] = ci.color();
-                    ++ci;
-                    ++start;
-                }
-            }
-            c = m_color_profile.last().color;
-            for(; end < m_color_lut.size(); end++)
-            {
-                m_color_lut[end] = c;
-            }
-        }
-    }
-}
-
-
-
-
-#endif

Sources/libagg/agg-2.4/agg_gsv_text.cpp

@@ -1,675 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// Class gsv_text
-//
-//----------------------------------------------------------------------------
-#include <string.h>
-#include <stdio.h>
-#include "agg_gsv_text.h"
-#include "agg_bounding_rect.h"
-
-
-
-namespace agg
-{
-    int8u gsv_default_font[] = 
-    {
-        0x40,0x00,0x6c,0x0f,0x15,0x00,0x0e,0x00,0xf9,0xff,
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-        0x0d,0x0a,0x0d,0x0a,0x46,0x6f,0x6e,0x74,0x20,0x28,
-        0x63,0x29,0x20,0x4d,0x69,0x63,0x72,0x6f,0x50,0x72,
-        0x6f,0x66,0x20,0x32,0x37,0x20,0x53,0x65,0x70,0x74,
-        0x65,0x6d,0x62,0x2e,0x31,0x39,0x38,0x39,0x00,0x0d,
-        0x0a,0x0d,0x0a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-        0x02,0x00,0x12,0x00,0x34,0x00,0x46,0x00,0x94,0x00,
-        0xd0,0x00,0x2e,0x01,0x3e,0x01,0x64,0x01,0x8a,0x01,
-        0x98,0x01,0xa2,0x01,0xb4,0x01,0xba,0x01,0xc6,0x01,
-        0xcc,0x01,0xf0,0x01,0xfa,0x01,0x18,0x02,0x38,0x02,
-        0x44,0x02,0x68,0x02,0x98,0x02,0xa2,0x02,0xde,0x02,
-        0x0e,0x03,0x24,0x03,0x40,0x03,0x48,0x03,0x52,0x03,
-        0x5a,0x03,0x82,0x03,0xec,0x03,0xfa,0x03,0x26,0x04,
-        0x4c,0x04,0x6a,0x04,0x7c,0x04,0x8a,0x04,0xb6,0x04,
-        0xc4,0x04,0xca,0x04,0xe0,0x04,0xee,0x04,0xf8,0x04,
-        0x0a,0x05,0x18,0x05,0x44,0x05,0x5e,0x05,0x8e,0x05,
-        0xac,0x05,0xd6,0x05,0xe0,0x05,0xf6,0x05,0x00,0x06,
-        0x12,0x06,0x1c,0x06,0x28,0x06,0x36,0x06,0x48,0x06,
-        0x4e,0x06,0x60,0x06,0x6e,0x06,0x74,0x06,0x84,0x06,
-        0xa6,0x06,0xc8,0x06,0xe6,0x06,0x08,0x07,0x2c,0x07,
-        0x3c,0x07,0x68,0x07,0x7c,0x07,0x8c,0x07,0xa2,0x07,
-        0xb0,0x07,0xb6,0x07,0xd8,0x07,0xec,0x07,0x10,0x08,
-        0x32,0x08,0x54,0x08,0x64,0x08,0x88,0x08,0x98,0x08,
-        0xac,0x08,0xb6,0x08,0xc8,0x08,0xd2,0x08,0xe4,0x08,
-        0xf2,0x08,0x3e,0x09,0x48,0x09,0x94,0x09,0xc2,0x09,
-        0xc4,0x09,0xd0,0x09,0xe2,0x09,0x04,0x0a,0x0e,0x0a,
-        0x26,0x0a,0x34,0x0a,0x4a,0x0a,0x66,0x0a,0x70,0x0a,
-        0x7e,0x0a,0x8e,0x0a,0x9a,0x0a,0xa6,0x0a,0xb4,0x0a,
-        0xd8,0x0a,0xe2,0x0a,0xf6,0x0a,0x18,0x0b,0x22,0x0b,
-        0x32,0x0b,0x56,0x0b,0x60,0x0b,0x6e,0x0b,0x7c,0x0b,
-        0x8a,0x0b,0x9c,0x0b,0x9e,0x0b,0xb2,0x0b,0xc2,0x0b,
-        0xd8,0x0b,0xf4,0x0b,0x08,0x0c,0x30,0x0c,0x56,0x0c,
-        0x72,0x0c,0x90,0x0c,0xb2,0x0c,0xce,0x0c,0xe2,0x0c,
-        0xfe,0x0c,0x10,0x0d,0x26,0x0d,0x36,0x0d,0x42,0x0d,
-        0x4e,0x0d,0x5c,0x0d,0x78,0x0d,0x8c,0x0d,0x8e,0x0d,
-        0x90,0x0d,0x92,0x0d,0x94,0x0d,0x96,0x0d,0x98,0x0d,
-        0x9a,0x0d,0x9c,0x0d,0x9e,0x0d,0xa0,0x0d,0xa2,0x0d,
-        0xa4,0x0d,0xa6,0x0d,0xa8,0x0d,0xaa,0x0d,0xac,0x0d,
-        0xae,0x0d,0xb0,0x0d,0xb2,0x0d,0xb4,0x0d,0xb6,0x0d,
-        0xb8,0x0d,0xba,0x0d,0xbc,0x0d,0xbe,0x0d,0xc0,0x0d,
-        0xc2,0x0d,0xc4,0x0d,0xc6,0x0d,0xc8,0x0d,0xca,0x0d,
-        0xcc,0x0d,0xce,0x0d,0xd0,0x0d,0xd2,0x0d,0xd4,0x0d,
-        0xd6,0x0d,0xd8,0x0d,0xda,0x0d,0xdc,0x0d,0xde,0x0d,
-        0xe0,0x0d,0xe2,0x0d,0xe4,0x0d,0xe6,0x0d,0xe8,0x0d,
-        0xea,0x0d,0xec,0x0d,0x0c,0x0e,0x26,0x0e,0x48,0x0e,
-        0x64,0x0e,0x88,0x0e,0x92,0x0e,0xa6,0x0e,0xb4,0x0e,
-        0xd0,0x0e,0xee,0x0e,0x02,0x0f,0x16,0x0f,0x26,0x0f,
-        0x3c,0x0f,0x58,0x0f,0x6c,0x0f,0x6c,0x0f,0x6c,0x0f,
-        0x6c,0x0f,0x6c,0x0f,0x6c,0x0f,0x6c,0x0f,0x6c,0x0f,
-        0x6c,0x0f,0x6c,0x0f,0x6c,0x0f,0x6c,0x0f,0x6c,0x0f,
-        0x6c,0x0f,0x6c,0x0f,0x6c,0x0f,0x6c,0x0f,0x10,0x80,
-        0x05,0x95,0x00,0x72,0x00,0xfb,0xff,0x7f,0x01,0x7f,
-        0x01,0x01,0xff,0x01,0x05,0xfe,0x05,0x95,0xff,0x7f,
-        0x00,0x7a,0x01,0x86,0xff,0x7a,0x01,0x87,0x01,0x7f,
-        0xfe,0x7a,0x0a,0x87,0xff,0x7f,0x00,0x7a,0x01,0x86,
-        0xff,0x7a,0x01,0x87,0x01,0x7f,0xfe,0x7a,0x05,0xf2,
-        0x0b,0x95,0xf9,0x64,0x0d,0x9c,0xf9,0x64,0xfa,0x91,
-        0x0e,0x00,0xf1,0xfa,0x0e,0x00,0x04,0xfc,0x08,0x99,
-        0x00,0x63,0x04,0x9d,0x00,0x63,0x04,0x96,0xff,0x7f,
-        0x01,0x7f,0x01,0x01,0x00,0x01,0xfe,0x02,0xfd,0x01,
-        0xfc,0x00,0xfd,0x7f,0xfe,0x7e,0x00,0x7e,0x01,0x7e,
-        0x01,0x7f,0x02,0x7f,0x06,0x7e,0x02,0x7f,0x02,0x7e,
-        0xf2,0x89,0x02,0x7e,0x02,0x7f,0x06,0x7e,0x02,0x7f,
-        0x01,0x7f,0x01,0x7e,0x00,0x7c,0xfe,0x7e,0xfd,0x7f,
-        0xfc,0x00,0xfd,0x01,0xfe,0x02,0x00,0x01,0x01,0x01,
-        0x01,0x7f,0xff,0x7f,0x10,0xfd,0x15,0x95,0xee,0x6b,
-        0x05,0x95,0x02,0x7e,0x00,0x7e,0xff,0x7e,0xfe,0x7f,
-        0xfe,0x00,0xfe,0x02,0x00,0x02,0x01,0x02,0x02,0x01,
-        0x02,0x00,0x02,0x7f,0x03,0x7f,0x03,0x00,0x03,0x01,
-        0x02,0x01,0xfc,0xf2,0xfe,0x7f,0xff,0x7e,0x00,0x7e,
-        0x02,0x7e,0x02,0x00,0x02,0x01,0x01,0x02,0x00,0x02,
-        0xfe,0x02,0xfe,0x00,0x07,0xf9,0x15,0x8d,0xff,0x7f,
-        0x01,0x7f,0x01,0x01,0x00,0x01,0xff,0x01,0xff,0x00,
-        0xff,0x7f,0xff,0x7e,0xfe,0x7b,0xfe,0x7d,0xfe,0x7e,
-        0xfe,0x7f,0xfd,0x00,0xfd,0x01,0xff,0x02,0x00,0x03,
-        0x01,0x02,0x06,0x04,0x02,0x02,0x01,0x02,0x00,0x02,
-        0xff,0x02,0xfe,0x01,0xfe,0x7f,0xff,0x7e,0x00,0x7e,
-        0x01,0x7d,0x02,0x7d,0x05,0x79,0x02,0x7e,0x03,0x7f,
-        0x01,0x00,0x01,0x01,0x00,0x01,0xf1,0xfe,0xfe,0x01,
-        0xff,0x02,0x00,0x03,0x01,0x02,0x02,0x02,0x00,0x86,
-        0x01,0x7e,0x08,0x75,0x02,0x7e,0x02,0x7f,0x05,0x80,
-        0x05,0x93,0xff,0x01,0x01,0x01,0x01,0x7f,0x00,0x7e,
-        0xff,0x7e,0xff,0x7f,0x06,0xf1,0x0b,0x99,0xfe,0x7e,
-        0xfe,0x7d,0xfe,0x7c,0xff,0x7b,0x00,0x7c,0x01,0x7b,
-        0x02,0x7c,0x02,0x7d,0x02,0x7e,0xfe,0x9e,0xfe,0x7c,
-        0xff,0x7d,0xff,0x7b,0x00,0x7c,0x01,0x7b,0x01,0x7d,
-        0x02,0x7c,0x05,0x85,0x03,0x99,0x02,0x7e,0x02,0x7d,
-        0x02,0x7c,0x01,0x7b,0x00,0x7c,0xff,0x7b,0xfe,0x7c,
-        0xfe,0x7d,0xfe,0x7e,0x02,0x9e,0x02,0x7c,0x01,0x7d,
-        0x01,0x7b,0x00,0x7c,0xff,0x7b,0xff,0x7d,0xfe,0x7c,
-        0x09,0x85,0x08,0x95,0x00,0x74,0xfb,0x89,0x0a,0x7a,
-        0x00,0x86,0xf6,0x7a,0x0d,0xf4,0x0d,0x92,0x00,0x6e,
-        0xf7,0x89,0x12,0x00,0x04,0xf7,0x06,0x81,0xff,0x7f,
-        0xff,0x01,0x01,0x01,0x01,0x7f,0x00,0x7e,0xff,0x7e,
-        0xff,0x7f,0x06,0x84,0x04,0x89,0x12,0x00,0x04,0xf7,
-        0x05,0x82,0xff,0x7f,0x01,0x7f,0x01,0x01,0xff,0x01,
-        0x05,0xfe,0x00,0xfd,0x0e,0x18,0x00,0xeb,0x09,0x95,
-        0xfd,0x7f,0xfe,0x7d,0xff,0x7b,0x00,0x7d,0x01,0x7b,
-        0x02,0x7d,0x03,0x7f,0x02,0x00,0x03,0x01,0x02,0x03,
-        0x01,0x05,0x00,0x03,0xff,0x05,0xfe,0x03,0xfd,0x01,
-        0xfe,0x00,0x0b,0xeb,0x06,0x91,0x02,0x01,0x03,0x03,
-        0x00,0x6b,0x09,0x80,0x04,0x90,0x00,0x01,0x01,0x02,
-        0x01,0x01,0x02,0x01,0x04,0x00,0x02,0x7f,0x01,0x7f,
-        0x01,0x7e,0x00,0x7e,0xff,0x7e,0xfe,0x7d,0xf6,0x76,
-        0x0e,0x00,0x03,0x80,0x05,0x95,0x0b,0x00,0xfa,0x78,
-        0x03,0x00,0x02,0x7f,0x01,0x7f,0x01,0x7d,0x00,0x7e,
-        0xff,0x7d,0xfe,0x7e,0xfd,0x7f,0xfd,0x00,0xfd,0x01,
-        0xff,0x01,0xff,0x02,0x11,0xfc,0x0d,0x95,0xf6,0x72,
-        0x0f,0x00,0xfb,0x8e,0x00,0x6b,0x07,0x80,0x0f,0x95,
-        0xf6,0x00,0xff,0x77,0x01,0x01,0x03,0x01,0x03,0x00,
-        0x03,0x7f,0x02,0x7e,0x01,0x7d,0x00,0x7e,0xff,0x7d,
-        0xfe,0x7e,0xfd,0x7f,0xfd,0x00,0xfd,0x01,0xff,0x01,
-        0xff,0x02,0x11,0xfc,0x10,0x92,0xff,0x02,0xfd,0x01,
-        0xfe,0x00,0xfd,0x7f,0xfe,0x7d,0xff,0x7b,0x00,0x7b,
-        0x01,0x7c,0x02,0x7e,0x03,0x7f,0x01,0x00,0x03,0x01,
-        0x02,0x02,0x01,0x03,0x00,0x01,0xff,0x03,0xfe,0x02,
-        0xfd,0x01,0xff,0x00,0xfd,0x7f,0xfe,0x7e,0xff,0x7d,
-        0x10,0xf9,0x11,0x95,0xf6,0x6b,0xfc,0x95,0x0e,0x00,
-        0x03,0xeb,0x08,0x95,0xfd,0x7f,0xff,0x7e,0x00,0x7e,
-        0x01,0x7e,0x02,0x7f,0x04,0x7f,0x03,0x7f,0x02,0x7e,
-        0x01,0x7e,0x00,0x7d,0xff,0x7e,0xff,0x7f,0xfd,0x7f,
-        0xfc,0x00,0xfd,0x01,0xff,0x01,0xff,0x02,0x00,0x03,
-        0x01,0x02,0x02,0x02,0x03,0x01,0x04,0x01,0x02,0x01,
-        0x01,0x02,0x00,0x02,0xff,0x02,0xfd,0x01,0xfc,0x00,
-        0x0c,0xeb,0x10,0x8e,0xff,0x7d,0xfe,0x7e,0xfd,0x7f,
-        0xff,0x00,0xfd,0x01,0xfe,0x02,0xff,0x03,0x00,0x01,
-        0x01,0x03,0x02,0x02,0x03,0x01,0x01,0x00,0x03,0x7f,
-        0x02,0x7e,0x01,0x7c,0x00,0x7b,0xff,0x7b,0xfe,0x7d,
-        0xfd,0x7f,0xfe,0x00,0xfd,0x01,0xff,0x02,0x10,0xfd,
-        0x05,0x8e,0xff,0x7f,0x01,0x7f,0x01,0x01,0xff,0x01,
-        0x00,0xf4,0xff,0x7f,0x01,0x7f,0x01,0x01,0xff,0x01,
-        0x05,0xfe,0x05,0x8e,0xff,0x7f,0x01,0x7f,0x01,0x01,
-        0xff,0x01,0x01,0xf3,0xff,0x7f,0xff,0x01,0x01,0x01,
-        0x01,0x7f,0x00,0x7e,0xff,0x7e,0xff,0x7f,0x06,0x84,
-        0x14,0x92,0xf0,0x77,0x10,0x77,0x04,0x80,0x04,0x8c,
-        0x12,0x00,0xee,0xfa,0x12,0x00,0x04,0xfa,0x04,0x92,
-        0x10,0x77,0xf0,0x77,0x14,0x80,0x03,0x90,0x00,0x01,
-        0x01,0x02,0x01,0x01,0x02,0x01,0x04,0x00,0x02,0x7f,
-        0x01,0x7f,0x01,0x7e,0x00,0x7e,0xff,0x7e,0xff,0x7f,
-        0xfc,0x7e,0x00,0x7d,0x00,0xfb,0xff,0x7f,0x01,0x7f,
-        0x01,0x01,0xff,0x01,0x09,0xfe,0x12,0x8d,0xff,0x02,
-        0xfe,0x01,0xfd,0x00,0xfe,0x7f,0xff,0x7f,0xff,0x7d,
-        0x00,0x7d,0x01,0x7e,0x02,0x7f,0x03,0x00,0x02,0x01,
-        0x01,0x02,0xfb,0x88,0xfe,0x7e,0xff,0x7d,0x00,0x7d,
-        0x01,0x7e,0x01,0x7f,0x07,0x8b,0xff,0x78,0x00,0x7e,
-        0x02,0x7f,0x02,0x00,0x02,0x02,0x01,0x03,0x00,0x02,
-        0xff,0x03,0xff,0x02,0xfe,0x02,0xfe,0x01,0xfd,0x01,
-        0xfd,0x00,0xfd,0x7f,0xfe,0x7f,0xfe,0x7e,0xff,0x7e,
-        0xff,0x7d,0x00,0x7d,0x01,0x7d,0x01,0x7e,0x02,0x7e,
-        0x02,0x7f,0x03,0x7f,0x03,0x00,0x03,0x01,0x02,0x01,
-        0x01,0x01,0xfe,0x8d,0xff,0x78,0x00,0x7e,0x01,0x7f,
-        0x08,0xfb,0x09,0x95,0xf8,0x6b,0x08,0x95,0x08,0x6b,
-        0xf3,0x87,0x0a,0x00,0x04,0xf9,0x04,0x95,0x00,0x6b,
-        0x00,0x95,0x09,0x00,0x03,0x7f,0x01,0x7f,0x01,0x7e,
-        0x00,0x7e,0xff,0x7e,0xff,0x7f,0xfd,0x7f,0xf7,0x80,
-        0x09,0x00,0x03,0x7f,0x01,0x7f,0x01,0x7e,0x00,0x7d,
-        0xff,0x7e,0xff,0x7f,0xfd,0x7f,0xf7,0x00,0x11,0x80,
-        0x12,0x90,0xff,0x02,0xfe,0x02,0xfe,0x01,0xfc,0x00,
-        0xfe,0x7f,0xfe,0x7e,0xff,0x7e,0xff,0x7d,0x00,0x7b,
-        0x01,0x7d,0x01,0x7e,0x02,0x7e,0x02,0x7f,0x04,0x00,
-        0x02,0x01,0x02,0x02,0x01,0x02,0x03,0xfb,0x04,0x95,
-        0x00,0x6b,0x00,0x95,0x07,0x00,0x03,0x7f,0x02,0x7e,
-        0x01,0x7e,0x01,0x7d,0x00,0x7b,0xff,0x7d,0xff,0x7e,
-        0xfe,0x7e,0xfd,0x7f,0xf9,0x00,0x11,0x80,0x04,0x95,
-        0x00,0x6b,0x00,0x95,0x0d,0x00,0xf3,0xf6,0x08,0x00,
-        0xf8,0xf5,0x0d,0x00,0x02,0x80,0x04,0x95,0x00,0x6b,
-        0x00,0x95,0x0d,0x00,0xf3,0xf6,0x08,0x00,0x06,0xf5,
-        0x12,0x90,0xff,0x02,0xfe,0x02,0xfe,0x01,0xfc,0x00,
-        0xfe,0x7f,0xfe,0x7e,0xff,0x7e,0xff,0x7d,0x00,0x7b,
-        0x01,0x7d,0x01,0x7e,0x02,0x7e,0x02,0x7f,0x04,0x00,
-        0x02,0x01,0x02,0x02,0x01,0x02,0x00,0x03,0xfb,0x80,
-        0x05,0x00,0x03,0xf8,0x04,0x95,0x00,0x6b,0x0e,0x95,
-        0x00,0x6b,0xf2,0x8b,0x0e,0x00,0x04,0xf5,0x04,0x95,
-        0x00,0x6b,0x04,0x80,0x0c,0x95,0x00,0x70,0xff,0x7d,
-        0xff,0x7f,0xfe,0x7f,0xfe,0x00,0xfe,0x01,0xff,0x01,
-        0xff,0x03,0x00,0x02,0x0e,0xf9,0x04,0x95,0x00,0x6b,
-        0x0e,0x95,0xf2,0x72,0x05,0x85,0x09,0x74,0x03,0x80,
-        0x04,0x95,0x00,0x6b,0x00,0x80,0x0c,0x00,0x01,0x80,
-        0x04,0x95,0x00,0x6b,0x00,0x95,0x08,0x6b,0x08,0x95,
-        0xf8,0x6b,0x08,0x95,0x00,0x6b,0x04,0x80,0x04,0x95,
-        0x00,0x6b,0x00,0x95,0x0e,0x6b,0x00,0x95,0x00,0x6b,
-        0x04,0x80,0x09,0x95,0xfe,0x7f,0xfe,0x7e,0xff,0x7e,
-        0xff,0x7d,0x00,0x7b,0x01,0x7d,0x01,0x7e,0x02,0x7e,
-        0x02,0x7f,0x04,0x00,0x02,0x01,0x02,0x02,0x01,0x02,
-        0x01,0x03,0x00,0x05,0xff,0x03,0xff,0x02,0xfe,0x02,
-        0xfe,0x01,0xfc,0x00,0x0d,0xeb,0x04,0x95,0x00,0x6b,
-        0x00,0x95,0x09,0x00,0x03,0x7f,0x01,0x7f,0x01,0x7e,
-        0x00,0x7d,0xff,0x7e,0xff,0x7f,0xfd,0x7f,0xf7,0x00,
-        0x11,0xf6,0x09,0x95,0xfe,0x7f,0xfe,0x7e,0xff,0x7e,
-        0xff,0x7d,0x00,0x7b,0x01,0x7d,0x01,0x7e,0x02,0x7e,
-        0x02,0x7f,0x04,0x00,0x02,0x01,0x02,0x02,0x01,0x02,
-        0x01,0x03,0x00,0x05,0xff,0x03,0xff,0x02,0xfe,0x02,
-        0xfe,0x01,0xfc,0x00,0x03,0xef,0x06,0x7a,0x04,0x82,
-        0x04,0x95,0x00,0x6b,0x00,0x95,0x09,0x00,0x03,0x7f,
-        0x01,0x7f,0x01,0x7e,0x00,0x7e,0xff,0x7e,0xff,0x7f,
-        0xfd,0x7f,0xf7,0x00,0x07,0x80,0x07,0x75,0x03,0x80,
-        0x11,0x92,0xfe,0x02,0xfd,0x01,0xfc,0x00,0xfd,0x7f,
-        0xfe,0x7e,0x00,0x7e,0x01,0x7e,0x01,0x7f,0x02,0x7f,
-        0x06,0x7e,0x02,0x7f,0x01,0x7f,0x01,0x7e,0x00,0x7d,
-        0xfe,0x7e,0xfd,0x7f,0xfc,0x00,0xfd,0x01,0xfe,0x02,
-        0x11,0xfd,0x08,0x95,0x00,0x6b,0xf9,0x95,0x0e,0x00,
-        0x01,0xeb,0x04,0x95,0x00,0x71,0x01,0x7d,0x02,0x7e,
-        0x03,0x7f,0x02,0x00,0x03,0x01,0x02,0x02,0x01,0x03,
-        0x00,0x0f,0x04,0xeb,0x01,0x95,0x08,0x6b,0x08,0x95,
-        0xf8,0x6b,0x09,0x80,0x02,0x95,0x05,0x6b,0x05,0x95,
-        0xfb,0x6b,0x05,0x95,0x05,0x6b,0x05,0x95,0xfb,0x6b,
-        0x07,0x80,0x03,0x95,0x0e,0x6b,0x00,0x95,0xf2,0x6b,
-        0x11,0x80,0x01,0x95,0x08,0x76,0x00,0x75,0x08,0x95,
-        0xf8,0x76,0x09,0xf5,0x11,0x95,0xf2,0x6b,0x00,0x95,
-        0x0e,0x00,0xf2,0xeb,0x0e,0x00,0x03,0x80,0x03,0x93,
-        0x00,0x6c,0x01,0x94,0x00,0x6c,0xff,0x94,0x05,0x00,
-        0xfb,0xec,0x05,0x00,0x02,0x81,0x00,0x95,0x0e,0x68,
-        0x00,0x83,0x06,0x93,0x00,0x6c,0x01,0x94,0x00,0x6c,
-        0xfb,0x94,0x05,0x00,0xfb,0xec,0x05,0x00,0x03,0x81,
-        0x03,0x87,0x08,0x05,0x08,0x7b,0xf0,0x80,0x08,0x04,
-        0x08,0x7c,0x03,0xf9,0x01,0x80,0x10,0x00,0x01,0x80,
-        0x06,0x95,0xff,0x7f,0xff,0x7e,0x00,0x7e,0x01,0x7f,
-        0x01,0x01,0xff,0x01,0x05,0xef,0x0f,0x8e,0x00,0x72,
-        0x00,0x8b,0xfe,0x02,0xfe,0x01,0xfd,0x00,0xfe,0x7f,
-        0xfe,0x7e,0xff,0x7d,0x00,0x7e,0x01,0x7d,0x02,0x7e,
-        0x02,0x7f,0x03,0x00,0x02,0x01,0x02,0x02,0x04,0xfd,
-        0x04,0x95,0x00,0x6b,0x00,0x8b,0x02,0x02,0x02,0x01,
-        0x03,0x00,0x02,0x7f,0x02,0x7e,0x01,0x7d,0x00,0x7e,
-        0xff,0x7d,0xfe,0x7e,0xfe,0x7f,0xfd,0x00,0xfe,0x01,
-        0xfe,0x02,0x0f,0xfd,0x0f,0x8b,0xfe,0x02,0xfe,0x01,
-        0xfd,0x00,0xfe,0x7f,0xfe,0x7e,0xff,0x7d,0x00,0x7e,
-        0x01,0x7d,0x02,0x7e,0x02,0x7f,0x03,0x00,0x02,0x01,
-        0x02,0x02,0x03,0xfd,0x0f,0x95,0x00,0x6b,0x00,0x8b,
-        0xfe,0x02,0xfe,0x01,0xfd,0x00,0xfe,0x7f,0xfe,0x7e,
-        0xff,0x7d,0x00,0x7e,0x01,0x7d,0x02,0x7e,0x02,0x7f,
-        0x03,0x00,0x02,0x01,0x02,0x02,0x04,0xfd,0x03,0x88,
-        0x0c,0x00,0x00,0x02,0xff,0x02,0xff,0x01,0xfe,0x01,
-        0xfd,0x00,0xfe,0x7f,0xfe,0x7e,0xff,0x7d,0x00,0x7e,
-        0x01,0x7d,0x02,0x7e,0x02,0x7f,0x03,0x00,0x02,0x01,
-        0x02,0x02,0x03,0xfd,0x0a,0x95,0xfe,0x00,0xfe,0x7f,
-        0xff,0x7d,0x00,0x6f,0xfd,0x8e,0x07,0x00,0x03,0xf2,
-        0x0f,0x8e,0x00,0x70,0xff,0x7d,0xff,0x7f,0xfe,0x7f,
-        0xfd,0x00,0xfe,0x01,0x09,0x91,0xfe,0x02,0xfe,0x01,
-        0xfd,0x00,0xfe,0x7f,0xfe,0x7e,0xff,0x7d,0x00,0x7e,
-        0x01,0x7d,0x02,0x7e,0x02,0x7f,0x03,0x00,0x02,0x01,
-        0x02,0x02,0x04,0xfd,0x04,0x95,0x00,0x6b,0x00,0x8a,
-        0x03,0x03,0x02,0x01,0x03,0x00,0x02,0x7f,0x01,0x7d,
-        0x00,0x76,0x04,0x80,0x03,0x95,0x01,0x7f,0x01,0x01,
-        0xff,0x01,0xff,0x7f,0x01,0xf9,0x00,0x72,0x04,0x80,
-        0x05,0x95,0x01,0x7f,0x01,0x01,0xff,0x01,0xff,0x7f,
-        0x01,0xf9,0x00,0x6f,0xff,0x7d,0xfe,0x7f,0xfe,0x00,
-        0x09,0x87,0x04,0x95,0x00,0x6b,0x0a,0x8e,0xf6,0x76,
-        0x04,0x84,0x07,0x78,0x02,0x80,0x04,0x95,0x00,0x6b,
-        0x04,0x80,0x04,0x8e,0x00,0x72,0x00,0x8a,0x03,0x03,
-        0x02,0x01,0x03,0x00,0x02,0x7f,0x01,0x7d,0x00,0x76,
-        0x00,0x8a,0x03,0x03,0x02,0x01,0x03,0x00,0x02,0x7f,
-        0x01,0x7d,0x00,0x76,0x04,0x80,0x04,0x8e,0x00,0x72,
-        0x00,0x8a,0x03,0x03,0x02,0x01,0x03,0x00,0x02,0x7f,
-        0x01,0x7d,0x00,0x76,0x04,0x80,0x08,0x8e,0xfe,0x7f,
-        0xfe,0x7e,0xff,0x7d,0x00,0x7e,0x01,0x7d,0x02,0x7e,
-        0x02,0x7f,0x03,0x00,0x02,0x01,0x02,0x02,0x01,0x03,
-        0x00,0x02,0xff,0x03,0xfe,0x02,0xfe,0x01,0xfd,0x00,
-        0x0b,0xf2,0x04,0x8e,0x00,0x6b,0x00,0x92,0x02,0x02,
-        0x02,0x01,0x03,0x00,0x02,0x7f,0x02,0x7e,0x01,0x7d,
-        0x00,0x7e,0xff,0x7d,0xfe,0x7e,0xfe,0x7f,0xfd,0x00,
-        0xfe,0x01,0xfe,0x02,0x0f,0xfd,0x0f,0x8e,0x00,0x6b,
-        0x00,0x92,0xfe,0x02,0xfe,0x01,0xfd,0x00,0xfe,0x7f,
-        0xfe,0x7e,0xff,0x7d,0x00,0x7e,0x01,0x7d,0x02,0x7e,
-        0x02,0x7f,0x03,0x00,0x02,0x01,0x02,0x02,0x04,0xfd,
-        0x04,0x8e,0x00,0x72,0x00,0x88,0x01,0x03,0x02,0x02,
-        0x02,0x01,0x03,0x00,0x01,0xf2,0x0e,0x8b,0xff,0x02,
-        0xfd,0x01,0xfd,0x00,0xfd,0x7f,0xff,0x7e,0x01,0x7e,
-        0x02,0x7f,0x05,0x7f,0x02,0x7f,0x01,0x7e,0x00,0x7f,
-        0xff,0x7e,0xfd,0x7f,0xfd,0x00,0xfd,0x01,0xff,0x02,
-        0x0e,0xfd,0x05,0x95,0x00,0x6f,0x01,0x7d,0x02,0x7f,
-        0x02,0x00,0xf8,0x8e,0x07,0x00,0x03,0xf2,0x04,0x8e,
-        0x00,0x76,0x01,0x7d,0x02,0x7f,0x03,0x00,0x02,0x01,
-        0x03,0x03,0x00,0x8a,0x00,0x72,0x04,0x80,0x02,0x8e,
-        0x06,0x72,0x06,0x8e,0xfa,0x72,0x08,0x80,0x03,0x8e,
-        0x04,0x72,0x04,0x8e,0xfc,0x72,0x04,0x8e,0x04,0x72,
-        0x04,0x8e,0xfc,0x72,0x07,0x80,0x03,0x8e,0x0b,0x72,
-        0x00,0x8e,0xf5,0x72,0x0e,0x80,0x02,0x8e,0x06,0x72,
-        0x06,0x8e,0xfa,0x72,0xfe,0x7c,0xfe,0x7e,0xfe,0x7f,
-        0xff,0x00,0x0f,0x87,0x0e,0x8e,0xf5,0x72,0x00,0x8e,
-        0x0b,0x00,0xf5,0xf2,0x0b,0x00,0x03,0x80,0x09,0x99,
-        0xfe,0x7f,0xff,0x7f,0xff,0x7e,0x00,0x7e,0x01,0x7e,
-        0x01,0x7f,0x01,0x7e,0x00,0x7e,0xfe,0x7e,0x01,0x8e,
-        0xff,0x7e,0x00,0x7e,0x01,0x7e,0x01,0x7f,0x01,0x7e,
-        0x00,0x7e,0xff,0x7e,0xfc,0x7e,0x04,0x7e,0x01,0x7e,
-        0x00,0x7e,0xff,0x7e,0xff,0x7f,0xff,0x7e,0x00,0x7e,
-        0x01,0x7e,0xff,0x8e,0x02,0x7e,0x00,0x7e,0xff,0x7e,
-        0xff,0x7f,0xff,0x7e,0x00,0x7e,0x01,0x7e,0x01,0x7f,
-        0x02,0x7f,0x05,0x87,0x04,0x95,0x00,0x77,0x00,0xfd,
-        0x00,0x77,0x04,0x80,0x05,0x99,0x02,0x7f,0x01,0x7f,
-        0x01,0x7e,0x00,0x7e,0xff,0x7e,0xff,0x7f,0xff,0x7e,
-        0x00,0x7e,0x02,0x7e,0xff,0x8e,0x01,0x7e,0x00,0x7e,
-        0xff,0x7e,0xff,0x7f,0xff,0x7e,0x00,0x7e,0x01,0x7e,
-        0x04,0x7e,0xfc,0x7e,0xff,0x7e,0x00,0x7e,0x01,0x7e,
-        0x01,0x7f,0x01,0x7e,0x00,0x7e,0xff,0x7e,0x01,0x8e,
-        0xfe,0x7e,0x00,0x7e,0x01,0x7e,0x01,0x7f,0x01,0x7e,
-        0x00,0x7e,0xff,0x7e,0xff,0x7f,0xfe,0x7f,0x09,0x87,
-        0x03,0x86,0x00,0x02,0x01,0x03,0x02,0x01,0x02,0x00,
-        0x02,0x7f,0x04,0x7d,0x02,0x7f,0x02,0x00,0x02,0x01,
-        0x01,0x02,0xee,0xfe,0x01,0x02,0x02,0x01,0x02,0x00,
-        0x02,0x7f,0x04,0x7d,0x02,0x7f,0x02,0x00,0x02,0x01,
-        0x01,0x03,0x00,0x02,0x03,0xf4,0x10,0x80,0x03,0x80,
-        0x07,0x15,0x08,0x6b,0xfe,0x85,0xf5,0x00,0x10,0xfb,
-        0x0d,0x95,0xf6,0x00,0x00,0x6b,0x0a,0x00,0x02,0x02,
-        0x00,0x08,0xfe,0x02,0xf6,0x00,0x0e,0xf4,0x03,0x80,
-        0x00,0x15,0x0a,0x00,0x02,0x7e,0x00,0x7e,0x00,0x7d,
-        0x00,0x7e,0xfe,0x7f,0xf6,0x00,0x0a,0x80,0x02,0x7e,
-        0x01,0x7e,0x00,0x7d,0xff,0x7d,0xfe,0x7f,0xf6,0x00,
-        0x10,0x80,0x03,0x80,0x00,0x15,0x0c,0x00,0xff,0x7e,
-        0x03,0xed,0x03,0xfd,0x00,0x03,0x02,0x00,0x00,0x12,
-        0x02,0x03,0x0a,0x00,0x00,0x6b,0x02,0x00,0x00,0x7d,
-        0xfe,0x83,0xf4,0x00,0x11,0x80,0x0f,0x80,0xf4,0x00,
-        0x00,0x15,0x0c,0x00,0xff,0xf6,0xf5,0x00,0x0f,0xf5,
-        0x04,0x95,0x07,0x76,0x00,0x0a,0x07,0x80,0xf9,0x76,
-        0x00,0x75,0xf8,0x80,0x07,0x0c,0x09,0xf4,0xf9,0x0c,
-        0x09,0xf4,0x03,0x92,0x02,0x03,0x07,0x00,0x03,0x7d,
-        0x00,0x7b,0xfc,0x7e,0x04,0x7d,0x00,0x7a,0xfd,0x7e,
-        0xf9,0x00,0xfe,0x02,0x06,0x89,0x02,0x00,0x06,0xf5,
-        0x03,0x95,0x00,0x6b,0x0c,0x15,0x00,0x6b,0x02,0x80,
-        0x03,0x95,0x00,0x6b,0x0c,0x15,0x00,0x6b,0xf8,0x96,
-        0x03,0x00,0x07,0xea,0x03,0x80,0x00,0x15,0x0c,0x80,
-        0xf7,0x76,0xfd,0x00,0x03,0x80,0x0a,0x75,0x03,0x80,
-        0x03,0x80,0x07,0x13,0x02,0x02,0x03,0x00,0x00,0x6b,
-        0x02,0x80,0x03,0x80,0x00,0x15,0x09,0x6b,0x09,0x15,
-        0x00,0x6b,0x03,0x80,0x03,0x80,0x00,0x15,0x00,0xf6,
-        0x0d,0x00,0x00,0x8a,0x00,0x6b,0x03,0x80,0x07,0x80,
-        0xfd,0x00,0xff,0x03,0x00,0x04,0x00,0x07,0x00,0x04,
-        0x01,0x02,0x03,0x01,0x06,0x00,0x03,0x7f,0x01,0x7e,
-        0x01,0x7c,0x00,0x79,0xff,0x7c,0xff,0x7d,0xfd,0x00,
-        0xfa,0x00,0x0e,0x80,0x03,0x80,0x00,0x15,0x0c,0x00,
-        0x00,0x6b,0x02,0x80,0x03,0x80,0x00,0x15,0x0a,0x00,
-        0x02,0x7f,0x01,0x7d,0x00,0x7b,0xff,0x7e,0xfe,0x7f,
-        0xf6,0x00,0x10,0xf7,0x11,0x8f,0xff,0x03,0xff,0x02,
-        0xfe,0x01,0xfa,0x00,0xfd,0x7f,0xff,0x7e,0x00,0x7c,
-        0x00,0x79,0x00,0x7b,0x01,0x7e,0x03,0x00,0x06,0x00,
-        0x02,0x00,0x01,0x03,0x01,0x02,0x03,0xfb,0x03,0x95,
-        0x0c,0x00,0xfa,0x80,0x00,0x6b,0x09,0x80,0x03,0x95,
-        0x00,0x77,0x06,0x7a,0x06,0x06,0x00,0x09,0xfa,0xf1,
-        0xfa,0x7a,0x0e,0x80,0x03,0x87,0x00,0x0b,0x02,0x02,
-        0x03,0x00,0x02,0x7e,0x01,0x02,0x04,0x00,0x02,0x7e,
-        0x00,0x75,0xfe,0x7e,0xfc,0x00,0xff,0x01,0xfe,0x7f,
-        0xfd,0x00,0xfe,0x02,0x07,0x8e,0x00,0x6b,0x09,0x80,
-        0x03,0x80,0x0e,0x15,0xf2,0x80,0x0e,0x6b,0x03,0x80,
-        0x03,0x95,0x00,0x6b,0x0e,0x00,0x00,0x7d,0xfe,0x98,
-        0x00,0x6b,0x05,0x80,0x03,0x95,0x00,0x75,0x02,0x7d,
-        0x0a,0x00,0x00,0x8e,0x00,0x6b,0x02,0x80,0x03,0x95,
-        0x00,0x6b,0x10,0x00,0x00,0x15,0xf8,0x80,0x00,0x6b,
-        0x0a,0x80,0x03,0x95,0x00,0x6b,0x10,0x00,0x00,0x15,
-        0xf8,0x80,0x00,0x6b,0x0a,0x00,0x00,0x7d,0x02,0x83,
-        0x10,0x80,0x03,0x95,0x00,0x6b,0x09,0x00,0x03,0x02,
-        0x00,0x08,0xfd,0x02,0xf7,0x00,0x0e,0x89,0x00,0x6b,
-        0x03,0x80,0x03,0x95,0x00,0x6b,0x09,0x00,0x03,0x02,
-        0x00,0x08,0xfd,0x02,0xf7,0x00,0x0e,0xf4,0x03,0x92,
-        0x02,0x03,0x07,0x00,0x03,0x7d,0x00,0x70,0xfd,0x7e,
-        0xf9,0x00,0xfe,0x02,0x03,0x89,0x09,0x00,0x02,0xf5,
-        0x03,0x80,0x00,0x15,0x00,0xf5,0x07,0x00,0x00,0x08,
-        0x02,0x03,0x06,0x00,0x02,0x7d,0x00,0x70,0xfe,0x7e,
-        0xfa,0x00,0xfe,0x02,0x00,0x08,0x0c,0xf6,0x0f,0x80,
-        0x00,0x15,0xf6,0x00,0xfe,0x7d,0x00,0x79,0x02,0x7e,
-        0x0a,0x00,0xf4,0xf7,0x07,0x09,0x07,0xf7,0x03,0x8c,
-        0x01,0x02,0x01,0x01,0x05,0x00,0x02,0x7f,0x01,0x7e,
-        0x00,0x74,0x00,0x86,0xff,0x01,0xfe,0x01,0xfb,0x00,
-        0xff,0x7f,0xff,0x7f,0x00,0x7c,0x01,0x7e,0x01,0x00,
-        0x05,0x00,0x02,0x00,0x01,0x02,0x03,0xfe,0x04,0x8e,
-        0x02,0x01,0x04,0x00,0x02,0x7f,0x01,0x7e,0x00,0x77,
-        0xff,0x7e,0xfe,0x7f,0xfc,0x00,0xfe,0x01,0xff,0x02,
-        0x00,0x09,0x01,0x02,0x02,0x02,0x03,0x01,0x02,0x01,
-        0x01,0x01,0x01,0x02,0x02,0xeb,0x03,0x80,0x00,0x15,
-        0x03,0x00,0x02,0x7e,0x00,0x7b,0xfe,0x7e,0xfd,0x00,
-        0x03,0x80,0x04,0x00,0x03,0x7e,0x00,0x78,0xfd,0x7e,
-        0xf9,0x00,0x0c,0x80,0x03,0x8c,0x02,0x02,0x02,0x01,
-        0x03,0x00,0x02,0x7f,0x01,0x7d,0xfe,0x7e,0xf9,0x7d,
-        0xff,0x7e,0x00,0x7d,0x03,0x7f,0x02,0x00,0x03,0x01,
-        0x02,0x01,0x02,0xfe,0x0d,0x8c,0xff,0x02,0xfe,0x01,
-        0xfc,0x00,0xfe,0x7f,0xff,0x7e,0x00,0x77,0x01,0x7e,
-        0x02,0x7f,0x04,0x00,0x02,0x01,0x01,0x02,0x00,0x0f,
-        0xff,0x02,0xfe,0x01,0xf9,0x00,0x0c,0xeb,0x03,0x88,
-        0x0a,0x00,0x00,0x02,0x00,0x03,0xfe,0x02,0xfa,0x00,
-        0xff,0x7e,0xff,0x7d,0x00,0x7b,0x01,0x7c,0x01,0x7f,
-        0x06,0x00,0x02,0x02,0x03,0xfe,0x03,0x8f,0x06,0x77,
-        0x06,0x09,0xfa,0x80,0x00,0x71,0xff,0x87,0xfb,0x79,
-        0x07,0x87,0x05,0x79,0x02,0x80,0x03,0x8d,0x02,0x02,
-        0x06,0x00,0x02,0x7e,0x00,0x7d,0xfc,0x7d,0x04,0x7e,
-        0x00,0x7d,0xfe,0x7e,0xfa,0x00,0xfe,0x02,0x04,0x85,
-        0x02,0x00,0x06,0xf9,0x03,0x8f,0x00,0x73,0x01,0x7e,
-        0x07,0x00,0x02,0x02,0x00,0x0d,0x00,0xf3,0x01,0x7e,
-        0x03,0x80,0x03,0x8f,0x00,0x73,0x01,0x7e,0x07,0x00,
-        0x02,0x02,0x00,0x0d,0x00,0xf3,0x01,0x7e,0xf8,0x90,
-        0x03,0x00,0x08,0xf0,0x03,0x80,0x00,0x15,0x00,0xf3,
-        0x02,0x00,0x06,0x07,0xfa,0xf9,0x07,0x78,0x03,0x80,
-        0x03,0x80,0x04,0x0c,0x02,0x03,0x04,0x00,0x00,0x71,
-        0x02,0x80,0x03,0x80,0x00,0x0f,0x06,0x77,0x06,0x09,
-        0x00,0x71,0x02,0x80,0x03,0x80,0x00,0x0f,0x0a,0xf1,
-        0x00,0x0f,0xf6,0xf8,0x0a,0x00,0x02,0xf9,0x05,0x80,
-        0xff,0x01,0xff,0x04,0x00,0x05,0x01,0x03,0x01,0x02,
-        0x06,0x00,0x02,0x7e,0x00,0x7d,0x00,0x7b,0x00,0x7c,
-        0xfe,0x7f,0xfa,0x00,0x0b,0x80,0x03,0x80,0x00,0x0f,
-        0x00,0xfb,0x01,0x03,0x01,0x02,0x05,0x00,0x02,0x7e,
-        0x01,0x7d,0x00,0x76,0x03,0x80,0x10,0x80,0x10,0x80,
-        0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,
-        0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,
-        0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,
-        0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,
-        0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,
-        0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,
-        0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,
-        0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,
-        0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,
-        0x10,0x80,0x0a,0x8f,0x02,0x7f,0x01,0x7e,0x00,0x76,
-        0xff,0x7f,0xfe,0x7f,0xfb,0x00,0xff,0x01,0xff,0x01,
-        0x00,0x0a,0x01,0x02,0x01,0x01,0x05,0x00,0xf9,0x80,
-        0x00,0x6b,0x0c,0x86,0x0d,0x8a,0xff,0x03,0xfe,0x02,
-        0xfb,0x00,0xff,0x7e,0xff,0x7d,0x00,0x7b,0x01,0x7c,
-        0x01,0x7f,0x05,0x00,0x02,0x01,0x01,0x03,0x03,0xfc,
-        0x03,0x80,0x00,0x0f,0x00,0xfb,0x01,0x03,0x01,0x02,
-        0x04,0x00,0x01,0x7e,0x01,0x7d,0x00,0x76,0x00,0x8a,
-        0x01,0x03,0x02,0x02,0x03,0x00,0x02,0x7e,0x01,0x7d,
-        0x00,0x76,0x03,0x80,0x03,0x8f,0x00,0x74,0x01,0x7e,
-        0x02,0x7f,0x04,0x00,0x02,0x01,0x01,0x01,0x00,0x8d,
-        0x00,0x6e,0xff,0x7e,0xfe,0x7f,0xfb,0x00,0xfe,0x01,
-        0x0c,0x85,0x03,0x8d,0x01,0x02,0x03,0x00,0x02,0x7e,
-        0x01,0x02,0x03,0x00,0x02,0x7e,0x00,0x74,0xfe,0x7f,
-        0xfd,0x00,0xff,0x01,0xfe,0x7f,0xfd,0x00,0xff,0x01,
-        0x00,0x0c,0x06,0x82,0x00,0x6b,0x08,0x86,0x03,0x80,
-        0x0a,0x0f,0xf6,0x80,0x0a,0x71,0x03,0x80,0x03,0x8f,
-        0x00,0x73,0x01,0x7e,0x07,0x00,0x02,0x02,0x00,0x0d,
-        0x00,0xf3,0x01,0x7e,0x00,0x7e,0x03,0x82,0x03,0x8f,
-        0x00,0x79,0x02,0x7e,0x08,0x00,0x00,0x89,0x00,0x71,
-        0x02,0x80,0x03,0x8f,0x00,0x73,0x01,0x7e,0x03,0x00,
-        0x02,0x02,0x00,0x0d,0x00,0xf3,0x01,0x7e,0x03,0x00,
-        0x02,0x02,0x00,0x0d,0x00,0xf3,0x01,0x7e,0x03,0x80,
-        0x03,0x8f,0x00,0x73,0x01,0x7e,0x03,0x00,0x02,0x02,
-        0x00,0x0d,0x00,0xf3,0x01,0x7e,0x03,0x00,0x02,0x02,
-        0x00,0x0d,0x00,0xf3,0x01,0x7e,0x00,0x7e,0x03,0x82,
-        0x03,0x8d,0x00,0x02,0x02,0x00,0x00,0x71,0x08,0x00,
-        0x02,0x02,0x00,0x06,0xfe,0x02,0xf8,0x00,0x0c,0xf6,
-        0x03,0x8f,0x00,0x71,0x07,0x00,0x02,0x02,0x00,0x06,
-        0xfe,0x02,0xf9,0x00,0x0c,0x85,0x00,0x71,0x02,0x80,
-        0x03,0x8f,0x00,0x71,0x07,0x00,0x03,0x02,0x00,0x06,
-        0xfd,0x02,0xf9,0x00,0x0c,0xf6,0x03,0x8d,0x02,0x02,
-        0x06,0x00,0x02,0x7e,0x00,0x75,0xfe,0x7e,0xfa,0x00,
-        0xfe,0x02,0x04,0x85,0x06,0x00,0x02,0xf9,0x03,0x80,
-        0x00,0x0f,0x00,0xf8,0x04,0x00,0x00,0x06,0x02,0x02,
-        0x04,0x00,0x02,0x7e,0x00,0x75,0xfe,0x7e,0xfc,0x00,
-        0xfe,0x02,0x00,0x05,0x0a,0xf9,0x0d,0x80,0x00,0x0f,
-        0xf7,0x00,0xff,0x7e,0x00,0x7b,0x01,0x7e,0x09,0x00,
-        0xf6,0xfa,0x04,0x06,0x08,0xfa
-    };
-
-    //-------------------------------------------------------------------------
-    gsv_text::gsv_text() :
-      m_x(0.0),
-      m_y(0.0),
-      m_start_x(0.0),
-      m_width(10.0),
-      m_height(0.0),
-      m_space(0.0),
-      m_line_space(0.0),
-      m_text(m_chr),
-      m_text_buf(),
-      m_cur_chr(m_chr),
-      m_font(gsv_default_font),
-      m_loaded_font(),
-      m_status(initial),
-      m_big_endian(false),
-      m_flip(false)
-    {
-        m_chr[0] = m_chr[1] = 0;
-
-        int t = 1;
-        if(*(char*)&t == 0) m_big_endian = true;
-    }
-
-    //-------------------------------------------------------------------------
-    void gsv_text::font(const void* font)
-    {
-        m_font = font;
-        if(m_font == 0) m_font = &m_loaded_font[0];
-    }
-
-    //-------------------------------------------------------------------------
-    void gsv_text::size(double height, double width)
-    {
-        m_height = height;
-        m_width  = width;
-    }
-
-    //-------------------------------------------------------------------------
-    void gsv_text::space(double space)
-    {
-        m_space = space;
-    }
-
-    //-------------------------------------------------------------------------
-    void gsv_text::line_space(double line_space)
-    {
-        m_line_space = line_space;
-    }
-
-    //-------------------------------------------------------------------------
-    void gsv_text::start_point(double x, double y)
-    {
-        m_x = m_start_x = x;
-        m_y = y;
-        //if(m_flip) m_y += m_height;
-    }
-
-    //-------------------------------------------------------------------------
-    void gsv_text::load_font(const char* file)
-    {
-        m_loaded_font.resize(0);
-        FILE* fd = fopen(file, "rb");
-        if(fd)
-        {
-            unsigned len;
-
-            fseek(fd, 0l, SEEK_END);
-            len = ftell(fd);
-            fseek(fd, 0l, SEEK_SET);
-            if(len > 0)
-            {
-                m_loaded_font.resize(len);
-                fread(&m_loaded_font[0], 1, len, fd);
-                m_font = &m_loaded_font[0];
-            }
-            fclose(fd);
-        }
-    }
-
-    //-------------------------------------------------------------------------
-    void gsv_text::text(const char* text)
-    {
-        if(text == 0)
-        {
-            m_chr[0] = 0;
-            m_text = m_chr;
-            return;
-        }
-        unsigned new_size = strlen(text) + 1;
-        if(new_size > m_text_buf.size())
-        {
-            m_text_buf.resize(new_size);
-        }
-        memcpy(&m_text_buf[0], text, new_size);
-        m_text = &m_text_buf[0];
-    }
-
-    //-------------------------------------------------------------------------
-    void gsv_text::rewind(unsigned)
-    {
-        m_status = initial;
-        if(m_font == 0) return;
-        
-        m_indices = (int8u*)m_font;
-        double base_height = value(m_indices + 4);
-        m_indices += value(m_indices);
-        m_glyphs = (int8*)(m_indices + 257*2);
-        m_h = m_height / base_height;
-        m_w = (m_width == 0.0) ? m_h : m_width / base_height;
-        if(m_flip) m_h = -m_h;
-        m_cur_chr = m_text;
-    }
-
-    //-------------------------------------------------------------------------
-    unsigned gsv_text::vertex(double* x, double* y)
-    {
-        unsigned idx;
-        int8 yc, yf;
-        int dx, dy;
-        bool quit = false;
-        
-        while(!quit)
-        {
-            switch(m_status)
-            {
-            case initial:
-                if(m_font == 0) 
-                {
-                    quit = true;
-                    break;
-                }
-                m_status = next_char;
-
-            case next_char:
-                if(*m_cur_chr == 0) 
-                {
-                    quit = true;
-                    break;
-                }
-                idx = (*m_cur_chr++) & 0xFF;
-                if(idx == '\n')
-                {
-                    m_x = m_start_x;
-                    m_y -= m_flip ? -m_height - m_line_space : m_height + m_line_space;
-                    break;
-                }
-                idx <<= 1;
-                m_bglyph = m_glyphs + value(m_indices + idx);
-                m_eglyph = m_glyphs + value(m_indices + idx + 2);
-                m_status = start_glyph;
-
-            case start_glyph:
-                *x = m_x;
-                *y = m_y;
-                m_status = glyph;
-                return path_cmd_move_to;
-
-            case glyph:
-                if(m_bglyph >= m_eglyph)
-                {
-                    m_status = next_char;
-                    m_x += m_space;
-                    break;
-                }
-                dx = int(*m_bglyph++);
-                yf = (yc = *m_bglyph++) & 0x80;
-                yc <<= 1; 
-                yc >>= 1;
-                dy = int(yc);
-                m_x += double(dx) * m_w;
-                m_y += double(dy) * m_h;
-                *x = m_x;
-                *y = m_y;
-                return yf ? path_cmd_move_to : path_cmd_line_to;
-            }
-
-        }
-        return path_cmd_stop;
-    }
-
-    //-------------------------------------------------------------------------
-    double gsv_text::text_width()
-    {
-        double x1, y1, x2, y2;
-        bounding_rect_single(*this, 0, &x1, &y1, &x2, &y2);
-        return x2 - x1;
-    }
-
-
-}

Sources/libagg/agg-2.4/agg_gsv_text.h

@@ -1,153 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// Class gsv_text
-//
-//----------------------------------------------------------------------------
-
-#ifndef AGG_GSV_TEXT_INCLUDED
-#define AGG_GSV_TEXT_INCLUDED
-
-#include "agg_array.h"
-#include "agg_conv_stroke.h"
-#include "agg_conv_transform.h"
-
-namespace agg
-{
-
-
-    //---------------------------------------------------------------gsv_text
-    //
-    // See Implementation agg_gsv_text.cpp 
-    //
-    class gsv_text
-    {
-        enum status
-        {
-            initial,
-            next_char,
-            start_glyph,
-            glyph
-        };
-
-    public:
-        gsv_text();
-
-        void font(const void* font);
-        void flip(bool flip_y) { m_flip = flip_y; }
-        void load_font(const char* file);
-        void size(double height, double width=0.0);
-        void space(double space);
-        void line_space(double line_space);
-        void start_point(double x, double y);
-        void text(const char* text);
-        
-        double text_width();
-
-        void rewind(unsigned path_id);
-        unsigned vertex(double* x, double* y);
-
-    private:
-        // not supposed to be copied
-        gsv_text(const gsv_text&);
-        const gsv_text& operator = (const gsv_text&);
-
-        int16u value(const int8u* p) const
-        {
-            int16u v;
-            if(m_big_endian)
-            {
-                 *(int8u*)&v      = p[1];
-                *((int8u*)&v + 1) = p[0];
-            }
-            else
-            {
-                 *(int8u*)&v      = p[0];
-                *((int8u*)&v + 1) = p[1];
-            }
-            return v;
-        }
-
-    private:
-        double          m_x;
-        double          m_y;
-        double          m_start_x;
-        double          m_width;
-        double          m_height;
-        double          m_space;
-        double          m_line_space;
-        char            m_chr[2];
-        char*           m_text;
-        pod_array<char> m_text_buf;
-        char*           m_cur_chr;
-        const void*     m_font;
-        pod_array<char> m_loaded_font;
-        status          m_status;
-        bool            m_big_endian;
-        bool            m_flip;
-        int8u*          m_indices;
-        int8*           m_glyphs;
-        int8*           m_bglyph;
-        int8*           m_eglyph;
-        double          m_w;
-        double          m_h;
-    };
-
-
-
-
-    //--------------------------------------------------------gsv_text_outline
-    template<class Transformer = trans_affine> class gsv_text_outline
-    {
-    public:
-        gsv_text_outline(gsv_text& text, const Transformer& trans) :
-          m_polyline(text),
-          m_trans(m_polyline, trans)
-        {
-        }
-
-        void width(double w) 
-        { 
-            m_polyline.width(w); 
-        }
-
-        void transformer(const Transformer* trans) 
-        {
-            m_trans->transformer(trans);
-        }
-
-        void rewind(unsigned path_id) 
-        { 
-            m_trans.rewind(path_id); 
-            m_polyline.line_join(round_join);
-            m_polyline.line_cap(round_cap);
-        }
-
-        unsigned vertex(double* x, double* y)
-        {
-            return m_trans.vertex(x, y);
-        }
-
-    private:
-        conv_stroke<gsv_text> m_polyline;
-        conv_transform<conv_stroke<gsv_text>, Transformer> m_trans;
-    };
-
-
-
-}
-
-
-#endif

Sources/libagg/agg-2.4/agg_image_accessors.h

@@ -1,481 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-
-#ifndef AGG_IMAGE_ACCESSORS_INCLUDED
-#define AGG_IMAGE_ACCESSORS_INCLUDED
-
-#include "agg_basics.h"
-
-namespace agg
-{
-
-    //-----------------------------------------------------image_accessor_clip
-    template<class PixFmt> class image_accessor_clip
-    {
-    public:
-        typedef PixFmt   pixfmt_type;
-        typedef typename pixfmt_type::color_type color_type;
-        typedef typename pixfmt_type::order_type order_type;
-        typedef typename pixfmt_type::value_type value_type;
-        enum pix_width_e { pix_width = pixfmt_type::pix_width };
-
-        image_accessor_clip() {}
-        explicit image_accessor_clip(const pixfmt_type& pixf, 
-                                     const color_type& bk) : 
-            m_pixf(&pixf)
-        {
-            pixfmt_type::make_pix(m_bk_buf, bk);
-        }
-
-        void attach(const pixfmt_type& pixf)
-        {
-            m_pixf = &pixf;
-        }
-
-        void background_color(const color_type& bk)
-        {
-            pixfmt_type::make_pix(m_bk_buf, bk);
-        }
-
-    private:
-        AGG_INLINE const int8u* pixel() const
-        {
-            if(m_y >= 0 && m_y < (int)m_pixf->height() &&
-               m_x >= 0 && m_x < (int)m_pixf->width())
-            {
-                return m_pixf->pix_ptr(m_x, m_y);
-            }
-            return m_bk_buf;
-        }
-
-    public:
-        AGG_INLINE const int8u* span(int x, int y, unsigned len)
-        {
-            m_x = m_x0 = x;
-            m_y = y;
-            if(y >= 0 && y < (int)m_pixf->height() &&
-               x >= 0 && x+(int)len <= (int)m_pixf->width())
-            {
-                return m_pix_ptr = m_pixf->pix_ptr(x, y);
-            }
-            m_pix_ptr = 0;
-            return pixel();
-        }
-
-        AGG_INLINE const int8u* next_x()
-        {
-            if(m_pix_ptr) return m_pix_ptr += pix_width;
-            ++m_x;
-            return pixel();
-        }
-
-        AGG_INLINE const int8u* next_y()
-        {
-            ++m_y;
-            m_x = m_x0;
-            if(m_pix_ptr && 
-               m_y >= 0 && m_y < (int)m_pixf->height())
-            {
-                return m_pix_ptr = m_pixf->pix_ptr(m_x, m_y);
-            }
-            m_pix_ptr = 0;
-            return pixel();
-        }
-
-    private:
-        const pixfmt_type* m_pixf;
-        int8u              m_bk_buf[4];
-        int                m_x, m_x0, m_y;
-        const int8u*       m_pix_ptr;
-    };
-
-
-
-
-    //--------------------------------------------------image_accessor_no_clip
-    template<class PixFmt> class image_accessor_no_clip
-    {
-    public:
-        typedef PixFmt   pixfmt_type;
-        typedef typename pixfmt_type::color_type color_type;
-        typedef typename pixfmt_type::order_type order_type;
-        typedef typename pixfmt_type::value_type value_type;
-        enum pix_width_e { pix_width = pixfmt_type::pix_width };
-
-        image_accessor_no_clip() {}
-        explicit image_accessor_no_clip(const pixfmt_type& pixf) : 
-            m_pixf(&pixf) 
-        {}
-
-        void attach(const pixfmt_type& pixf)
-        {
-            m_pixf = &pixf;
-        }
-
-        AGG_INLINE const int8u* span(int x, int y, unsigned)
-        {
-            m_x = x;
-            m_y = y;
-            return m_pix_ptr = m_pixf->pix_ptr(x, y);
-        }
-
-        AGG_INLINE const int8u* next_x()
-        {
-            return m_pix_ptr += pix_width;
-        }
-
-        AGG_INLINE const int8u* next_y()
-        {
-            ++m_y;
-            return m_pix_ptr = m_pixf->pix_ptr(m_x, m_y);
-        }
-
-    private:
-        const pixfmt_type* m_pixf;
-        int                m_x, m_y;
-        const int8u*       m_pix_ptr;
-    };
-
-
-
-
-    //----------------------------------------------------image_accessor_clone
-    template<class PixFmt> class image_accessor_clone
-    {
-    public:
-        typedef PixFmt   pixfmt_type;
-        typedef typename pixfmt_type::color_type color_type;
-        typedef typename pixfmt_type::order_type order_type;
-        typedef typename pixfmt_type::value_type value_type;
-        enum pix_width_e { pix_width = pixfmt_type::pix_width };
-
-        image_accessor_clone() {}
-        explicit image_accessor_clone(const pixfmt_type& pixf) : 
-            m_pixf(&pixf) 
-        {}
-
-        void attach(const pixfmt_type& pixf)
-        {
-            m_pixf = &pixf;
-        }
-
-    private:
-        AGG_INLINE const int8u* pixel() const
-        {
-            register int x = m_x;
-            register int y = m_y;
-            if(x < 0) x = 0;
-            if(y < 0) y = 0;
-            if(x >= (int)m_pixf->width())  x = m_pixf->width() - 1;
-            if(y >= (int)m_pixf->height()) y = m_pixf->height() - 1;
-            return m_pixf->pix_ptr(x, y);
-        }
-
-    public:
-        AGG_INLINE const int8u* span(int x, int y, unsigned len)
-        {
-            m_x = m_x0 = x;
-            m_y = y;
-            if(y >= 0 && y < (int)m_pixf->height() &&
-               x >= 0 && x+len <= (int)m_pixf->width())
-            {
-                return m_pix_ptr = m_pixf->pix_ptr(x, y);
-            }
-            m_pix_ptr = 0;
-            return pixel();
-        }
-
-        AGG_INLINE const int8u* next_x()
-        {
-            if(m_pix_ptr) return m_pix_ptr += pix_width;
-            ++m_x;
-            return pixel();
-        }
-
-        AGG_INLINE const int8u* next_y()
-        {
-            ++m_y;
-            m_x = m_x0;
-            if(m_pix_ptr && 
-               m_y >= 0 && m_y < (int)m_pixf->height())
-            {
-                return m_pix_ptr = m_pixf->pix_ptr(m_x, m_y);
-            }
-            m_pix_ptr = 0;
-            return pixel();
-        }
-
-    private:
-        const pixfmt_type* m_pixf;
-        int                m_x, m_x0, m_y;
-        const int8u*       m_pix_ptr;
-    };
-
-
-
-
-
-    //-----------------------------------------------------image_accessor_wrap
-    template<class PixFmt, class WrapX, class WrapY> class image_accessor_wrap
-    {
-    public:
-        typedef PixFmt   pixfmt_type;
-        typedef typename pixfmt_type::color_type color_type;
-        typedef typename pixfmt_type::order_type order_type;
-        typedef typename pixfmt_type::value_type value_type;
-        enum pix_width_e { pix_width = pixfmt_type::pix_width };
-
-        image_accessor_wrap() {}
-        explicit image_accessor_wrap(const pixfmt_type& pixf) : 
-            m_pixf(&pixf), 
-            m_wrap_x(pixf.width()), 
-            m_wrap_y(pixf.height())
-        {}
-
-        void attach(const pixfmt_type& pixf)
-        {
-            m_pixf = &pixf;
-        }
-
-        AGG_INLINE const int8u* span(int x, int y, unsigned)
-        {
-            m_x = x;
-            m_row_ptr = m_pixf->row_ptr(m_wrap_y(y));
-            return m_row_ptr + m_wrap_x(x) * pix_width;
-        }
-
-        AGG_INLINE const int8u* next_x()
-        {
-            int x = ++m_wrap_x;
-            return m_row_ptr + x * pix_width;
-        }
-
-        AGG_INLINE const int8u* next_y()
-        {
-            m_row_ptr = m_pixf->row_ptr(++m_wrap_y);
-            return m_row_ptr + m_wrap_x(m_x) * pix_width;
-        }
-
-    private:
-        const pixfmt_type* m_pixf;
-        const int8u*       m_row_ptr;
-        int                m_x;
-        WrapX              m_wrap_x;
-        WrapY              m_wrap_y;
-    };
-
-
-
-
-    //--------------------------------------------------------wrap_mode_repeat
-    class wrap_mode_repeat
-    {
-    public:
-        wrap_mode_repeat() {}
-        wrap_mode_repeat(unsigned size) : 
-            m_size(size), 
-            m_add(size * (0x3FFFFFFF / size)),
-            m_value(0)
-        {}
-
-        AGG_INLINE unsigned operator() (int v)
-        { 
-            return m_value = (unsigned(v) + m_add) % m_size; 
-        }
-
-        AGG_INLINE unsigned operator++ ()
-        {
-            ++m_value;
-            if(m_value >= m_size) m_value = 0;
-            return m_value;
-        }
-    private:
-        unsigned m_size;
-        unsigned m_add;
-        unsigned m_value;
-    };
-
-
-    //---------------------------------------------------wrap_mode_repeat_pow2
-    class wrap_mode_repeat_pow2
-    {
-    public:
-        wrap_mode_repeat_pow2() {}
-        wrap_mode_repeat_pow2(unsigned size) : m_value(0)
-        {
-            m_mask = 1;
-            while(m_mask < size) m_mask = (m_mask << 1) | 1;
-            m_mask >>= 1;
-        }
-        AGG_INLINE unsigned operator() (int v)
-        { 
-            return m_value = unsigned(v) & m_mask;
-        }
-        AGG_INLINE unsigned operator++ ()
-        {
-            ++m_value;
-            if(m_value > m_mask) m_value = 0;
-            return m_value;
-        }
-    private:
-        unsigned m_mask;
-        unsigned m_value;
-    };
-
-
-    //----------------------------------------------wrap_mode_repeat_auto_pow2
-    class wrap_mode_repeat_auto_pow2
-    {
-    public:
-        wrap_mode_repeat_auto_pow2() {}
-        wrap_mode_repeat_auto_pow2(unsigned size) :
-            m_size(size),
-            m_add(size * (0x3FFFFFFF / size)),
-            m_mask((m_size & (m_size-1)) ? 0 : m_size-1),
-            m_value(0)
-        {}
-
-        AGG_INLINE unsigned operator() (int v) 
-        { 
-            if(m_mask) return m_value = unsigned(v) & m_mask;
-            return m_value = (unsigned(v) + m_add) % m_size;
-        }
-        AGG_INLINE unsigned operator++ ()
-        {
-            ++m_value;
-            if(m_value >= m_size) m_value = 0;
-            return m_value;
-        }
-
-    private:
-        unsigned m_size;
-        unsigned m_add;
-        unsigned m_mask;
-        unsigned m_value;
-    };
-
-
-    //-------------------------------------------------------wrap_mode_reflect
-    class wrap_mode_reflect
-    {
-    public:
-        wrap_mode_reflect() {}
-        wrap_mode_reflect(unsigned size) : 
-            m_size(size), 
-            m_size2(size * 2),
-            m_add(m_size2 * (0x3FFFFFFF / m_size2)),
-            m_value(0)
-        {}
-
-        AGG_INLINE unsigned operator() (int v)
-        { 
-            m_value = (unsigned(v) + m_add) % m_size2;
-            if(m_value >= m_size) return m_size2 - m_value - 1;
-            return m_value;
-        }
-
-        AGG_INLINE unsigned operator++ ()
-        {
-            ++m_value;
-            if(m_value >= m_size2) m_value = 0;
-            if(m_value >= m_size) return m_size2 - m_value - 1;
-            return m_value;
-        }
-    private:
-        unsigned m_size;
-        unsigned m_size2;
-        unsigned m_add;
-        unsigned m_value;
-    };
-
-
-
-    //--------------------------------------------------wrap_mode_reflect_pow2
-    class wrap_mode_reflect_pow2
-    {
-    public:
-        wrap_mode_reflect_pow2() {}
-        wrap_mode_reflect_pow2(unsigned size) : m_value(0)
-        {
-            m_mask = 1;
-            m_size = 1;
-            while(m_mask < size) 
-            {
-                m_mask = (m_mask << 1) | 1;
-                m_size <<= 1;
-            }
-        }
-        AGG_INLINE unsigned operator() (int v)
-        { 
-            m_value = unsigned(v) & m_mask;
-            if(m_value >= m_size) return m_mask - m_value;
-            return m_value;
-        }
-        AGG_INLINE unsigned operator++ ()
-        {
-            ++m_value;
-            m_value &= m_mask;
-            if(m_value >= m_size) return m_mask - m_value;
-            return m_value;
-        }
-    private:
-        unsigned m_size;
-        unsigned m_mask;
-        unsigned m_value;
-    };
-
-
-
-    //---------------------------------------------wrap_mode_reflect_auto_pow2
-    class wrap_mode_reflect_auto_pow2
-    {
-    public:
-        wrap_mode_reflect_auto_pow2() {}
-        wrap_mode_reflect_auto_pow2(unsigned size) :
-            m_size(size),
-            m_size2(size * 2),
-            m_add(m_size2 * (0x3FFFFFFF / m_size2)),
-            m_mask((m_size2 & (m_size2-1)) ? 0 : m_size2-1),
-            m_value(0)
-        {}
-
-        AGG_INLINE unsigned operator() (int v) 
-        { 
-            m_value = m_mask ? unsigned(v) & m_mask : 
-                              (unsigned(v) + m_add) % m_size2;
-            if(m_value >= m_size) return m_size2 - m_value - 1;
-            return m_value;            
-        }
-        AGG_INLINE unsigned operator++ ()
-        {
-            ++m_value;
-            if(m_value >= m_size2) m_value = 0;
-            if(m_value >= m_size) return m_size2 - m_value - 1;
-            return m_value;
-        }
-
-    private:
-        unsigned m_size;
-        unsigned m_size2;
-        unsigned m_add;
-        unsigned m_mask;
-        unsigned m_value;
-    };
-
-
-}
-
-
-#endif

Sources/libagg/agg-2.4/agg_image_filters.cpp

@@ -1,103 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// Filtering class image_filter_lut implemantation
-//
-//----------------------------------------------------------------------------
-
-
-#include "agg_image_filters.h"
-
-
-namespace agg
-{
-    //--------------------------------------------------------------------
-    void image_filter_lut::realloc_lut(double radius)
-    {
-        m_radius = radius;
-        m_diameter = uceil(radius) * 2;
-        m_start = -int(m_diameter / 2 - 1);
-        unsigned size = m_diameter << image_subpixel_shift;
-        if(size > m_weight_array.size())
-        {
-            m_weight_array.resize(size);
-        }
-    }
-
-
-
-    //--------------------------------------------------------------------
-    // This function normalizes integer values and corrects the rounding 
-    // errors. It doesn't do anything with the source floating point values
-    // (m_weight_array_dbl), it corrects only integers according to the rule 
-    // of 1.0 which means that any sum of pixel weights must be equal to 1.0.
-    // So, the filter function must produce a graph of the proper shape.
-    //--------------------------------------------------------------------
-    void image_filter_lut::normalize()
-    {
-        unsigned i;
-        int flip = 1;
-
-        for(i = 0; i < image_subpixel_scale; i++)
-        {
-            for(;;)
-            {
-                int sum = 0;
-                unsigned j;
-                for(j = 0; j < m_diameter; j++)
-                {
-                    sum += m_weight_array[j * image_subpixel_scale + i];
-                }
-
-                if(sum == image_filter_scale) break;
-
-                double k = double(image_filter_scale) / double(sum);
-                sum = 0;
-                for(j = 0; j < m_diameter; j++)
-                {
-                    sum +=     m_weight_array[j * image_subpixel_scale + i] = 
-                        iround(m_weight_array[j * image_subpixel_scale + i] * k);
-                }
-
-                sum -= image_filter_scale;
-                int inc = (sum > 0) ? -1 : 1;
-
-                for(j = 0; j < m_diameter && sum; j++)
-                {
-                    flip ^= 1;
-                    unsigned idx = flip ? m_diameter/2 + j/2 : m_diameter/2 - j/2;
-                    int v = m_weight_array[idx * image_subpixel_scale + i];
-                    if(v < image_filter_scale)
-                    {
-                        m_weight_array[idx * image_subpixel_scale + i] += inc;
-                        sum += inc;
-                    }
-                }
-            }
-        }
-
-        unsigned pivot = m_diameter << (image_subpixel_shift - 1);
-
-        for(i = 0; i < pivot; i++)
-        {
-            m_weight_array[pivot + i] = m_weight_array[pivot - i];
-        }
-        unsigned end = (diameter() << image_subpixel_shift) - 1;
-        m_weight_array[0] = m_weight_array[end];
-    }
-
-
-}
-

Sources/libagg/agg-2.4/agg_image_filters.h

@@ -1,448 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// Image transformation filters,
-// Filtering classes (image_filter_lut, image_filter),
-// Basic filter shape classes
-//----------------------------------------------------------------------------
-#ifndef AGG_IMAGE_FILTERS_INCLUDED
-#define AGG_IMAGE_FILTERS_INCLUDED
-
-#include "agg_array.h"
-#include "agg_math.h"
-
-namespace agg
-{
-
-    // See Implementation agg_image_filters.cpp 
-
-    enum image_filter_scale_e
-    {
-        image_filter_shift = 14,                      //----image_filter_shift
-        image_filter_scale = 1 << image_filter_shift, //----image_filter_scale 
-        image_filter_mask  = image_filter_scale - 1   //----image_filter_mask 
-    };
-
-    enum image_subpixel_scale_e
-    {
-        image_subpixel_shift = 8,                         //----image_subpixel_shift
-        image_subpixel_scale = 1 << image_subpixel_shift, //----image_subpixel_scale 
-        image_subpixel_mask  = image_subpixel_scale - 1   //----image_subpixel_mask 
-    };
-
-
-    //-----------------------------------------------------image_filter_lut
-    class image_filter_lut
-    {
-    public:
-        template<class FilterF> void calculate(const FilterF& filter,
-                                               bool normalization=true)
-        {
-            double r = filter.radius();
-            realloc_lut(r);
-            unsigned i;
-            unsigned pivot = diameter() << (image_subpixel_shift - 1);
-            for(i = 0; i < pivot; i++)
-            {
-                double x = double(i) / double(image_subpixel_scale);
-                double y = filter.calc_weight(x);
-                m_weight_array[pivot + i] = 
-                m_weight_array[pivot - i] = (int16)iround(y * image_filter_scale);
-            }
-            unsigned end = (diameter() << image_subpixel_shift) - 1;
-            m_weight_array[0] = m_weight_array[end];
-            if(normalization) 
-            {
-                normalize();
-            }
-        }
-
-        image_filter_lut() : m_radius(0), m_diameter(0), m_start(0) {}
-
-        template<class FilterF> image_filter_lut(const FilterF& filter, 
-                                                 bool normalization=true)
-        {
-            calculate(filter, normalization);
-        }
-
-        double       radius()       const { return m_radius;   }
-        unsigned     diameter()     const { return m_diameter; }
-        int          start()        const { return m_start;    }
-        const int16* weight_array() const { return &m_weight_array[0]; }
-        void         normalize();
-
-    private:
-        void realloc_lut(double radius);
-        image_filter_lut(const image_filter_lut&);
-        const image_filter_lut& operator = (const image_filter_lut&);
-
-        double           m_radius;
-        unsigned         m_diameter;
-        int              m_start;
-        pod_array<int16> m_weight_array;
-    };
-
-
-
-    //--------------------------------------------------------image_filter
-    template<class FilterF> class image_filter : public image_filter_lut
-    {
-    public:
-        image_filter()
-        {
-            calculate(m_filter_function);
-        }
-    private:
-        FilterF m_filter_function;
-    };
-
-
-    //-----------------------------------------------image_filter_bilinear
-    struct image_filter_bilinear
-    {
-        static double radius() { return 1.0; }
-        static double calc_weight(double x)
-        {
-            return 1.0 - x;
-        }
-    };
-
-
-    //-----------------------------------------------image_filter_hanning
-    struct image_filter_hanning
-    {
-        static double radius() { return 1.0; }
-        static double calc_weight(double x)
-        {
-            return 0.5 + 0.5 * cos(pi * x);
-        }
-    };
-
-
-    //-----------------------------------------------image_filter_hamming
-    struct image_filter_hamming
-    {
-        static double radius() { return 1.0; }
-        static double calc_weight(double x)
-        {
-            return 0.54 + 0.46 * cos(pi * x);
-        }
-    };
-
-    //-----------------------------------------------image_filter_hermite
-    struct image_filter_hermite
-    {
-        static double radius() { return 1.0; }
-        static double calc_weight(double x)
-        {
-            return (2.0 * x - 3.0) * x * x + 1.0;
-        }
-    };
-   
-    //------------------------------------------------image_filter_quadric
-    struct image_filter_quadric
-    {
-        static double radius() { return 1.5; }
-        static double calc_weight(double x)
-        {
-            double t;
-            if(x <  0.5) return 0.75 - x * x;
-            if(x <  1.5) {t = x - 1.5; return 0.5 * t * t;}
-            return 0.0;
-        }
-    };
-
-    //------------------------------------------------image_filter_bicubic
-    class image_filter_bicubic
-    {
-        static double pow3(double x)
-        {
-            return (x <= 0.0) ? 0.0 : x * x * x;
-        }
-
-    public:
-        static double radius() { return 2.0; }
-        static double calc_weight(double x)
-        {
-            return
-                (1.0/6.0) * 
-                (pow3(x + 2) - 4 * pow3(x + 1) + 6 * pow3(x) - 4 * pow3(x - 1));
-        }
-    };
-
-    //-------------------------------------------------image_filter_kaiser
-    class image_filter_kaiser
-    {
-        double a;
-        double i0a;
-        double epsilon;
-
-    public:
-        image_filter_kaiser(double b = 6.33) :
-            a(b), epsilon(1e-12)
-        {
-            i0a = 1.0 / bessel_i0(b);
-        }
-
-        static double radius() { return 1.0; }
-        double calc_weight(double x) const
-        {
-            return bessel_i0(a * sqrt(1. - x * x)) * i0a;
-        }
-
-    private:
-        double bessel_i0(double x) const
-        {
-            int i;
-            double sum, y, t;
-
-            sum = 1.;
-            y = x * x / 4.;
-            t = y;
-        
-            for(i = 2; t > epsilon; i++)
-            {
-                sum += t;
-                t *= (double)y / (i * i);
-            }
-            return sum;
-        }
-    };
-
-    //----------------------------------------------image_filter_catrom
-    struct image_filter_catrom
-    {
-        static double radius() { return 2.0; }
-        static double calc_weight(double x)
-        {
-            if(x <  1.0) return 0.5 * (2.0 + x * x * (-5.0 + x * 3.0));
-            if(x <  2.0) return 0.5 * (4.0 + x * (-8.0 + x * (5.0 - x)));
-            return 0.;
-        }
-    };
-
-    //---------------------------------------------image_filter_mitchell
-    class image_filter_mitchell
-    {
-        double p0, p2, p3;
-        double q0, q1, q2, q3;
-
-    public:
-        image_filter_mitchell(double b = 1.0/3.0, double c = 1.0/3.0) :
-            p0((6.0 - 2.0 * b) / 6.0),
-            p2((-18.0 + 12.0 * b + 6.0 * c) / 6.0),
-            p3((12.0 - 9.0 * b - 6.0 * c) / 6.0),
-            q0((8.0 * b + 24.0 * c) / 6.0),
-            q1((-12.0 * b - 48.0 * c) / 6.0),
-            q2((6.0 * b + 30.0 * c) / 6.0),
-            q3((-b - 6.0 * c) / 6.0)
-        {}
-
-        static double radius() { return 2.0; }
-        double calc_weight(double x) const
-        {
-            if(x < 1.0) return p0 + x * x * (p2 + x * p3);
-            if(x < 2.0) return q0 + x * (q1 + x * (q2 + x * q3));
-            return 0.0;
-        }
-    };
-
-
-    //----------------------------------------------image_filter_spline16
-    struct image_filter_spline16
-    {
-        static double radius() { return 2.0; }
-        static double calc_weight(double x)
-        {
-            if(x < 1.0)
-            {
-                return ((x - 9.0/5.0 ) * x - 1.0/5.0 ) * x + 1.0;
-            }
-            return ((-1.0/3.0 * (x-1) + 4.0/5.0) * (x-1) - 7.0/15.0 ) * (x-1);
-        }
-    };
-
-
-    //---------------------------------------------image_filter_spline36
-    struct image_filter_spline36
-    {
-        static double radius() { return 3.0; }
-        static double calc_weight(double x)
-        {
-           if(x < 1.0)
-           {
-              return ((13.0/11.0 * x - 453.0/209.0) * x - 3.0/209.0) * x + 1.0;
-           }
-           if(x < 2.0)
-           {
-              return ((-6.0/11.0 * (x-1) + 270.0/209.0) * (x-1) - 156.0/ 209.0) * (x-1);
-           }
-           return ((1.0/11.0 * (x-2) - 45.0/209.0) * (x-2) +  26.0/209.0) * (x-2);
-        }
-    };
-
-
-    //----------------------------------------------image_filter_gaussian
-    struct image_filter_gaussian
-    {
-        static double radius() { return 2.0; }
-        static double calc_weight(double x) 
-        {
-            return exp(-2.0 * x * x) * sqrt(2.0 / pi);
-        }
-    };
-
-
-    //------------------------------------------------image_filter_bessel
-    struct image_filter_bessel
-    {
-        static double radius() { return 3.2383; } 
-        static double calc_weight(double x)
-        {
-            return (x == 0.0) ? pi / 4.0 : besj(pi * x, 1) / (2.0 * x);
-        }
-    };
-
-
-    //-------------------------------------------------image_filter_sinc
-    class image_filter_sinc
-    {
-    public:
-        image_filter_sinc(double r) : m_radius(r < 2.0 ? 2.0 : r) {}
-        double radius() const { return m_radius; }
-        double calc_weight(double x) const
-        {
-            if(x == 0.0) return 1.0;
-            x *= pi;
-            return sin(x) / x;
-        }
-    private:
-        double m_radius;
-    };
-
-
-    //-----------------------------------------------image_filter_lanczos
-    class image_filter_lanczos
-    {
-    public:
-        image_filter_lanczos(double r) : m_radius(r < 2.0 ? 2.0 : r) {}
-        double radius() const { return m_radius; }
-        double calc_weight(double x) const
-        {
-           if(x == 0.0) return 1.0;
-           if(x > m_radius) return 0.0;
-           x *= pi;
-           double xr = x / m_radius;
-           return (sin(x) / x) * (sin(xr) / xr);
-        }
-    private:
-        double m_radius;
-    };
-
-
-    //----------------------------------------------image_filter_blackman
-    class image_filter_blackman
-    {
-    public:
-        image_filter_blackman(double r) : m_radius(r < 2.0 ? 2.0 : r) {}
-        double radius() const { return m_radius; }
-        double calc_weight(double x) const
-        {
-           if(x == 0.0) return 1.0;
-           if(x > m_radius) return 0.0;
-           x *= pi;
-           double xr = x / m_radius;
-           return (sin(x) / x) * (0.42 + 0.5*cos(xr) + 0.08*cos(2*xr));
-        }
-    private:
-        double m_radius;
-    };
-
-    //------------------------------------------------image_filter_sinc36
-    class image_filter_sinc36 : public image_filter_sinc
-    { public: image_filter_sinc36() : image_filter_sinc(3.0){} };
-
-    //------------------------------------------------image_filter_sinc64
-    class image_filter_sinc64 : public image_filter_sinc
-    { public: image_filter_sinc64() : image_filter_sinc(4.0){} };
-
-    //-----------------------------------------------image_filter_sinc100
-    class image_filter_sinc100 : public image_filter_sinc
-    { public: image_filter_sinc100() : image_filter_sinc(5.0){} };
-
-    //-----------------------------------------------image_filter_sinc144
-    class image_filter_sinc144 : public image_filter_sinc
-    { public: image_filter_sinc144() : image_filter_sinc(6.0){} };
-
-    //-----------------------------------------------image_filter_sinc196
-    class image_filter_sinc196 : public image_filter_sinc
-    { public: image_filter_sinc196() : image_filter_sinc(7.0){} };
-
-    //-----------------------------------------------image_filter_sinc256
-    class image_filter_sinc256 : public image_filter_sinc
-    { public: image_filter_sinc256() : image_filter_sinc(8.0){} };
-
-    //---------------------------------------------image_filter_lanczos36
-    class image_filter_lanczos36 : public image_filter_lanczos
-    { public: image_filter_lanczos36() : image_filter_lanczos(3.0){} };
-
-    //---------------------------------------------image_filter_lanczos64
-    class image_filter_lanczos64 : public image_filter_lanczos
-    { public: image_filter_lanczos64() : image_filter_lanczos(4.0){} };
-
-    //--------------------------------------------image_filter_lanczos100
-    class image_filter_lanczos100 : public image_filter_lanczos
-    { public: image_filter_lanczos100() : image_filter_lanczos(5.0){} };
-
-    //--------------------------------------------image_filter_lanczos144
-    class image_filter_lanczos144 : public image_filter_lanczos
-    { public: image_filter_lanczos144() : image_filter_lanczos(6.0){} };
-
-    //--------------------------------------------image_filter_lanczos196
-    class image_filter_lanczos196 : public image_filter_lanczos
-    { public: image_filter_lanczos196() : image_filter_lanczos(7.0){} };
-
-    //--------------------------------------------image_filter_lanczos256
-    class image_filter_lanczos256 : public image_filter_lanczos
-    { public: image_filter_lanczos256() : image_filter_lanczos(8.0){} };
-
-    //--------------------------------------------image_filter_blackman36
-    class image_filter_blackman36 : public image_filter_blackman
-    { public: image_filter_blackman36() : image_filter_blackman(3.0){} };
-
-    //--------------------------------------------image_filter_blackman64
-    class image_filter_blackman64 : public image_filter_blackman
-    { public: image_filter_blackman64() : image_filter_blackman(4.0){} };
-
-    //-------------------------------------------image_filter_blackman100
-    class image_filter_blackman100 : public image_filter_blackman
-    { public: image_filter_blackman100() : image_filter_blackman(5.0){} };
-
-    //-------------------------------------------image_filter_blackman144
-    class image_filter_blackman144 : public image_filter_blackman
-    { public: image_filter_blackman144() : image_filter_blackman(6.0){} };
-
-    //-------------------------------------------image_filter_blackman196
-    class image_filter_blackman196 : public image_filter_blackman
-    { public: image_filter_blackman196() : image_filter_blackman(7.0){} };
-
-    //-------------------------------------------image_filter_blackman256
-    class image_filter_blackman256 : public image_filter_blackman
-    { public: image_filter_blackman256() : image_filter_blackman(8.0){} };
-
-
-}
-
-#endif

Sources/libagg/agg-2.4/agg_line_aa_basics.cpp

@@ -1,82 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-
-#include <math.h>
-#include "agg_line_aa_basics.h"
-
-namespace agg
-{
-    //-------------------------------------------------------------------------
-    // The number of the octant is determined as a 3-bit value as follows:
-    // bit 0 = vertical flag
-    // bit 1 = sx < 0
-    // bit 2 = sy < 0
-    //
-    // [N] shows the number of the orthogonal quadrant
-    // <M> shows the number of the diagonal quadrant
-    //               <1>
-    //   [1]          |          [0]
-    //       . (3)011 | 001(1) .
-    //         .      |      .
-    //           .    |    . 
-    //             .  |  . 
-    //    (2)010     .|.     000(0)
-    // <2> ----------.+.----------- <0>
-    //    (6)110   .  |  .   100(4)
-    //           .    |    .
-    //         .      |      .
-    //       .        |        .
-    //         (7)111 | 101(5) 
-    //   [2]          |          [3]
-    //               <3> 
-    //                                                        0,1,2,3,4,5,6,7 
-    const int8u line_parameters::s_orthogonal_quadrant[8] = { 0,0,1,1,3,3,2,2 };
-    const int8u line_parameters::s_diagonal_quadrant[8]   = { 0,1,2,1,0,3,2,3 };
-
-
-
-    //-------------------------------------------------------------------------
-    void bisectrix(const line_parameters& l1, 
-                   const line_parameters& l2, 
-                   int* x, int* y)
-    {
-        double k = double(l2.len) / double(l1.len);
-        double tx = l2.x2 - (l2.x1 - l1.x1) * k;
-        double ty = l2.y2 - (l2.y1 - l1.y1) * k;
-
-        //All bisectrices must be on the right of the line
-        //If the next point is on the left (l1 => l2.2)
-        //then the bisectix should be rotated by 180 degrees.
-        if(double(l2.x2 - l2.x1) * double(l2.y1 - l1.y1) <
-           double(l2.y2 - l2.y1) * double(l2.x1 - l1.x1) + 100.0)
-        {
-            tx -= (tx - l2.x1) * 2.0;
-            ty -= (ty - l2.y1) * 2.0;
-        }
-
-        // Check if the bisectrix is too short
-        double dx = tx - l2.x1;
-        double dy = ty - l2.y1;
-        if((int)sqrt(dx * dx + dy * dy) < line_subpixel_scale)
-        {
-            *x = (l2.x1 + l2.x1 + (l2.y1 - l1.y1) + (l2.y2 - l2.y1)) >> 1;
-            *y = (l2.y1 + l2.y1 - (l2.x1 - l1.x1) - (l2.x2 - l2.x1)) >> 1;
-            return;
-        }
-        *x = iround(tx);
-        *y = iround(ty);
-    }
-
-}

Sources/libagg/agg-2.4/agg_line_aa_basics.h

@@ -1,189 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-#ifndef AGG_LINE_AA_BASICS_INCLUDED
-#define AGG_LINE_AA_BASICS_INCLUDED
-
-#include <stdlib.h>
-#include "agg_basics.h"
-
-namespace agg
-{
-
-    // See Implementation agg_line_aa_basics.cpp 
-
-    //-------------------------------------------------------------------------
-    enum line_subpixel_scale_e
-    {
-        line_subpixel_shift = 8,                          //----line_subpixel_shift
-        line_subpixel_scale  = 1 << line_subpixel_shift,  //----line_subpixel_scale
-        line_subpixel_mask  = line_subpixel_scale - 1,    //----line_subpixel_mask
-        line_max_coord      = (1 << 28) - 1,              //----line_max_coord
-        line_max_length = 1 << (line_subpixel_shift + 10) //----line_max_length
-    };
-
-    //-------------------------------------------------------------------------
-    enum line_mr_subpixel_scale_e
-    {
-        line_mr_subpixel_shift = 4,                           //----line_mr_subpixel_shift
-        line_mr_subpixel_scale = 1 << line_mr_subpixel_shift, //----line_mr_subpixel_scale 
-        line_mr_subpixel_mask  = line_mr_subpixel_scale - 1   //----line_mr_subpixel_mask 
-    };
-
-    //------------------------------------------------------------------line_mr
-    AGG_INLINE int line_mr(int x) 
-    { 
-        return x >> (line_subpixel_shift - line_mr_subpixel_shift); 
-    }
-
-    //-------------------------------------------------------------------line_hr
-    AGG_INLINE int line_hr(int x) 
-    { 
-        return x << (line_subpixel_shift - line_mr_subpixel_shift); 
-    }
-
-    //---------------------------------------------------------------line_dbl_hr
-    AGG_INLINE int line_dbl_hr(int x) 
-    { 
-        return x << line_subpixel_shift;
-    }
-
-    //---------------------------------------------------------------line_coord
-    struct line_coord
-    {
-        AGG_INLINE static int conv(double x)
-        {
-            return iround(x * line_subpixel_scale);
-        }
-    };
-
-    //-----------------------------------------------------------line_coord_sat
-    struct line_coord_sat
-    {
-        AGG_INLINE static int conv(double x)
-        {
-            return saturation<line_max_coord>::iround(x * line_subpixel_scale);
-        }
-    };
-
-    //==========================================================line_parameters
-    struct line_parameters
-    {
-        //---------------------------------------------------------------------
-        line_parameters() {}
-        line_parameters(int x1_, int y1_, int x2_, int y2_, int len_) :
-            x1(x1_), y1(y1_), x2(x2_), y2(y2_), 
-            dx(abs(x2_ - x1_)),
-            dy(abs(y2_ - y1_)),
-            sx((x2_ > x1_) ? 1 : -1),
-            sy((y2_ > y1_) ? 1 : -1),
-            vertical(dy >= dx),
-            inc(vertical ? sy : sx),
-            len(len_),
-            octant((sy & 4) | (sx & 2) | int(vertical))
-        {
-        }
-
-        //---------------------------------------------------------------------
-        unsigned orthogonal_quadrant() const { return s_orthogonal_quadrant[octant]; }
-        unsigned diagonal_quadrant()   const { return s_diagonal_quadrant[octant];   }
-
-        //---------------------------------------------------------------------
-        bool same_orthogonal_quadrant(const line_parameters& lp) const
-        {
-            return s_orthogonal_quadrant[octant] == s_orthogonal_quadrant[lp.octant];
-        }
-
-        //---------------------------------------------------------------------
-        bool same_diagonal_quadrant(const line_parameters& lp) const
-        {
-            return s_diagonal_quadrant[octant] == s_diagonal_quadrant[lp.octant];
-        }
-
-        //---------------------------------------------------------------------
-        void divide(line_parameters& lp1, line_parameters& lp2) const
-        {
-            int xmid = (x1 + x2) >> 1;
-            int ymid = (y1 + y2) >> 1;
-            int len2 = len >> 1;
-
-            lp1 = *this;
-            lp2 = *this;
-
-            lp1.x2  = xmid;
-            lp1.y2  = ymid;
-            lp1.len = len2;
-            lp1.dx  = abs(lp1.x2 - lp1.x1);
-            lp1.dy  = abs(lp1.y2 - lp1.y1);
-
-            lp2.x1  = xmid;
-            lp2.y1  = ymid;
-            lp2.len = len2;
-            lp2.dx  = abs(lp2.x2 - lp2.x1);
-            lp2.dy  = abs(lp2.y2 - lp2.y1);
-        }
-        
-        //---------------------------------------------------------------------
-        int x1, y1, x2, y2, dx, dy, sx, sy;
-        bool vertical;
-        int inc;
-        int len;
-        int octant;
-
-        //---------------------------------------------------------------------
-        static const int8u s_orthogonal_quadrant[8];
-        static const int8u s_diagonal_quadrant[8];
-    };
-
-
-
-    // See Implementation agg_line_aa_basics.cpp 
-
-    //----------------------------------------------------------------bisectrix
-    void bisectrix(const line_parameters& l1, 
-                   const line_parameters& l2, 
-                   int* x, int* y);
-
-
-    //-------------------------------------------fix_degenerate_bisectrix_start
-    void inline fix_degenerate_bisectrix_start(const line_parameters& lp, 
-                                               int* x, int* y)
-    {
-        int d = iround((double(*x - lp.x2) * double(lp.y2 - lp.y1) - 
-                        double(*y - lp.y2) * double(lp.x2 - lp.x1)) / lp.len);
-        if(d < line_subpixel_scale/2)
-        {
-            *x = lp.x1 + (lp.y2 - lp.y1);
-            *y = lp.y1 - (lp.x2 - lp.x1);
-        }
-    }
-
-
-    //---------------------------------------------fix_degenerate_bisectrix_end
-    void inline fix_degenerate_bisectrix_end(const line_parameters& lp, 
-                                             int* x, int* y)
-    {
-        int d = iround((double(*x - lp.x2) * double(lp.y2 - lp.y1) - 
-                        double(*y - lp.y2) * double(lp.x2 - lp.x1)) / lp.len);
-        if(d < line_subpixel_scale/2)
-        {
-            *x = lp.x2 + (lp.y2 - lp.y1);
-            *y = lp.y2 - (lp.x2 - lp.x1);
-        }
-    }
-
-
-}
-
-#endif

Sources/libagg/agg-2.4/agg_line_profile_aa.cpp

@@ -1,116 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-
-#include "agg_renderer_outline_aa.h"
-
-namespace agg
-{
-
-    //---------------------------------------------------------------------
-    void line_profile_aa::width(double w)
-    {
-        if(w < 0.0) w = 0.0;
-
-        if(w < m_smoother_width) w += w;
-        else                     w += m_smoother_width;
-
-        w *= 0.5;
-
-        w -= m_smoother_width;
-        double s = m_smoother_width;
-        if(w < 0.0) 
-        {
-            s += w;
-            w = 0.0;
-        }
-        set(w, s);
-    }
-
-
-    //---------------------------------------------------------------------
-    line_profile_aa::value_type* line_profile_aa::profile(double w)
-    {
-        m_subpixel_width = uround(w * subpixel_scale);
-        unsigned size = m_subpixel_width + subpixel_scale * 6;
-        if(size > m_profile.size())
-        {
-            m_profile.resize(size);
-        }
-        return &m_profile[0];
-    }
-
-
-    //---------------------------------------------------------------------
-    void line_profile_aa::set(double center_width, double smoother_width)
-    {
-        double base_val = 1.0;
-        if(center_width == 0.0)   center_width = 1.0 / subpixel_scale;
-        if(smoother_width == 0.0) smoother_width = 1.0 / subpixel_scale;
-
-        double width = center_width + smoother_width;
-        if(width < m_min_width)
-        {
-            double k = width / m_min_width;
-            base_val *= k;
-            center_width /= k;
-            smoother_width /= k;
-        }
-
-        value_type* ch = profile(center_width + smoother_width);
-
-        unsigned subpixel_center_width = unsigned(center_width * subpixel_scale);
-        unsigned subpixel_smoother_width = unsigned(smoother_width * subpixel_scale);
-
-        value_type* ch_center   = ch + subpixel_scale*2;
-        value_type* ch_smoother = ch_center + subpixel_center_width;
-
-        unsigned i;
-
-        unsigned val = m_gamma[unsigned(base_val * aa_mask)];
-        ch = ch_center;
-        for(i = 0; i < subpixel_center_width; i++)
-        {
-            *ch++ = (value_type)val;
-        }
-
-        for(i = 0; i < subpixel_smoother_width; i++)
-        {
-            *ch_smoother++ = 
-                m_gamma[unsigned((base_val - 
-                                  base_val * 
-                                  (double(i) / subpixel_smoother_width)) * aa_mask)];
-        }
-
-        unsigned n_smoother = profile_size() - 
-                              subpixel_smoother_width - 
-                              subpixel_center_width - 
-                              subpixel_scale*2;
-
-        val = m_gamma[0];
-        for(i = 0; i < n_smoother; i++)
-        {
-            *ch_smoother++ = (value_type)val;
-        }
-
-        ch = ch_center;
-        for(i = 0; i < subpixel_scale*2; i++)
-        {
-            *--ch = *ch_center++;
-        }
-    }
-
-
-}
-

Sources/libagg/agg-2.4/agg_math.h

@@ -1,437 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-// Bessel function (besj) was adapted for use in AGG library by Andy Wilk 
-// Contact: castor.vulgaris@gmail.com
-//----------------------------------------------------------------------------
-
-#ifndef AGG_MATH_INCLUDED
-#define AGG_MATH_INCLUDED
-
-#include <math.h>
-#include "agg_basics.h"
-
-namespace agg
-{
-
-    //------------------------------------------------------vertex_dist_epsilon
-    // Coinciding points maximal distance (Epsilon)
-    const double vertex_dist_epsilon = 1e-14;
-
-    //-----------------------------------------------------intersection_epsilon
-    // See calc_intersection
-    const double intersection_epsilon = 1.0e-30;
-
-    //------------------------------------------------------------cross_product
-    AGG_INLINE double cross_product(double x1, double y1, 
-                                    double x2, double y2, 
-                                    double x,  double y)
-    {
-        return (x - x2) * (y2 - y1) - (y - y2) * (x2 - x1);
-    }
-
-    //--------------------------------------------------------point_in_triangle
-    AGG_INLINE bool point_in_triangle(double x1, double y1, 
-                                      double x2, double y2, 
-                                      double x3, double y3, 
-                                      double x,  double y)
-    {
-        bool cp1 = cross_product(x1, y1, x2, y2, x, y) < 0.0;
-        bool cp2 = cross_product(x2, y2, x3, y3, x, y) < 0.0;
-        bool cp3 = cross_product(x3, y3, x1, y1, x, y) < 0.0;
-        return cp1 == cp2 && cp2 == cp3 && cp3 == cp1;
-    }
-
-    //-----------------------------------------------------------calc_distance
-    AGG_INLINE double calc_distance(double x1, double y1, double x2, double y2)
-    {
-        double dx = x2-x1;
-        double dy = y2-y1;
-        return sqrt(dx * dx + dy * dy);
-    }
-
-    //--------------------------------------------------------calc_sq_distance
-    AGG_INLINE double calc_sq_distance(double x1, double y1, double x2, double y2)
-    {
-        double dx = x2-x1;
-        double dy = y2-y1;
-        return dx * dx + dy * dy;
-    }
-
-    //------------------------------------------------calc_line_point_distance
-    AGG_INLINE double calc_line_point_distance(double x1, double y1, 
-                                               double x2, double y2, 
-                                               double x,  double y)
-    {
-        double dx = x2-x1;
-        double dy = y2-y1;
-        double d = sqrt(dx * dx + dy * dy);
-        if(d < vertex_dist_epsilon)
-        {
-            return calc_distance(x1, y1, x, y);
-        }
-        return ((x - x2) * dy - (y - y2) * dx) / d;
-    }
-
-    //-------------------------------------------------------calc_line_point_u
-    AGG_INLINE double calc_segment_point_u(double x1, double y1, 
-                                           double x2, double y2, 
-                                           double x,  double y)
-    {
-        double dx = x2 - x1;
-        double dy = y2 - y1;
-
-        if(dx == 0 && dy == 0)
-        {
-	        return 0;
-        }
-
-        double pdx = x - x1;
-        double pdy = y - y1;
-
-        return (pdx * dx + pdy * dy) / (dx * dx + dy * dy);
-    }
-
-    //---------------------------------------------calc_line_point_sq_distance
-    AGG_INLINE double calc_segment_point_sq_distance(double x1, double y1, 
-                                                     double x2, double y2, 
-                                                     double x,  double y,
-                                                     double u)
-    {
-        if(u <= 0)
-        {
-	        return calc_sq_distance(x, y, x1, y1);
-        }
-        else 
-        if(u >= 1)
-        {
-	        return calc_sq_distance(x, y, x2, y2);
-        }
-        return calc_sq_distance(x, y, x1 + u * (x2 - x1), y1 + u * (y2 - y1));
-    }
-
-    //---------------------------------------------calc_line_point_sq_distance
-    AGG_INLINE double calc_segment_point_sq_distance(double x1, double y1, 
-                                                     double x2, double y2, 
-                                                     double x,  double y)
-    {
-        return 
-            calc_segment_point_sq_distance(
-                x1, y1, x2, y2, x, y,
-                calc_segment_point_u(x1, y1, x2, y2, x, y));
-    }
-
-    //-------------------------------------------------------calc_intersection
-    AGG_INLINE bool calc_intersection(double ax, double ay, double bx, double by,
-                                      double cx, double cy, double dx, double dy,
-                                      double* x, double* y)
-    {
-        double num = (ay-cy) * (dx-cx) - (ax-cx) * (dy-cy);
-        double den = (bx-ax) * (dy-cy) - (by-ay) * (dx-cx);
-        if(fabs(den) < intersection_epsilon) return false;
-        double r = num / den;
-        *x = ax + r * (bx-ax);
-        *y = ay + r * (by-ay);
-        return true;
-    }
-
-    //-----------------------------------------------------intersection_exists
-    AGG_INLINE bool intersection_exists(double x1, double y1, double x2, double y2,
-                                        double x3, double y3, double x4, double y4)
-    {
-        // It's less expensive but you can't control the 
-        // boundary conditions: Less or LessEqual
-        double dx1 = x2 - x1;
-        double dy1 = y2 - y1;
-        double dx2 = x4 - x3;
-        double dy2 = y4 - y3;
-        return ((x3 - x2) * dy1 - (y3 - y2) * dx1 < 0.0) != 
-               ((x4 - x2) * dy1 - (y4 - y2) * dx1 < 0.0) &&
-               ((x1 - x4) * dy2 - (y1 - y4) * dx2 < 0.0) !=
-               ((x2 - x4) * dy2 - (y2 - y4) * dx2 < 0.0);
-
-        // It's is more expensive but more flexible 
-        // in terms of boundary conditions.
-        //--------------------
-        //double den  = (x2-x1) * (y4-y3) - (y2-y1) * (x4-x3);
-        //if(fabs(den) < intersection_epsilon) return false;
-        //double nom1 = (x4-x3) * (y1-y3) - (y4-y3) * (x1-x3);
-        //double nom2 = (x2-x1) * (y1-y3) - (y2-y1) * (x1-x3);
-        //double ua = nom1 / den;
-        //double ub = nom2 / den;
-        //return ua >= 0.0 && ua <= 1.0 && ub >= 0.0 && ub <= 1.0;
-    }
-
-    //--------------------------------------------------------calc_orthogonal
-    AGG_INLINE void calc_orthogonal(double thickness,
-                                    double x1, double y1,
-                                    double x2, double y2,
-                                    double* x, double* y)
-    {
-        double dx = x2 - x1;
-        double dy = y2 - y1;
-        double d = sqrt(dx*dx + dy*dy); 
-        *x =  thickness * dy / d;
-        *y = -thickness * dx / d;
-    }
-
-    //--------------------------------------------------------dilate_triangle
-    AGG_INLINE void dilate_triangle(double x1, double y1,
-                                    double x2, double y2,
-                                    double x3, double y3,
-                                    double *x, double* y,
-                                    double d)
-    {
-        double dx1=0.0;
-        double dy1=0.0; 
-        double dx2=0.0;
-        double dy2=0.0; 
-        double dx3=0.0;
-        double dy3=0.0; 
-        double loc = cross_product(x1, y1, x2, y2, x3, y3);
-        if(fabs(loc) > intersection_epsilon)
-        {
-            if(cross_product(x1, y1, x2, y2, x3, y3) > 0.0) 
-            {
-                d = -d;
-            }
-            calc_orthogonal(d, x1, y1, x2, y2, &dx1, &dy1);
-            calc_orthogonal(d, x2, y2, x3, y3, &dx2, &dy2);
-            calc_orthogonal(d, x3, y3, x1, y1, &dx3, &dy3);
-        }
-        *x++ = x1 + dx1;  *y++ = y1 + dy1;
-        *x++ = x2 + dx1;  *y++ = y2 + dy1;
-        *x++ = x2 + dx2;  *y++ = y2 + dy2;
-        *x++ = x3 + dx2;  *y++ = y3 + dy2;
-        *x++ = x3 + dx3;  *y++ = y3 + dy3;
-        *x++ = x1 + dx3;  *y++ = y1 + dy3;
-    }
-
-    //------------------------------------------------------calc_triangle_area
-    AGG_INLINE double calc_triangle_area(double x1, double y1,
-                                         double x2, double y2,
-                                         double x3, double y3)
-    {
-        return (x1*y2 - x2*y1 + x2*y3 - x3*y2 + x3*y1 - x1*y3) * 0.5;
-    }
-
-    //-------------------------------------------------------calc_polygon_area
-    template<class Storage> double calc_polygon_area(const Storage& st)
-    {
-        unsigned i;
-        double sum = 0.0;
-        double x  = st[0].x;
-        double y  = st[0].y;
-        double xs = x;
-        double ys = y;
-
-        for(i = 1; i < st.size(); i++)
-        {
-            const typename Storage::value_type& v = st[i];
-            sum += x * v.y - y * v.x;
-            x = v.x;
-            y = v.y;
-        }
-        return (sum + x * ys - y * xs) * 0.5;
-    }
-
-    //------------------------------------------------------------------------
-    // Tables for fast sqrt
-    extern int16u g_sqrt_table[1024];
-    extern int8   g_elder_bit_table[256];
-
-
-    //---------------------------------------------------------------fast_sqrt
-    //Fast integer Sqrt - really fast: no cycles, divisions or multiplications
-    #if defined(_MSC_VER)
-    #pragma warning(push)
-    #pragma warning(disable : 4035) //Disable warning "no return value"
-    #endif
-    AGG_INLINE unsigned fast_sqrt(unsigned val)
-    {
-    #if defined(_M_IX86) && defined(_MSC_VER) && !defined(AGG_NO_ASM)
-        //For Ix86 family processors this assembler code is used. 
-        //The key command here is bsr - determination the number of the most 
-        //significant bit of the value. For other processors
-        //(and maybe compilers) the pure C "#else" section is used.
-        __asm
-        {
-            mov ebx, val
-            mov edx, 11
-            bsr ecx, ebx
-            sub ecx, 9
-            jle less_than_9_bits
-            shr ecx, 1
-            adc ecx, 0
-            sub edx, ecx
-            shl ecx, 1
-            shr ebx, cl
-    less_than_9_bits:
-            xor eax, eax
-            mov  ax, g_sqrt_table[ebx*2]
-            mov ecx, edx
-            shr eax, cl
-        }
-    #else
-
-        //This code is actually pure C and portable to most 
-        //arcitectures including 64bit ones. 
-        unsigned t = val;
-        int bit=0;
-        unsigned shift = 11;
-
-        //The following piece of code is just an emulation of the
-        //Ix86 assembler command "bsr" (see above). However on old
-        //Intels (like Intel MMX 233MHz) this code is about twice 
-        //faster (sic!) then just one "bsr". On PIII and PIV the
-        //bsr is optimized quite well.
-        bit = t >> 24;
-        if(bit)
-        {
-            bit = g_elder_bit_table[bit] + 24;
-        }
-        else
-        {
-            bit = (t >> 16) & 0xFF;
-            if(bit)
-            {
-                bit = g_elder_bit_table[bit] + 16;
-            }
-            else
-            {
-                bit = (t >> 8) & 0xFF;
-                if(bit)
-                {
-                    bit = g_elder_bit_table[bit] + 8;
-                }
-                else
-                {
-                    bit = g_elder_bit_table[t];
-                }
-            }
-        }
-
-        //This code calculates the sqrt.
-        bit -= 9;
-        if(bit > 0)
-        {
-            bit = (bit >> 1) + (bit & 1);
-            shift -= bit;
-            val >>= (bit << 1);
-        }
-        return g_sqrt_table[val] >> shift;
-    #endif
-    }
-    #if defined(_MSC_VER)
-    #pragma warning(pop)
-    #endif
-
-
-
-
-    //--------------------------------------------------------------------besj
-    // Function BESJ calculates Bessel function of first kind of order n
-    // Arguments:
-    //     n - an integer (>=0), the order
-    //     x - value at which the Bessel function is required
-    //--------------------
-    // C++ Mathematical Library
-    // Convereted from equivalent FORTRAN library
-    // Converetd by Gareth Walker for use by course 392 computational project
-    // All functions tested and yield the same results as the corresponding
-    // FORTRAN versions.
-    //
-    // If you have any problems using these functions please report them to
-    // M.Muldoon@UMIST.ac.uk
-    //
-    // Documentation available on the web
-    // http://www.ma.umist.ac.uk/mrm/Teaching/392/libs/392.html
-    // Version 1.0   8/98
-    // 29 October, 1999
-    //--------------------
-    // Adapted for use in AGG library by Andy Wilk (castor.vulgaris@gmail.com)
-    //------------------------------------------------------------------------
-    inline double besj(double x, int n)
-    {
-        if(n < 0)
-        {
-            return 0;
-        }
-        double d = 1E-6;
-        double b = 0;
-        if(fabs(x) <= d) 
-        {
-            if(n != 0) return 0;
-            return 1;
-        }
-        double b1 = 0; // b1 is the value from the previous iteration
-        // Set up a starting order for recurrence
-        int m1 = (int)fabs(x) + 6;
-        if(fabs(x) > 5) 
-        {
-            m1 = (int)(fabs(1.4 * x + 60 / x));
-        }
-        int m2 = (int)(n + 2 + fabs(x) / 4);
-        if (m1 > m2) 
-        {
-            m2 = m1;
-        }
-    
-        // Apply recurrence down from curent max order
-        for(;;) 
-        {
-            double c3 = 0;
-            double c2 = 1E-30;
-            double c4 = 0;
-            int m8 = 1;
-            if (m2 / 2 * 2 == m2) 
-            {
-                m8 = -1;
-            }
-            int imax = m2 - 2;
-            for (int i = 1; i <= imax; i++) 
-            {
-                double c6 = 2 * (m2 - i) * c2 / x - c3;
-                c3 = c2;
-                c2 = c6;
-                if(m2 - i - 1 == n)
-                {
-                    b = c6;
-                }
-                m8 = -1 * m8;
-                if (m8 > 0)
-                {
-                    c4 = c4 + 2 * c6;
-                }
-            }
-            double c6 = 2 * c2 / x - c3;
-            if(n == 0)
-            {
-                b = c6;
-            }
-            c4 += c6;
-            b /= c4;
-            if(fabs(b - b1) < d)
-            {
-                return b;
-            }
-            b1 = b;
-            m2 += 3;
-        }
-    }
-
-}
-
-
-#endif

Sources/libagg/agg-2.4/agg_math_stroke.h

@@ -1,526 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// Stroke math
-//
-//----------------------------------------------------------------------------
-
-#ifndef AGG_STROKE_MATH_INCLUDED
-#define AGG_STROKE_MATH_INCLUDED
-
-#include "agg_math.h"
-#include "agg_vertex_sequence.h"
-
-namespace agg
-{
-    //-------------------------------------------------------------line_cap_e
-    enum line_cap_e
-    {
-        butt_cap,
-        square_cap,
-        round_cap
-    };
-
-    //------------------------------------------------------------line_join_e
-    enum line_join_e
-    {
-        miter_join         = 0,
-        miter_join_revert  = 1,
-        round_join         = 2,
-        bevel_join         = 3,
-        miter_join_round   = 4
-    };
-
-
-    //-----------------------------------------------------------inner_join_e
-    enum inner_join_e
-    {
-        inner_bevel,
-        inner_miter,
-        inner_jag,
-        inner_round
-    };
-
-    //------------------------------------------------------------math_stroke
-    template<class VertexConsumer> class math_stroke
-    {
-    public:
-        typedef typename VertexConsumer::value_type coord_type;
-
-        math_stroke();
-
-        void line_cap(line_cap_e lc)     { m_line_cap = lc; }
-        void line_join(line_join_e lj)   { m_line_join = lj; }
-        void inner_join(inner_join_e ij) { m_inner_join = ij; }
-
-        line_cap_e   line_cap()   const { return m_line_cap; }
-        line_join_e  line_join()  const { return m_line_join; }
-        inner_join_e inner_join() const { return m_inner_join; }
-
-        void width(double w);
-        void miter_limit(double ml) { m_miter_limit = ml; }
-        void miter_limit_theta(double t);
-        void inner_miter_limit(double ml) { m_inner_miter_limit = ml; }
-        void approximation_scale(double as) { m_approx_scale = as; }
-
-        double width() const { return m_width * 2.0; }
-        double miter_limit() const { return m_miter_limit; }
-        double inner_miter_limit() const { return m_inner_miter_limit; }
-        double approximation_scale() const { return m_approx_scale; }
-
-        void calc_cap(VertexConsumer& vc,
-                      const vertex_dist& v0, 
-                      const vertex_dist& v1, 
-                      double len);
-
-        void calc_join(VertexConsumer& vc,
-                       const vertex_dist& v0, 
-                       const vertex_dist& v1, 
-                       const vertex_dist& v2,
-                       double len1, 
-                       double len2);
-
-    private:
-        AGG_INLINE void add_vertex(VertexConsumer& vc, double x, double y)
-        {
-            vc.add(coord_type(x, y));
-        }
-
-        void calc_arc(VertexConsumer& vc,
-                      double x,   double y, 
-                      double dx1, double dy1, 
-                      double dx2, double dy2);
-
-        void calc_miter(VertexConsumer& vc,
-                        const vertex_dist& v0, 
-                        const vertex_dist& v1, 
-                        const vertex_dist& v2,
-                        double dx1, double dy1, 
-                        double dx2, double dy2,
-                        line_join_e lj,
-                        double mlimit,
-                        double dbevel);
-
-        double       m_width;
-        double       m_width_abs;
-        double       m_width_eps;
-        int          m_width_sign;
-        double       m_miter_limit;
-        double       m_inner_miter_limit;
-        double       m_approx_scale;
-        line_cap_e   m_line_cap;
-        line_join_e  m_line_join;
-        inner_join_e m_inner_join;
-    };
-
-    //-----------------------------------------------------------------------
-    template<class VC> math_stroke<VC>::math_stroke() :
-        m_width(0.5),
-        m_width_abs(0.5),
-        m_width_eps(0.5/1024.0),
-        m_width_sign(1),
-        m_miter_limit(4.0),
-        m_inner_miter_limit(1.01),
-        m_approx_scale(1.0),
-        m_line_cap(butt_cap),
-        m_line_join(miter_join),
-        m_inner_join(inner_miter)
-    {
-    }
-
-    //-----------------------------------------------------------------------
-    template<class VC> void math_stroke<VC>::width(double w)
-    { 
-        m_width = w * 0.5; 
-        if(m_width < 0)
-        {
-            m_width_abs  = -m_width;
-            m_width_sign = -1;
-        }
-        else
-        {
-            m_width_abs  = m_width;
-            m_width_sign = 1;
-        }
-        m_width_eps = m_width / 1024.0;
-    }
-
-    //-----------------------------------------------------------------------
-    template<class VC> void math_stroke<VC>::miter_limit_theta(double t)
-    { 
-        m_miter_limit = 1.0 / sin(t * 0.5) ;
-    }
-
-    //-----------------------------------------------------------------------
-    template<class VC> 
-    void math_stroke<VC>::calc_arc(VC& vc,
-                                   double x,   double y, 
-                                   double dx1, double dy1, 
-                                   double dx2, double dy2)
-    {
-        double a1 = atan2(dy1 * m_width_sign, dx1 * m_width_sign);
-        double a2 = atan2(dy2 * m_width_sign, dx2 * m_width_sign);
-        double da = a1 - a2;
-        int i, n;
-
-        da = acos(m_width_abs / (m_width_abs + 0.125 / m_approx_scale)) * 2;
-
-        add_vertex(vc, x + dx1, y + dy1);
-        if(m_width_sign > 0)
-        {
-            if(a1 > a2) a2 += 2 * pi;
-            n = int((a2 - a1) / da);
-            da = (a2 - a1) / (n + 1);
-            a1 += da;
-            for(i = 0; i < n; i++)
-            {
-                add_vertex(vc, x + cos(a1) * m_width, y + sin(a1) * m_width);
-                a1 += da;
-            }
-        }
-        else
-        {
-            if(a1 < a2) a2 -= 2 * pi;
-            n = int((a1 - a2) / da);
-            da = (a1 - a2) / (n + 1);
-            a1 -= da;
-            for(i = 0; i < n; i++)
-            {
-                add_vertex(vc, x + cos(a1) * m_width, y + sin(a1) * m_width);
-                a1 -= da;
-            }
-        }
-        add_vertex(vc, x + dx2, y + dy2);
-    }
-
-    //-----------------------------------------------------------------------
-    template<class VC> 
-    void math_stroke<VC>::calc_miter(VC& vc,
-                                     const vertex_dist& v0, 
-                                     const vertex_dist& v1, 
-                                     const vertex_dist& v2,
-                                     double dx1, double dy1, 
-                                     double dx2, double dy2,
-                                     line_join_e lj,
-                                     double mlimit,
-                                     double dbevel)
-    {
-        double xi  = v1.x;
-        double yi  = v1.y;
-        double di  = 1;
-        double lim = m_width_abs * mlimit;
-        bool miter_limit_exceeded = true; // Assume the worst
-        bool intersection_failed  = true; // Assume the worst
-
-        if(calc_intersection(v0.x + dx1, v0.y - dy1,
-                             v1.x + dx1, v1.y - dy1,
-                             v1.x + dx2, v1.y - dy2,
-                             v2.x + dx2, v2.y - dy2,
-                             &xi, &yi))
-        {
-            // Calculation of the intersection succeeded
-            //---------------------
-            di = calc_distance(v1.x, v1.y, xi, yi);
-            if(di <= lim)
-            {
-                // Inside the miter limit
-                //---------------------
-                add_vertex(vc, xi, yi);
-                miter_limit_exceeded = false;
-            }
-            intersection_failed = false;
-        }
-        else
-        {
-            // Calculation of the intersection failed, most probably
-            // the three points lie one straight line. 
-            // First check if v0 and v2 lie on the opposite sides of vector: 
-            // (v1.x, v1.y) -> (v1.x+dx1, v1.y-dy1), that is, the perpendicular
-            // to the line determined by vertices v0 and v1.
-            // This condition determines whether the next line segments continues
-            // the previous one or goes back.
-            //----------------
-            double x2 = v1.x + dx1;
-            double y2 = v1.y - dy1;
-            if((cross_product(v0.x, v0.y, v1.x, v1.y, x2, y2) < 0.0) == 
-               (cross_product(v1.x, v1.y, v2.x, v2.y, x2, y2) < 0.0))
-            {
-                // This case means that the next segment continues 
-                // the previous one (straight line)
-                //-----------------
-                add_vertex(vc, v1.x + dx1, v1.y - dy1);
-                miter_limit_exceeded = false;
-            }
-        }
-
-        if(miter_limit_exceeded)
-        {
-            // Miter limit exceeded
-            //------------------------
-            switch(lj)
-            {
-            case miter_join_revert:
-                // For the compatibility with SVG, PDF, etc, 
-                // we use a simple bevel join instead of
-                // "smart" bevel
-                //-------------------
-                add_vertex(vc, v1.x + dx1, v1.y - dy1);
-                add_vertex(vc, v1.x + dx2, v1.y - dy2);
-                break;
-
-            case miter_join_round:
-                calc_arc(vc, v1.x, v1.y, dx1, -dy1, dx2, -dy2);
-                break;
-
-            default:
-                // If no miter-revert, calculate new dx1, dy1, dx2, dy2
-                //----------------
-                if(intersection_failed)
-                {
-                    mlimit *= m_width_sign;
-                    add_vertex(vc, v1.x + dx1 + dy1 * mlimit, 
-                                   v1.y - dy1 + dx1 * mlimit);
-                    add_vertex(vc, v1.x + dx2 - dy2 * mlimit, 
-                                   v1.y - dy2 - dx2 * mlimit);
-                }
-                else
-                {
-                    double x1 = v1.x + dx1;
-                    double y1 = v1.y - dy1;
-                    double x2 = v1.x + dx2;
-                    double y2 = v1.y - dy2;
-                    di = (lim - dbevel) / (di - dbevel);
-                    add_vertex(vc, x1 + (xi - x1) * di, 
-                                   y1 + (yi - y1) * di);
-                    add_vertex(vc, x2 + (xi - x2) * di, 
-                                   y2 + (yi - y2) * di);
-                }
-                break;
-            }
-        }
-    }
-
-    //--------------------------------------------------------stroke_calc_cap
-    template<class VC> 
-    void math_stroke<VC>::calc_cap(VC& vc,
-                                   const vertex_dist& v0, 
-                                   const vertex_dist& v1, 
-                                   double len)
-    {
-        vc.remove_all();
-
-        double dx1 = (v1.y - v0.y) / len;
-        double dy1 = (v1.x - v0.x) / len;
-        double dx2 = 0;
-        double dy2 = 0;
-
-        dx1 *= m_width;
-        dy1 *= m_width;
-
-        if(m_line_cap != round_cap)
-        {
-            if(m_line_cap == square_cap)
-            {
-                dx2 = dy1 * m_width_sign;
-                dy2 = dx1 * m_width_sign;
-            }
-            add_vertex(vc, v0.x - dx1 - dx2, v0.y + dy1 - dy2);
-            add_vertex(vc, v0.x + dx1 - dx2, v0.y - dy1 - dy2);
-        }
-        else
-        {
-            double da = acos(m_width_abs / (m_width_abs + 0.125 / m_approx_scale)) * 2;
-            double a1;
-            int i;
-            int n = int(pi / da);
-
-            da = pi / (n + 1);
-            add_vertex(vc, v0.x - dx1, v0.y + dy1);
-            if(m_width_sign > 0)
-            {
-                a1 = atan2(dy1, -dx1);
-                a1 += da;
-                for(i = 0; i < n; i++)
-                {
-                    add_vertex(vc, v0.x + cos(a1) * m_width, 
-                                   v0.y + sin(a1) * m_width);
-                    a1 += da;
-                }
-            }
-            else
-            {
-                a1 = atan2(-dy1, dx1);
-                a1 -= da;
-                for(i = 0; i < n; i++)
-                {
-                    add_vertex(vc, v0.x + cos(a1) * m_width, 
-                                   v0.y + sin(a1) * m_width);
-                    a1 -= da;
-                }
-            }
-            add_vertex(vc, v0.x + dx1, v0.y - dy1);
-        }
-    }
-
-    //-----------------------------------------------------------------------
-    template<class VC> 
-    void math_stroke<VC>::calc_join(VC& vc,
-                                    const vertex_dist& v0, 
-                                    const vertex_dist& v1, 
-                                    const vertex_dist& v2,
-                                    double len1, 
-                                    double len2)
-    {
-        double dx1 = m_width * (v1.y - v0.y) / len1;
-        double dy1 = m_width * (v1.x - v0.x) / len1;
-        double dx2 = m_width * (v2.y - v1.y) / len2;
-        double dy2 = m_width * (v2.x - v1.x) / len2;
-
-        vc.remove_all();
-
-        double cp = cross_product(v0.x, v0.y, v1.x, v1.y, v2.x, v2.y);
-        if(cp != 0 && (cp > 0) == (m_width > 0))
-        {
-            // Inner join
-            //---------------
-            double limit = ((len1 < len2) ? len1 : len2) / m_width_abs;
-            if(limit < m_inner_miter_limit)
-            {
-                limit = m_inner_miter_limit;
-            }
-
-            switch(m_inner_join)
-            {
-            default: // inner_bevel
-                add_vertex(vc, v1.x + dx1, v1.y - dy1);
-                add_vertex(vc, v1.x + dx2, v1.y - dy2);
-                break;
-
-            case inner_miter:
-                calc_miter(vc,
-                           v0, v1, v2, dx1, dy1, dx2, dy2, 
-                           miter_join_revert, 
-                           limit, 0);
-                break;
-
-            case inner_jag:
-            case inner_round:
-                cp = (dx1-dx2) * (dx1-dx2) + (dy1-dy2) * (dy1-dy2);
-                if(cp < len1 * len1 && cp < len2 * len2)
-                {
-                    calc_miter(vc,
-                               v0, v1, v2, dx1, dy1, dx2, dy2, 
-                               miter_join_revert, 
-                               limit, 0);
-                }
-                else
-                {
-                    if(m_inner_join == inner_jag)
-                    {
-                        add_vertex(vc, v1.x + dx1, v1.y - dy1);
-                        add_vertex(vc, v1.x,       v1.y      );
-                        add_vertex(vc, v1.x + dx2, v1.y - dy2);
-                    }
-                    else
-                    {
-                        add_vertex(vc, v1.x + dx1, v1.y - dy1);
-                        add_vertex(vc, v1.x,       v1.y      );
-                        calc_arc(vc, v1.x, v1.y, dx2, -dy2, dx1, -dy1);
-                        add_vertex(vc, v1.x,       v1.y      );
-                        add_vertex(vc, v1.x + dx2, v1.y - dy2);
-                    }
-                }
-                break;
-            }
-        }
-        else
-        {
-            // Outer join
-            //---------------
-
-            // Calculate the distance between v1 and 
-            // the central point of the bevel line segment
-            //---------------
-            double dx = (dx1 + dx2) / 2;
-            double dy = (dy1 + dy2) / 2;
-            double dbevel = sqrt(dx * dx + dy * dy);
-
-            if(m_line_join == round_join || m_line_join == bevel_join)
-            {
-                // This is an optimization that reduces the number of points 
-                // in cases of almost collinear segments. If there's no
-                // visible difference between bevel and miter joins we'd rather
-                // use miter join because it adds only one point instead of two. 
-                //
-                // Here we calculate the middle point between the bevel points 
-                // and then, the distance between v1 and this middle point. 
-                // At outer joins this distance always less than stroke width, 
-                // because it's actually the height of an isosceles triangle of
-                // v1 and its two bevel points. If the difference between this
-                // width and this value is small (no visible bevel) we can 
-                // add just one point. 
-                //
-                // The constant in the expression makes the result approximately 
-                // the same as in round joins and caps. You can safely comment 
-                // out this entire "if".
-                //-------------------
-                if(m_approx_scale * (m_width_abs - dbevel) < m_width_eps)
-                {
-                    if(calc_intersection(v0.x + dx1, v0.y - dy1,
-                                         v1.x + dx1, v1.y - dy1,
-                                         v1.x + dx2, v1.y - dy2,
-                                         v2.x + dx2, v2.y - dy2,
-                                         &dx, &dy))
-                    {
-                        add_vertex(vc, dx, dy);
-                    }
-                    else
-                    {
-                        add_vertex(vc, v1.x + dx1, v1.y - dy1);
-                    }
-                    return;
-                }
-            }
-
-            switch(m_line_join)
-            {
-            case miter_join:
-            case miter_join_revert:
-            case miter_join_round:
-                calc_miter(vc, 
-                           v0, v1, v2, dx1, dy1, dx2, dy2, 
-                           m_line_join, 
-                           m_miter_limit,
-                           dbevel);
-                break;
-
-            case round_join:
-                calc_arc(vc, v1.x, v1.y, dx1, -dy1, dx2, -dy2);
-                break;
-
-            default: // Bevel join
-                add_vertex(vc, v1.x + dx1, v1.y - dy1);
-                add_vertex(vc, v1.x + dx2, v1.y - dy2);
-                break;
-            }
-        }
-    }
-
-
-
-
-}
-
-#endif

Sources/libagg/agg-2.4/agg_path_length.h

@@ -1,65 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-#ifndef AGG_PATH_LENGTH_INCLUDED
-#define AGG_PATH_LENGTH_INCLUDED
-
-#include "agg_math.h"
-
-namespace agg
-{
-    template<class VertexSource> 
-    double path_length(VertexSource& vs, unsigned path_id = 0)
-    {
-        double len = 0.0;
-        double start_x = 0.0;
-        double start_y = 0.0;
-        double x1 = 0.0;
-        double y1 = 0.0;
-        double x2 = 0.0;
-        double y2 = 0.0;
-        bool first = true;
-
-        unsigned cmd;
-        vs.rewind(path_id);
-        while(!is_stop(cmd = vs.vertex(&x2, &y2)))
-        {
-            if(is_vertex(cmd))
-            {
-                if(first || is_move_to(cmd))
-                {
-                    start_x = x2;
-                    start_y = y2;
-                }
-                else
-                {
-                    len += calc_distance(x1, y1, x2, y2);
-                }
-                x1 = x2;
-                y1 = y2;
-                first = false;
-            }
-            else
-            {
-                if(is_close(cmd) && !first)
-                {
-                    len += calc_distance(x1, y1, start_x, start_y);
-                }
-            }
-        }
-        return len;
-    }
-}
-
-#endif

Sources/libagg/agg-2.4/agg_path_storage_integer.h

@@ -1,295 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-
-#ifndef AGG_PATH_STORAGE_INTEGER_INCLUDED
-#define AGG_PATH_STORAGE_INTEGER_INCLUDED
-
-#include <string.h>
-#include "agg_array.h"
-
-namespace agg
-{
-    //---------------------------------------------------------vertex_integer
-    template<class T, unsigned CoordShift=6> struct vertex_integer
-    {
-        enum path_cmd
-        {
-            cmd_move_to = 0,
-            cmd_line_to = 1,
-            cmd_curve3  = 2,
-            cmd_curve4  = 3
-        };
-
-        enum coord_scale_e
-        {
-            coord_shift = CoordShift,
-            coord_scale  = 1 << coord_shift
-        };
-
-        T x,y;
-        vertex_integer() {}
-        vertex_integer(T x_, T y_, unsigned flag) :
-            x(((x_ << 1) & ~1) | (flag &  1)),
-            y(((y_ << 1) & ~1) | (flag >> 1)) {}
-
-        unsigned vertex(double* x_, double* y_, 
-                        double dx=0, double dy=0,
-                        double scale=1.0) const
-        {
-            *x_ = dx + (double(x >> 1) / coord_scale) * scale;
-            *y_ = dy + (double(y >> 1) / coord_scale) * scale;
-            switch(((y & 1) << 1) | (x & 1))
-            {
-                case cmd_move_to: return path_cmd_move_to;
-                case cmd_line_to: return path_cmd_line_to;
-                case cmd_curve3:  return path_cmd_curve3;
-                case cmd_curve4:  return path_cmd_curve4;
-            }
-            return path_cmd_stop;
-        }
-    };
-
-
-    //---------------------------------------------------path_storage_integer
-    template<class T, unsigned CoordShift=6> class path_storage_integer
-    {
-    public:
-        typedef T value_type;
-        typedef vertex_integer<T, CoordShift> vertex_integer_type;
-
-        //--------------------------------------------------------------------
-        path_storage_integer() : m_storage(), m_vertex_idx(0), m_closed(true) {}
-
-        //--------------------------------------------------------------------
-        void remove_all() { m_storage.remove_all(); }
-
-        //--------------------------------------------------------------------
-        void move_to(T x, T y)
-        {
-            m_storage.add(vertex_integer_type(x, y, vertex_integer_type::cmd_move_to));
-        }
-
-        //--------------------------------------------------------------------
-        void line_to(T x, T y)
-        {
-            m_storage.add(vertex_integer_type(x, y, vertex_integer_type::cmd_line_to));
-        }
-
-        //--------------------------------------------------------------------
-        void curve3(T x_ctrl,  T y_ctrl, 
-                    T x_to,    T y_to)
-        {
-            m_storage.add(vertex_integer_type(x_ctrl, y_ctrl, vertex_integer_type::cmd_curve3));
-            m_storage.add(vertex_integer_type(x_to,   y_to,   vertex_integer_type::cmd_curve3));
-        }
-
-        //--------------------------------------------------------------------
-        void curve4(T x_ctrl1, T y_ctrl1, 
-                    T x_ctrl2, T y_ctrl2, 
-                    T x_to,    T y_to)
-        {
-            m_storage.add(vertex_integer_type(x_ctrl1, y_ctrl1, vertex_integer_type::cmd_curve4));
-            m_storage.add(vertex_integer_type(x_ctrl2, y_ctrl2, vertex_integer_type::cmd_curve4));
-            m_storage.add(vertex_integer_type(x_to,    y_to,    vertex_integer_type::cmd_curve4));
-        }
-
-        //--------------------------------------------------------------------
-        void close_polygon() {}
-
-        //--------------------------------------------------------------------
-        unsigned size() const { return m_storage.size(); }
-        unsigned vertex(unsigned idx, double* x, double* y) const
-        {
-            return m_storage[idx].vertex(x, y);
-        }
-
-        //--------------------------------------------------------------------
-        unsigned byte_size() const { return m_storage.size() * sizeof(vertex_integer_type); }
-        void serialize(int8u* ptr) const
-        {
-            unsigned i;
-            for(i = 0; i < m_storage.size(); i++)
-            {
-                memcpy(ptr, &m_storage[i], sizeof(vertex_integer_type));
-                ptr += sizeof(vertex_integer_type);
-            }
-        }
-
-        //--------------------------------------------------------------------
-        void rewind(unsigned) 
-        { 
-            m_vertex_idx = 0; 
-            m_closed = true;
-        }
-
-        //--------------------------------------------------------------------
-        unsigned vertex(double* x, double* y)
-        {
-            if(m_storage.size() < 2 || m_vertex_idx > m_storage.size()) 
-            {
-                *x = 0;
-                *y = 0;
-                return path_cmd_stop;
-            }
-            if(m_vertex_idx == m_storage.size())
-            {
-                *x = 0;
-                *y = 0;
-                ++m_vertex_idx;
-                return path_cmd_end_poly | path_flags_close;
-            }
-            unsigned cmd = m_storage[m_vertex_idx].vertex(x, y);
-            if(is_move_to(cmd) && !m_closed)
-            {
-                *x = 0;
-                *y = 0;
-                m_closed = true;
-                return path_cmd_end_poly | path_flags_close;
-            }
-            m_closed = false;
-            ++m_vertex_idx;
-            return cmd;
-        }
-
-        //--------------------------------------------------------------------
-        rect_d bounding_rect() const
-        {
-            rect_d bounds(1e100, 1e100, -1e100, -1e100);
-            if(m_storage.size() == 0)
-            {
-                bounds.x1 = bounds.y1 = bounds.x2 = bounds.y2 = 0.0;
-            }
-            else
-            {
-                unsigned i;
-                for(i = 0; i < m_storage.size(); i++)
-                {
-                    double x, y;
-                    m_storage[i].vertex(&x, &y);
-                    if(x < bounds.x1) bounds.x1 = x;
-                    if(y < bounds.y1) bounds.y1 = y;
-                    if(x > bounds.x2) bounds.x2 = x;
-                    if(y > bounds.y2) bounds.y2 = y;
-                }
-            }
-            return bounds;
-        }
-
-    private:
-        pod_bvector<vertex_integer_type, 6> m_storage;
-        unsigned                            m_vertex_idx;
-        bool                                m_closed;
-    };
-
-
-
-
-    //-----------------------------------------serialized_integer_path_adaptor
-    template<class T, unsigned CoordShift=6> class serialized_integer_path_adaptor
-    {
-    public:
-        typedef vertex_integer<T, CoordShift> vertex_integer_type;
-
-        //--------------------------------------------------------------------
-        serialized_integer_path_adaptor() :
-            m_data(0),
-            m_end(0),
-            m_ptr(0),
-            m_dx(0.0),
-            m_dy(0.0),
-            m_scale(1.0),
-            m_vertices(0)
-        {}
-
-        //--------------------------------------------------------------------
-        serialized_integer_path_adaptor(const int8u* data, unsigned size,
-                                        double dx, double dy) :
-            m_data(data),
-            m_end(data + size),
-            m_ptr(data),
-            m_dx(dx),
-            m_dy(dy),
-            m_vertices(0)
-        {}
-
-        //--------------------------------------------------------------------
-        void init(const int8u* data, unsigned size, 
-                  double dx, double dy, double scale=1.0)
-        {
-            m_data     = data;
-            m_end      = data + size;
-            m_ptr      = data;
-            m_dx       = dx;
-            m_dy       = dy;
-            m_scale    = scale;
-            m_vertices = 0;
-        }
-
-
-        //--------------------------------------------------------------------
-        void rewind(unsigned) 
-        { 
-            m_ptr      = m_data; 
-            m_vertices = 0;
-        }
-
-        //--------------------------------------------------------------------
-        unsigned vertex(double* x, double* y)
-        {
-            if(m_data == 0 || m_ptr > m_end) 
-            {
-                *x = 0;
-                *y = 0;
-                return path_cmd_stop;
-            }
-
-            if(m_ptr == m_end)
-            {
-                *x = 0;
-                *y = 0;
-                m_ptr += sizeof(vertex_integer_type);
-                return path_cmd_end_poly | path_flags_close;
-            }
-
-            vertex_integer_type v;
-            memcpy(&v, m_ptr, sizeof(vertex_integer_type));
-            unsigned cmd = v.vertex(x, y, m_dx, m_dy, m_scale);
-            if(is_move_to(cmd) && m_vertices > 2)
-            {
-                *x = 0;
-                *y = 0;
-                m_vertices = 0;
-                return path_cmd_end_poly | path_flags_close;
-            }
-            ++m_vertices;
-            m_ptr += sizeof(vertex_integer_type);
-            return cmd;
-        }
-
-    private:
-        const int8u* m_data;
-        const int8u* m_end;
-        const int8u* m_ptr;
-        double       m_dx;
-        double       m_dy;
-        double       m_scale;
-        unsigned     m_vertices;
-    };
-
-}
-
-
-#endif
-

Sources/libagg/agg-2.4/agg_pattern_filters_rgba.h

@@ -1,122 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-#ifndef AGG_PATTERN_FILTERS_RGBA8_INCLUDED
-#define AGG_PATTERN_FILTERS_RGBA8_INCLUDED
-
-#include "agg_basics.h"
-#include "agg_line_aa_basics.h"
-#include "agg_color_rgba.h"
-
-
-namespace agg
-{
-
-    //=======================================================pattern_filter_nn
-    template<class ColorT> struct pattern_filter_nn
-    {
-        typedef ColorT color_type;
-        static unsigned dilation() { return 0; }
-
-        static void AGG_INLINE pixel_low_res(color_type const* const* buf, 
-                                             color_type* p, int x, int y)
-        {
-            *p = buf[y][x];
-        }
-
-        static void AGG_INLINE pixel_high_res(color_type const* const* buf, 
-                                              color_type* p, int x, int y)
-        {
-            *p = buf[y >> line_subpixel_shift]
-                    [x >> line_subpixel_shift];
-        }
-    };
-
-    typedef pattern_filter_nn<rgba8>  pattern_filter_nn_rgba8;
-    typedef pattern_filter_nn<rgba16> pattern_filter_nn_rgba16;
-
-
-    //===========================================pattern_filter_bilinear_rgba
-    template<class ColorT> struct pattern_filter_bilinear_rgba
-    {
-        typedef ColorT color_type;
-        typedef typename color_type::value_type value_type;
-        typedef typename color_type::calc_type calc_type;
-
-
-        static unsigned dilation() { return 1; }
-
-        static AGG_INLINE void pixel_low_res(color_type const* const* buf, 
-                                             color_type* p, int x, int y)
-        {
-            *p = buf[y][x];
-        }
-
-        static AGG_INLINE void pixel_high_res(color_type const* const* buf, 
-                                              color_type* p, int x, int y)
-        {
-            calc_type r, g, b, a;
-            r = g = b = a = line_subpixel_scale * line_subpixel_scale / 2;
-
-            calc_type weight;
-            int x_lr = x >> line_subpixel_shift;
-            int y_lr = y >> line_subpixel_shift;
-
-            x &= line_subpixel_mask;
-            y &= line_subpixel_mask;
-            const color_type* ptr = buf[y_lr] + x_lr;
-
-            weight = (line_subpixel_scale - x) * 
-                     (line_subpixel_scale - y);
-            r += weight * ptr->r;
-            g += weight * ptr->g;
-            b += weight * ptr->b;
-            a += weight * ptr->a;
-
-            ++ptr;
-
-            weight = x * (line_subpixel_scale - y);
-            r += weight * ptr->r;
-            g += weight * ptr->g;
-            b += weight * ptr->b;
-            a += weight * ptr->a;
-
-            ptr = buf[y_lr + 1] + x_lr;
-
-            weight = (line_subpixel_scale - x) * y;
-            r += weight * ptr->r;
-            g += weight * ptr->g;
-            b += weight * ptr->b;
-            a += weight * ptr->a;
-
-            ++ptr;
-
-            weight = x * y;
-            r += weight * ptr->r;
-            g += weight * ptr->g;
-            b += weight * ptr->b;
-            a += weight * ptr->a;
-
-            p->r = (value_type)(r >> line_subpixel_shift * 2);
-            p->g = (value_type)(g >> line_subpixel_shift * 2);
-            p->b = (value_type)(b >> line_subpixel_shift * 2);
-            p->a = (value_type)(a >> line_subpixel_shift * 2);
-        }
-    };
-
-    typedef pattern_filter_bilinear_rgba<rgba8>  pattern_filter_bilinear_rgba8;
-    typedef pattern_filter_bilinear_rgba<rgba16> pattern_filter_bilinear_rgba16;
-}
-
-#endif

Sources/libagg/agg-2.4/agg_pixfmt_amask_adaptor.h

@@ -1,240 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-
-#ifndef AGG_PIXFMT_AMASK_ADAPTOR_INCLUDED
-#define AGG_PIXFMT_AMASK_ADAPTOR_INCLUDED
-
-
-#include <string.h>
-#include "agg_array.h"
-#include "agg_rendering_buffer.h"
-
-
-namespace agg
-{
-    //==================================================pixfmt_amask_adaptor
-    template<class PixFmt, class AlphaMask> class pixfmt_amask_adaptor
-    {
-    public:
-        typedef PixFmt pixfmt_type;
-        typedef typename pixfmt_type::color_type color_type;
-        typedef typename pixfmt_type::row_data row_data;
-        typedef AlphaMask amask_type;
-        typedef typename amask_type::cover_type cover_type;
-
-    private:
-        enum span_extra_tail_e { span_extra_tail = 256 };
-
-        void realloc_span(unsigned len)
-        {
-            if(len > m_span.size())
-            {
-                m_span.resize(len + span_extra_tail);
-            }
-        }
-
-        void init_span(unsigned len)
-        {
-            realloc_span(len);
-            memset(&m_span[0], amask_type::cover_full, len * sizeof(cover_type));
-        }
-
-        void init_span(unsigned len, const cover_type* covers)
-        {
-            realloc_span(len);
-            memcpy(&m_span[0], covers, len * sizeof(cover_type));
-        }
-
-
-    public:
-        pixfmt_amask_adaptor(pixfmt_type& pixf, const amask_type& mask) :
-            m_pixf(&pixf), m_mask(&mask), m_span()
-        {}
-
-        void attach_pixfmt(pixfmt_type& pixf)          { m_pixf = &pixf; }
-        void attach_alpha_mask(const amask_type& mask) { m_mask = &mask; }
-
-        //--------------------------------------------------------------------
-        template<class PixFmt2>
-        bool attach_pixfmt(PixFmt2& pixf, int x1, int y1, int x2, int y2)
-        {
-            return m_pixf->attach(pixf, x1, y1, x2, y2);
-        }
-
-        //--------------------------------------------------------------------
-        unsigned width()  const { return m_pixf->width();  }
-        unsigned height() const { return m_pixf->height(); }
-
-        //--------------------------------------------------------------------
-        color_type pixel(int x, int y)
-        {
-            return m_pixf->pixel(x, y);
-        }
-
-        //--------------------------------------------------------------------
-        void copy_pixel(int x, int y, const color_type& c)
-        {
-            m_pixf->blend_pixel(x, y, c, m_mask->pixel(x, y));
-        }
-
-        //--------------------------------------------------------------------
-        void blend_pixel(int x, int y, const color_type& c, cover_type cover)
-        {
-            m_pixf->blend_pixel(x, y, c, m_mask->combine_pixel(x, y, cover));
-        }
-
-        //--------------------------------------------------------------------
-        void copy_hline(int x, int y, 
-                        unsigned len, 
-                        const color_type& c)
-        {
-            realloc_span(len);
-            m_mask->fill_hspan(x, y, &m_span[0], len);
-            m_pixf->blend_solid_hspan(x, y, len, c, &m_span[0]);
-        }
-
-        //--------------------------------------------------------------------
-        void blend_hline(int x, int y,
-                         unsigned len, 
-                         const color_type& c,
-                         cover_type cover)
-        {
-            init_span(len);
-            m_mask->combine_hspan(x, y, &m_span[0], len);
-            m_pixf->blend_solid_hspan(x, y, len, c, &m_span[0]);
-        }
-
-        //--------------------------------------------------------------------
-        void copy_vline(int x, int y,
-                        unsigned len, 
-                        const color_type& c)
-        {
-            realloc_span(len);
-            m_mask->fill_vspan(x, y, &m_span[0], len);
-            m_pixf->blend_solid_vspan(x, y, len, c, &m_span[0]);
-        }
-
-        //--------------------------------------------------------------------
-        void blend_vline(int x, int y,
-                         unsigned len, 
-                         const color_type& c,
-                         cover_type cover)
-        {
-            init_span(len);
-            m_mask->combine_vspan(x, y, &m_span[0], len);
-            m_pixf->blend_solid_vspan(x, y, len, c, &m_span[0]);
-        }
-
-        //--------------------------------------------------------------------
-        void copy_from(const rendering_buffer& from, 
-                       int xdst, int ydst,
-                       int xsrc, int ysrc,
-                       unsigned len)
-        {
-            m_pixf->copy_from(from, xdst, ydst, xsrc, ysrc, len);
-        }
-
-
-        //--------------------------------------------------------------------
-        void blend_solid_hspan(int x, int y,
-                               unsigned len, 
-                               const color_type& c,
-                               const cover_type* covers)
-        {
-            init_span(len, covers);
-            m_mask->combine_hspan(x, y, &m_span[0], len);
-            m_pixf->blend_solid_hspan(x, y, len, c, &m_span[0]);
-        }
-
-
-        //--------------------------------------------------------------------
-        void blend_solid_vspan(int x, int y,
-                               unsigned len, 
-                               const color_type& c,
-                               const cover_type* covers)
-        {
-            init_span(len, covers);
-            m_mask->combine_vspan(x, y, &m_span[0], len);
-            m_pixf->blend_solid_vspan(x, y, len, c, &m_span[0]);
-        }
-
-
-        //--------------------------------------------------------------------
-        void copy_color_hspan(int x, int y, unsigned len, const color_type* colors)
-        {
-            realloc_span(len);
-            m_mask->fill_hspan(x, y, &m_span[0], len);
-            m_pixf->blend_color_hspan(x, y, len, colors, &m_span[0], cover_full);
-        }
-
-        //--------------------------------------------------------------------
-        void copy_color_vspan(int x, int y, unsigned len, const color_type* colors)
-        {
-            realloc_span(len);
-            m_mask->fill_vspan(x, y, &m_span[0], len);
-            m_pixf->blend_color_vspan(x, y, len, colors, &m_span[0], cover_full);
-        }
-
-        //--------------------------------------------------------------------
-        void blend_color_hspan(int x, int y,
-                               unsigned len, 
-                               const color_type* colors,
-                               const cover_type* covers,
-                               cover_type cover = cover_full)
-        {
-            if(covers) 
-            {
-                init_span(len, covers);
-                m_mask->combine_hspan(x, y, &m_span[0], len);
-            }
-            else
-            {
-                realloc_span(len);
-                m_mask->fill_hspan(x, y, &m_span[0], len);
-            }
-            m_pixf->blend_color_hspan(x, y, len, colors, &m_span[0], cover);
-        }
-
-
-        //--------------------------------------------------------------------
-        void blend_color_vspan(int x, int y,
-                               unsigned len, 
-                               const color_type* colors,
-                               const cover_type* covers,
-                               cover_type cover = cover_full)
-        {
-            if(covers) 
-            {
-                init_span(len, covers);
-                m_mask->combine_vspan(x, y, &m_span[0], len);
-            }
-            else
-            {
-                realloc_span(len);
-                m_mask->fill_vspan(x, y, &m_span[0], len);
-            }
-            m_pixf->blend_color_vspan(x, y, len, colors, &m_span[0], cover);
-        }
-
-    private:
-        pixfmt_type*          m_pixf;
-        const amask_type*     m_mask;
-        pod_array<cover_type> m_span;
-    };
-
-}
-
-#endif
-

Sources/libagg/agg-2.4/agg_pixfmt_gray.h

@@ -1,670 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// Adaptation for high precision colors has been sponsored by 
-// Liberty Technology Systems, Inc., visit http://lib-sys.com
-//
-// Liberty Technology Systems, Inc. is the provider of
-// PostScript and PDF technology for software developers.
-// 
-//----------------------------------------------------------------------------
-
-#ifndef AGG_PIXFMT_GRAY_INCLUDED
-#define AGG_PIXFMT_GRAY_INCLUDED
-
-#include <string.h>
-#include "agg_basics.h"
-#include "agg_color_gray.h"
-#include "agg_rendering_buffer.h"
-
-namespace agg
-{
- 
-    //============================================================blender_gray
-    template<class ColorT> struct blender_gray
-    {
-        typedef ColorT color_type;
-        typedef typename color_type::value_type value_type;
-        typedef typename color_type::calc_type calc_type;
-        enum base_scale_e { base_shift = color_type::base_shift };
-
-        static AGG_INLINE void blend_pix(value_type* p, unsigned cv, 
-                                         unsigned alpha, unsigned cover=0)
-        {
-            *p = (value_type)((((cv - calc_type(*p)) * alpha) + (calc_type(*p) << base_shift)) >> base_shift);
-        }
-    };
-
-
-    //======================================================blender_gray_pre
-    template<class ColorT> struct blender_gray_pre
-    {
-        typedef ColorT color_type;
-        typedef typename color_type::value_type value_type;
-        typedef typename color_type::calc_type calc_type;
-        enum base_scale_e { base_shift = color_type::base_shift };
-
-        static AGG_INLINE void blend_pix(value_type* p, unsigned cv,
-                                         unsigned alpha, unsigned cover)
-        {
-            alpha = color_type::base_mask - alpha;
-            cover = (cover + 1) << (base_shift - 8);
-            *p = (value_type)((*p * alpha + cv * cover) >> base_shift);
-        }
-
-        static AGG_INLINE void blend_pix(value_type* p, unsigned cv,
-                                         unsigned alpha)
-        {
-            *p = (value_type)(((*p * (color_type::base_mask - alpha)) >> base_shift) + cv);
-        }
-    };
-    
-
-
-    //=====================================================apply_gamma_dir_gray
-    template<class ColorT, class GammaLut> class apply_gamma_dir_gray
-    {
-    public:
-        typedef typename ColorT::value_type value_type;
-
-        apply_gamma_dir_gray(const GammaLut& gamma) : m_gamma(gamma) {}
-
-        AGG_INLINE void operator () (value_type* p)
-        {
-            *p = m_gamma.dir(*p);
-        }
-
-    private:
-        const GammaLut& m_gamma;
-    };
-
-
-
-    //=====================================================apply_gamma_inv_gray
-    template<class ColorT, class GammaLut> class apply_gamma_inv_gray
-    {
-    public:
-        typedef typename ColorT::value_type value_type;
-
-        apply_gamma_inv_gray(const GammaLut& gamma) : m_gamma(gamma) {}
-
-        AGG_INLINE void operator () (value_type* p)
-        {
-            *p = m_gamma.inv(*p);
-        }
-
-    private:
-        const GammaLut& m_gamma;
-    };
-
-
-
-    //=================================================pixfmt_alpha_blend_gray
-    template<class Blender, class RenBuf, unsigned Step=1, unsigned Offset=0>
-    class pixfmt_alpha_blend_gray
-    {
-    public:
-        typedef RenBuf   rbuf_type;
-        typedef typename rbuf_type::row_data row_data;
-        typedef Blender  blender_type;
-        typedef typename blender_type::color_type color_type;
-        typedef int                               order_type; // A fake one
-        typedef typename color_type::value_type   value_type;
-        typedef typename color_type::calc_type    calc_type;
-        enum base_scale_e 
-        {
-            base_shift = color_type::base_shift,
-            base_scale = color_type::base_scale,
-            base_mask  = color_type::base_mask,
-            pix_width  = sizeof(value_type),
-            pix_step   = Step,
-            pix_offset = Offset
-        };
-
-    private:
-        //--------------------------------------------------------------------
-        static AGG_INLINE void copy_or_blend_pix(value_type* p, 
-                                                 const color_type& c, 
-                                                 unsigned cover)
-        {
-            if (c.a)
-            {
-                calc_type alpha = (calc_type(c.a) * (cover + 1)) >> 8;
-                if(alpha == base_mask)
-                {
-                    *p = c.v;
-                }
-                else
-                {
-                    Blender::blend_pix(p, c.v, alpha, cover);
-                }
-            }
-        }
-
-
-        static AGG_INLINE void copy_or_blend_pix(value_type* p, 
-                                                 const color_type& c)
-        {
-            if (c.a)
-            {
-                if(c.a == base_mask)
-                {
-                    *p = c.v;
-                }
-                else
-                {
-                    Blender::blend_pix(p, c.v, c.a);
-                }
-            }
-        }
-
-
-    public:
-        //--------------------------------------------------------------------
-        explicit pixfmt_alpha_blend_gray(rbuf_type& rb) :
-            m_rbuf(&rb)
-        {}
-        void attach(rbuf_type& rb) { m_rbuf = &rb; }
-        //--------------------------------------------------------------------
-
-        template<class PixFmt>
-        bool attach(PixFmt& pixf, int x1, int y1, int x2, int y2)
-        {
-            rect_i r(x1, y1, x2, y2);
-            if(r.clip(rect_i(0, 0, pixf.width()-1, pixf.height()-1)))
-            {
-                int stride = pixf.stride();
-                m_rbuf->attach(pixf.pix_ptr(r.x1, stride < 0 ? r.y2 : r.y1), 
-                               (r.x2 - r.x1) + 1,
-                               (r.y2 - r.y1) + 1,
-                               stride);
-                return true;
-            }
-            return false;
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE unsigned width()  const { return m_rbuf->width();  }
-        AGG_INLINE unsigned height() const { return m_rbuf->height(); }
-        AGG_INLINE int      stride() const { return m_rbuf->stride(); }
-
-        //--------------------------------------------------------------------
-              int8u* row_ptr(int y)       { return m_rbuf->row_ptr(y); }
-        const int8u* row_ptr(int y) const { return m_rbuf->row_ptr(y); }
-        row_data     row(int y)     const { return m_rbuf->row(y); }
-
-        const int8u* pix_ptr(int x, int y) const
-        {
-            return m_rbuf->row_ptr(y) + x * Step + Offset;
-        }
-
-        int8u* pix_ptr(int x, int y)
-        {
-            return m_rbuf->row_ptr(y) + x * Step + Offset;
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE static void make_pix(int8u* p, const color_type& c)
-        {
-            *(value_type*)p = c.v;
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE color_type pixel(int x, int y) const
-        {
-            value_type* p = (value_type*)m_rbuf->row_ptr(y) + x * Step + Offset;
-            return color_type(*p);
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE void copy_pixel(int x, int y, const color_type& c)
-        {
-            *((value_type*)m_rbuf->row_ptr(x, y, 1) + x * Step + Offset) = c.v;
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE void blend_pixel(int x, int y, const color_type& c, int8u cover)
-        {
-            copy_or_blend_pix((value_type*)
-                               m_rbuf->row_ptr(x, y, 1) + x * Step + Offset, 
-                               c, 
-                               cover);
-        }
-
-
-        //--------------------------------------------------------------------
-        AGG_INLINE void copy_hline(int x, int y, 
-                                   unsigned len, 
-                                   const color_type& c)
-        {
-            value_type* p = (value_type*)
-                m_rbuf->row_ptr(x, y, len) + x * Step + Offset;
-
-            do
-            {
-                *p = c.v; 
-                p += Step;
-            }
-            while(--len);
-        }
-
-
-        //--------------------------------------------------------------------
-        AGG_INLINE void copy_vline(int x, int y,
-                                   unsigned len, 
-                                   const color_type& c)
-        {
-            do
-            {
-                value_type* p = (value_type*)
-                    m_rbuf->row_ptr(x, y++, 1) + x * Step + Offset;
-
-                *p = c.v;
-            }
-            while(--len);
-        }
-
-
-        //--------------------------------------------------------------------
-        void blend_hline(int x, int y,
-                         unsigned len, 
-                         const color_type& c,
-                         int8u cover)
-        {
-            if (c.a)
-            {
-                value_type* p = (value_type*)
-                    m_rbuf->row_ptr(x, y, len) + x * Step + Offset;
-
-                calc_type alpha = (calc_type(c.a) * (cover + 1)) >> 8;
-                if(alpha == base_mask)
-                {
-                    do
-                    {
-                        *p = c.v; 
-                        p += Step;
-                    }
-                    while(--len);
-                }
-                else
-                {
-                    do
-                    {
-                        Blender::blend_pix(p, c.v, alpha, cover);
-                        p += Step;
-                    }
-                    while(--len);
-                }
-            }
-        }
-
-
-        //--------------------------------------------------------------------
-        void blend_vline(int x, int y,
-                         unsigned len, 
-                         const color_type& c,
-                         int8u cover)
-        {
-            if (c.a)
-            {
-                value_type* p;
-                calc_type alpha = (calc_type(c.a) * (cover + 1)) >> 8;
-                if(alpha == base_mask)
-                {
-                    do
-                    {
-                        p = (value_type*)
-                            m_rbuf->row_ptr(x, y++, 1) + x * Step + Offset;
-
-                        *p = c.v; 
-                    }
-                    while(--len);
-                }
-                else
-                {
-                    do
-                    {
-                        p = (value_type*)
-                            m_rbuf->row_ptr(x, y++, 1) + x * Step + Offset;
-
-                        Blender::blend_pix(p, c.v, alpha, cover);
-                    }
-                    while(--len);
-                }
-            }
-        }
-
-
-        //--------------------------------------------------------------------
-        void blend_solid_hspan(int x, int y,
-                               unsigned len, 
-                               const color_type& c,
-                               const int8u* covers)
-        {
-            if (c.a)
-            {
-                value_type* p = (value_type*)
-                    m_rbuf->row_ptr(x, y, len) + x * Step + Offset;
-
-                do 
-                {
-                    calc_type alpha = (calc_type(c.a) * (calc_type(*covers) + 1)) >> 8;
-                    if(alpha == base_mask)
-                    {
-                        *p = c.v;
-                    }
-                    else
-                    {
-                        Blender::blend_pix(p, c.v, alpha, *covers);
-                    }
-                    p += Step;
-                    ++covers;
-                }
-                while(--len);
-            }
-        }
-
-
-        //--------------------------------------------------------------------
-        void blend_solid_vspan(int x, int y,
-                               unsigned len, 
-                               const color_type& c,
-                               const int8u* covers)
-        {
-            if (c.a)
-            {
-                do 
-                {
-                    calc_type alpha = (calc_type(c.a) * (calc_type(*covers) + 1)) >> 8;
-
-                    value_type* p = (value_type*)
-                        m_rbuf->row_ptr(x, y++, 1) + x * Step + Offset;
-
-                    if(alpha == base_mask)
-                    {
-                        *p = c.v;
-                    }
-                    else
-                    {
-                        Blender::blend_pix(p, c.v, alpha, *covers);
-                    }
-                    ++covers;
-                }
-                while(--len);
-            }
-        }
-
-
-        //--------------------------------------------------------------------
-        void copy_color_hspan(int x, int y,
-                              unsigned len, 
-                              const color_type* colors)
-        {
-            value_type* p = (value_type*)
-                m_rbuf->row_ptr(x, y, len) + x * Step + Offset;
-
-            do 
-            {
-                *p = colors->v;
-                p += Step;
-                ++colors;
-            }
-            while(--len);
-        }
-
-
-        //--------------------------------------------------------------------
-        void copy_color_vspan(int x, int y,
-                              unsigned len, 
-                              const color_type* colors)
-        {
-            do 
-            {
-                value_type* p = (value_type*)
-                    m_rbuf->row_ptr(x, y++, 1) + x * Step + Offset;
-                *p = colors->v;
-                ++colors;
-            }
-            while(--len);
-        }
-
-
-        //--------------------------------------------------------------------
-        void blend_color_hspan(int x, int y,
-                               unsigned len, 
-                               const color_type* colors,
-                               const int8u* covers,
-                               int8u cover)
-        {
-            value_type* p = (value_type*)
-                m_rbuf->row_ptr(x, y, len) + x * Step + Offset;
-
-            if(covers)
-            {
-                do 
-                {
-                    copy_or_blend_pix(p, *colors++, *covers++);
-                    p += Step;
-                }
-                while(--len);
-            }
-            else
-            {
-                if(cover == 255)
-                {
-                    do 
-                    {
-                        if(colors->a == base_mask)
-                        {
-                            *p = colors->v;
-                        }
-                        else
-                        {
-                            copy_or_blend_pix(p, *colors);
-                        }
-                        p += Step;
-                        ++colors;
-                    }
-                    while(--len);
-                }
-                else
-                {
-                    do 
-                    {
-                        copy_or_blend_pix(p, *colors++, cover);
-                        p += Step;
-                    }
-                    while(--len);
-                }
-            }
-        }
-
-
-
-        //--------------------------------------------------------------------
-        void blend_color_vspan(int x, int y,
-                               unsigned len, 
-                               const color_type* colors,
-                               const int8u* covers,
-                               int8u cover)
-        {
-            value_type* p;
-            if(covers)
-            {
-                do 
-                {
-                    p = (value_type*)
-                        m_rbuf->row_ptr(x, y++, 1) + x * Step + Offset;
-
-                    copy_or_blend_pix(p, *colors++, *covers++);
-                }
-                while(--len);
-            }
-            else
-            {
-                if(cover == 255)
-                {
-                    do 
-                    {
-                        p = (value_type*)
-                            m_rbuf->row_ptr(x, y++, 1) + x * Step + Offset;
-
-                        if(colors->a == base_mask)
-                        {
-                            *p = colors->v;
-                        }
-                        else
-                        {
-                            copy_or_blend_pix(p, *colors);
-                        }
-                        ++colors;
-                    }
-                    while(--len);
-                }
-                else
-                {
-                    do 
-                    {
-                        p = (value_type*)
-                            m_rbuf->row_ptr(x, y++, 1) + x * Step + Offset;
-
-                        copy_or_blend_pix(p, *colors++, cover);
-                    }
-                    while(--len);
-                }
-            }
-        }
-
-        //--------------------------------------------------------------------
-        template<class Function> void for_each_pixel(Function f)
-        {
-            unsigned y;
-            for(y = 0; y < height(); ++y)
-            {
-                row_data r = m_rbuf->row(y);
-                if(r.ptr)
-                {
-                    unsigned len = r.x2 - r.x1 + 1;
-
-                    value_type* p = (value_type*)
-                        m_rbuf->row_ptr(r.x1, y, len) + r.x1 * Step + Offset;
-
-                    do
-                    {
-                        f(p);
-                        p += Step;
-                    }
-                    while(--len);
-                }
-            }
-        }
-
-        //--------------------------------------------------------------------
-        template<class GammaLut> void apply_gamma_dir(const GammaLut& g)
-        {
-            for_each_pixel(apply_gamma_dir_gray<color_type, GammaLut>(g));
-        }
-
-        //--------------------------------------------------------------------
-        template<class GammaLut> void apply_gamma_inv(const GammaLut& g)
-        {
-            for_each_pixel(apply_gamma_inv_gray<color_type, GammaLut>(g));
-        }
-
-        //--------------------------------------------------------------------
-        template<class RenBuf2>
-        void copy_from(const RenBuf2& from, 
-                       int xdst, int ydst,
-                       int xsrc, int ysrc,
-                       unsigned len)
-        {
-            const int8u* p = from.row_ptr(ysrc);
-            if(p)
-            {
-                memmove(m_rbuf->row_ptr(xdst, ydst, len) + xdst * pix_width, 
-                        p + xsrc * pix_width, 
-                        len * pix_width);
-            }
-        }
-
-        //--------------------------------------------------------------------
-        template<class SrcPixelFormatRenderer>
-        void blend_from_color(const SrcPixelFormatRenderer& from, 
-                              const color_type& color,
-                              int xdst, int ydst,
-                              int xsrc, int ysrc,
-                              unsigned len,
-                              int8u cover)
-        {
-            typedef typename SrcPixelFormatRenderer::value_type src_value_type;
-            const src_value_type* psrc = (src_value_type*)from.row_ptr(ysrc);
-            if(psrc)
-            {
-                value_type* pdst = 
-                    (value_type*)m_rbuf->row_ptr(xdst, ydst, len) + xdst;
-                do 
-                {
-                    copy_or_blend_pix(pdst, 
-                                      color, 
-                                      (*psrc * cover + base_mask) >> base_shift);
-                    ++psrc;
-                    ++pdst;
-                }
-                while(--len);
-            }
-        }
-
-        //--------------------------------------------------------------------
-        template<class SrcPixelFormatRenderer>
-        void blend_from_lut(const SrcPixelFormatRenderer& from, 
-                            const color_type* color_lut,
-                            int xdst, int ydst,
-                            int xsrc, int ysrc,
-                            unsigned len,
-                            int8u cover)
-        {
-            typedef typename SrcPixelFormatRenderer::value_type src_value_type;
-            const src_value_type* psrc = (src_value_type*)from.row_ptr(ysrc);
-            if(psrc)
-            {
-                value_type* pdst = 
-                    (value_type*)m_rbuf->row_ptr(xdst, ydst, len) + xdst;
-                do 
-                {
-                    copy_or_blend_pix(pdst, color_lut[*psrc], cover);
-                    ++psrc;
-                    ++pdst;
-                }
-                while(--len);
-            }
-        }
-
-    private:
-        rbuf_type* m_rbuf;
-    };
-
-    typedef blender_gray<gray8>      blender_gray8;
-    typedef blender_gray_pre<gray8>  blender_gray8_pre;
-    typedef blender_gray<gray16>     blender_gray16;
-    typedef blender_gray_pre<gray16> blender_gray16_pre;
-
-    typedef pixfmt_alpha_blend_gray<blender_gray8,      rendering_buffer> pixfmt_gray8;      //----pixfmt_gray8
-    typedef pixfmt_alpha_blend_gray<blender_gray8_pre,  rendering_buffer> pixfmt_gray8_pre;  //----pixfmt_gray8_pre
-    typedef pixfmt_alpha_blend_gray<blender_gray16,     rendering_buffer> pixfmt_gray16;     //----pixfmt_gray16
-    typedef pixfmt_alpha_blend_gray<blender_gray16_pre, rendering_buffer> pixfmt_gray16_pre; //----pixfmt_gray16_pre
-}
-
-#endif
-

Sources/libagg/agg-2.4/agg_pixfmt_rgb.h

@@ -1,860 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// Adaptation for high precision colors has been sponsored by 
-// Liberty Technology Systems, Inc., visit http://lib-sys.com
-//
-// Liberty Technology Systems, Inc. is the provider of
-// PostScript and PDF technology for software developers.
-// 
-//----------------------------------------------------------------------------
-
-#ifndef AGG_PIXFMT_RGB_INCLUDED
-#define AGG_PIXFMT_RGB_INCLUDED
-
-#include <string.h>
-#include "agg_basics.h"
-#include "agg_color_rgba.h"
-#include "agg_rendering_buffer.h"
-
-namespace agg
-{
-
-    //=====================================================apply_gamma_dir_rgb
-    template<class ColorT, class Order, class GammaLut> class apply_gamma_dir_rgb
-    {
-    public:
-        typedef typename ColorT::value_type value_type;
-
-        apply_gamma_dir_rgb(const GammaLut& gamma) : m_gamma(gamma) {}
-
-        AGG_INLINE void operator () (value_type* p)
-        {
-            p[Order::R] = m_gamma.dir(p[Order::R]);
-            p[Order::G] = m_gamma.dir(p[Order::G]);
-            p[Order::B] = m_gamma.dir(p[Order::B]);
-        }
-
-    private:
-        const GammaLut& m_gamma;
-    };
-
-
-
-    //=====================================================apply_gamma_inv_rgb
-    template<class ColorT, class Order, class GammaLut> class apply_gamma_inv_rgb
-    {
-    public:
-        typedef typename ColorT::value_type value_type;
-
-        apply_gamma_inv_rgb(const GammaLut& gamma) : m_gamma(gamma) {}
-
-        AGG_INLINE void operator () (value_type* p)
-        {
-            p[Order::R] = m_gamma.inv(p[Order::R]);
-            p[Order::G] = m_gamma.inv(p[Order::G]);
-            p[Order::B] = m_gamma.inv(p[Order::B]);
-        }
-
-    private:
-        const GammaLut& m_gamma;
-    };
-
-
-    //=========================================================blender_rgb
-    template<class ColorT, class Order> struct blender_rgb
-    {
-        typedef ColorT color_type;
-        typedef Order order_type;
-        typedef typename color_type::value_type value_type;
-        typedef typename color_type::calc_type calc_type;
-        enum base_scale_e { base_shift = color_type::base_shift };
-
-        //--------------------------------------------------------------------
-        static AGG_INLINE void blend_pix(value_type* p, 
-                                         unsigned cr, unsigned cg, unsigned cb, 
-                                         unsigned alpha, 
-                                         unsigned cover=0)
-        {
-            p[Order::R] += (value_type)(((cr - p[Order::R]) * alpha) >> base_shift);
-            p[Order::G] += (value_type)(((cg - p[Order::G]) * alpha) >> base_shift);
-            p[Order::B] += (value_type)(((cb - p[Order::B]) * alpha) >> base_shift);
-        }
-    };
-
-
-    //======================================================blender_rgb_pre
-    template<class ColorT, class Order> struct blender_rgb_pre
-    {
-        typedef ColorT color_type;
-        typedef Order order_type;
-        typedef typename color_type::value_type value_type;
-        typedef typename color_type::calc_type calc_type;
-        enum base_scale_e { base_shift = color_type::base_shift };
-
-        //--------------------------------------------------------------------
-        static AGG_INLINE void blend_pix(value_type* p, 
-                                         unsigned cr, unsigned cg, unsigned cb,
-                                         unsigned alpha,
-                                         unsigned cover)
-        {
-            alpha = color_type::base_mask - alpha;
-            cover = (cover + 1) << (base_shift - 8);
-            p[Order::R] = (value_type)((p[Order::R] * alpha + cr * cover) >> base_shift);
-            p[Order::G] = (value_type)((p[Order::G] * alpha + cg * cover) >> base_shift);
-            p[Order::B] = (value_type)((p[Order::B] * alpha + cb * cover) >> base_shift);
-        }
-
-        //--------------------------------------------------------------------
-        static AGG_INLINE void blend_pix(value_type* p, 
-                                         unsigned cr, unsigned cg, unsigned cb,
-                                         unsigned alpha)
-        {
-            alpha = color_type::base_mask - alpha;
-            p[Order::R] = (value_type)(((p[Order::R] * alpha) >> base_shift) + cr);
-            p[Order::G] = (value_type)(((p[Order::G] * alpha) >> base_shift) + cg);
-            p[Order::B] = (value_type)(((p[Order::B] * alpha) >> base_shift) + cb);
-        }
-
-    };
-
-
-
-    //===================================================blender_rgb_gamma
-    template<class ColorT, class Order, class Gamma> class blender_rgb_gamma
-    {
-    public:
-        typedef ColorT color_type;
-        typedef Order order_type;
-        typedef Gamma gamma_type;
-        typedef typename color_type::value_type value_type;
-        typedef typename color_type::calc_type calc_type;
-        enum base_scale_e { base_shift = color_type::base_shift };
-
-        //--------------------------------------------------------------------
-        blender_rgb_gamma() : m_gamma(0) {}
-        void gamma(const gamma_type& g) { m_gamma = &g; }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE void blend_pix(value_type* p, 
-                                  unsigned cr, unsigned cg, unsigned cb,
-                                  unsigned alpha, 
-                                  unsigned cover=0)
-        {
-            calc_type r = m_gamma->dir(p[Order::R]);
-            calc_type g = m_gamma->dir(p[Order::G]);
-            calc_type b = m_gamma->dir(p[Order::B]);
-            p[Order::R] = m_gamma->inv((((m_gamma->dir(cr) - r) * alpha) >> base_shift) + r);
-            p[Order::G] = m_gamma->inv((((m_gamma->dir(cg) - g) * alpha) >> base_shift) + g);
-            p[Order::B] = m_gamma->inv((((m_gamma->dir(cb) - b) * alpha) >> base_shift) + b);
-        }
-
-    private:
-        const gamma_type* m_gamma;
-    };
-
-
-
-    
-    //==================================================pixfmt_alpha_blend_rgb
-    template<class Blender, class RenBuf> class pixfmt_alpha_blend_rgb
-    {
-    public:
-        typedef RenBuf   rbuf_type;
-        typedef Blender  blender_type;
-        typedef typename rbuf_type::row_data row_data;
-        typedef typename blender_type::color_type color_type;
-        typedef typename blender_type::order_type order_type;
-        typedef typename color_type::value_type value_type;
-        typedef typename color_type::calc_type calc_type;
-        enum base_scale_e 
-        {
-            base_shift = color_type::base_shift,
-            base_scale = color_type::base_scale,
-            base_mask  = color_type::base_mask,
-            pix_width  = sizeof(value_type) * 3
-        };
-
-    private:
-        //--------------------------------------------------------------------
-        AGG_INLINE void copy_or_blend_pix(value_type* p, 
-                                          const color_type& c, 
-                                          unsigned cover)
-        {
-            if (c.a)
-            {
-                calc_type alpha = (calc_type(c.a) * (cover + 1)) >> 8;
-                if(alpha == base_mask)
-                {
-                    p[order_type::R] = c.r;
-                    p[order_type::G] = c.g;
-                    p[order_type::B] = c.b;
-                }
-                else
-                {
-                    m_blender.blend_pix(p, c.r, c.g, c.b, alpha, cover);
-                }
-            }
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE void copy_or_blend_pix(value_type* p, 
-                                          const color_type& c)
-        {
-            if (c.a)
-            {
-                if(c.a == base_mask)
-                {
-                    p[order_type::R] = c.r;
-                    p[order_type::G] = c.g;
-                    p[order_type::B] = c.b;
-                }
-                else
-                {
-                    m_blender.blend_pix(p, c.r, c.g, c.b, c.a);
-                }
-            }
-        }
-
-
-    public:
-        //--------------------------------------------------------------------
-        explicit pixfmt_alpha_blend_rgb(rbuf_type& rb) :
-            m_rbuf(&rb)
-        {}
-        void attach(rbuf_type& rb) { m_rbuf = &rb; }
-
-        //--------------------------------------------------------------------
-        template<class PixFmt>
-        bool attach(PixFmt& pixf, int x1, int y1, int x2, int y2)
-        {
-            rect_i r(x1, y1, x2, y2);
-            if(r.clip(rect_i(0, 0, pixf.width()-1, pixf.height()-1)))
-            {
-                int stride = pixf.stride();
-                m_rbuf->attach(pixf.pix_ptr(r.x1, stride < 0 ? r.y2 : r.y1), 
-                               (r.x2 - r.x1) + 1,
-                               (r.y2 - r.y1) + 1,
-                               stride);
-                return true;
-            }
-            return false;
-        }
-
-        //--------------------------------------------------------------------
-        Blender& blender() { return m_blender; }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE unsigned width()  const { return m_rbuf->width();  }
-        AGG_INLINE unsigned height() const { return m_rbuf->height(); }
-        AGG_INLINE int      stride() const { return m_rbuf->stride(); }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE       int8u* row_ptr(int y)       { return m_rbuf->row_ptr(y); }
-        AGG_INLINE const int8u* row_ptr(int y) const { return m_rbuf->row_ptr(y); }
-        AGG_INLINE row_data     row(int y)     const { return m_rbuf->row(y); }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE int8u* pix_ptr(int x, int y) 
-        { 
-            return m_rbuf->row_ptr(y) + x * pix_width; 
-        }
-
-        AGG_INLINE const int8u* pix_ptr(int x, int y) const 
-        { 
-            return m_rbuf->row_ptr(y) + x * pix_width; 
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE static void make_pix(int8u* p, const color_type& c)
-        {
-            ((value_type*)p)[order_type::R] = c.r;
-            ((value_type*)p)[order_type::G] = c.g;
-            ((value_type*)p)[order_type::B] = c.b;
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE color_type pixel(int x, int y) const
-        {
-            value_type* p = (value_type*)m_rbuf->row_ptr(y) + x + x + x;
-            return color_type(p[order_type::R], 
-                              p[order_type::G], 
-                              p[order_type::B]);
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE void copy_pixel(int x, int y, const color_type& c)
-        {
-            value_type* p = (value_type*)m_rbuf->row_ptr(x, y, 1) + x + x + x;
-            p[order_type::R] = c.r;
-            p[order_type::G] = c.g;
-            p[order_type::B] = c.b;
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE void blend_pixel(int x, int y, const color_type& c, int8u cover)
-        {
-            copy_or_blend_pix((value_type*)m_rbuf->row_ptr(x, y, 1) + x + x + x, c, cover);
-        }
-
-
-        //--------------------------------------------------------------------
-        AGG_INLINE void copy_hline(int x, int y, 
-                                   unsigned len, 
-                                   const color_type& c)
-        {
-            value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + x + x + x;
-            do
-            {
-                p[order_type::R] = c.r; 
-                p[order_type::G] = c.g; 
-                p[order_type::B] = c.b;
-                p += 3;
-            }
-            while(--len);
-        }
-
-
-        //--------------------------------------------------------------------
-        AGG_INLINE void copy_vline(int x, int y,
-                                   unsigned len, 
-                                   const color_type& c)
-        {
-            do
-            {
-                value_type* p = (value_type*)
-                    m_rbuf->row_ptr(x, y++, 1) + x + x + x;
-                p[order_type::R] = c.r; 
-                p[order_type::G] = c.g; 
-                p[order_type::B] = c.b;
-            }
-            while(--len);
-        }
-
-
-        //--------------------------------------------------------------------
-        void blend_hline(int x, int y,
-                         unsigned len, 
-                         const color_type& c,
-                         int8u cover)
-        {
-            if (c.a)
-            {
-                value_type* p = (value_type*)
-                    m_rbuf->row_ptr(x, y, len) + x + x + x;
-
-                calc_type alpha = (calc_type(c.a) * (calc_type(cover) + 1)) >> 8;
-                if(alpha == base_mask)
-                {
-                    do
-                    {
-                        p[order_type::R] = c.r; 
-                        p[order_type::G] = c.g; 
-                        p[order_type::B] = c.b;
-                        p += 3;
-                    }
-                    while(--len);
-                }
-                else
-                {
-                    do
-                    {
-                        m_blender.blend_pix(p, c.r, c.g, c.b, alpha, cover);
-                        p += 3;
-                    }
-                    while(--len);
-                }
-            }
-        }
-
-
-        //--------------------------------------------------------------------
-        void blend_vline(int x, int y,
-                         unsigned len, 
-                         const color_type& c,
-                         int8u cover)
-        {
-            if (c.a)
-            {
-                value_type* p;
-                calc_type alpha = (calc_type(c.a) * (cover + 1)) >> 8;
-                if(alpha == base_mask)
-                {
-                    do
-                    {
-                        p = (value_type*)
-                            m_rbuf->row_ptr(x, y++, 1) + x + x + x;
-
-                        p[order_type::R] = c.r; 
-                        p[order_type::G] = c.g; 
-                        p[order_type::B] = c.b;
-                    }
-                    while(--len);
-                }
-                else
-                {
-                    do
-                    {
-                        p = (value_type*)
-                            m_rbuf->row_ptr(x, y++, 1) + x + x + x;
-
-                        m_blender.blend_pix(p, c.r, c.g, c.b, alpha, cover);
-                    }
-                    while(--len);
-                }
-            }
-        }
-
-
-        //--------------------------------------------------------------------
-        void blend_solid_hspan(int x, int y,
-                               unsigned len, 
-                               const color_type& c,
-                               const int8u* covers)
-        {
-            if (c.a)
-            {
-                value_type* p = (value_type*)
-                    m_rbuf->row_ptr(x, y, len) + x + x + x;
-
-                do 
-                {
-                    calc_type alpha = (calc_type(c.a) * (calc_type(*covers) + 1)) >> 8;
-                    if(alpha == base_mask)
-                    {
-                        p[order_type::R] = c.r;
-                        p[order_type::G] = c.g;
-                        p[order_type::B] = c.b;
-                    }
-                    else
-                    {
-                        m_blender.blend_pix(p, c.r, c.g, c.b, alpha, *covers);
-                    }
-                    p += 3;
-                    ++covers;
-                }
-                while(--len);
-            }
-        }
-
-
-        //--------------------------------------------------------------------
-        void blend_solid_vspan(int x, int y,
-                               unsigned len, 
-                               const color_type& c,
-                               const int8u* covers)
-        {
-            if (c.a)
-            {
-                do 
-                {
-                    value_type* p = (value_type*)
-                        m_rbuf->row_ptr(x, y++, 1) + x + x + x;
-
-                    calc_type alpha = (calc_type(c.a) * (calc_type(*covers) + 1)) >> 8;
-                    if(alpha == base_mask)
-                    {
-                        p[order_type::R] = c.r;
-                        p[order_type::G] = c.g;
-                        p[order_type::B] = c.b;
-                    }
-                    else
-                    {
-                        m_blender.blend_pix(p, c.r, c.g, c.b, alpha, *covers);
-                    }
-                    ++covers;
-                }
-                while(--len);
-            }
-        }
-
-
-        //--------------------------------------------------------------------
-        void copy_color_hspan(int x, int y,
-                              unsigned len, 
-                              const color_type* colors)
-        {
-            value_type* p = (value_type*)
-                m_rbuf->row_ptr(x, y, len) + x + x + x;
-
-            do 
-            {
-                p[order_type::R] = colors->r;
-                p[order_type::G] = colors->g;
-                p[order_type::B] = colors->b;
-                ++colors;
-                p += 3;
-            }
-            while(--len);
-        }
-
-
-        //--------------------------------------------------------------------
-        void copy_color_vspan(int x, int y,
-                              unsigned len, 
-                              const color_type* colors)
-        {
-            do 
-            {
-                value_type* p = (value_type*)
-                    m_rbuf->row_ptr(x, y++, 1) + x + x + x;
-                p[order_type::R] = colors->r;
-                p[order_type::G] = colors->g;
-                p[order_type::B] = colors->b;
-                ++colors;
-            }
-            while(--len);
-        }
-
-
-        //--------------------------------------------------------------------
-        void blend_color_hspan(int x, int y,
-                               unsigned len, 
-                               const color_type* colors,
-                               const int8u* covers,
-                               int8u cover)
-        {
-            value_type* p = (value_type*)
-                m_rbuf->row_ptr(x, y, len) + x + x + x;
-
-            if(covers)
-            {
-                do 
-                {
-                    copy_or_blend_pix(p, *colors++, *covers++);
-                    p += 3;
-                }
-                while(--len);
-            }
-            else
-            {
-                if(cover == 255)
-                {
-                    do 
-                    {
-                        copy_or_blend_pix(p, *colors++);
-                        p += 3;
-                    }
-                    while(--len);
-                }
-                else
-                {
-                    do 
-                    {
-                        copy_or_blend_pix(p, *colors++, cover);
-                        p += 3;
-                    }
-                    while(--len);
-                }
-            }
-        }
-
-
-
-        //--------------------------------------------------------------------
-        void blend_color_vspan(int x, int y,
-                               unsigned len, 
-                               const color_type* colors,
-                               const int8u* covers,
-                               int8u cover)
-        {
-            value_type* p;
-            if(covers)
-            {
-                do 
-                {
-                    p = (value_type*)
-                        m_rbuf->row_ptr(x, y++, 1) + x + x + x;
-
-                    copy_or_blend_pix(p, *colors++, *covers++);
-                }
-                while(--len);
-            }
-            else
-            {
-                if(cover == 255)
-                {
-                    do 
-                    {
-                        p = (value_type*)
-                            m_rbuf->row_ptr(x, y++, 1) + x + x + x;
-
-                        copy_or_blend_pix(p, *colors++);
-                    }
-                    while(--len);
-                }
-                else
-                {
-                    do 
-                    {
-                        p = (value_type*)
-                            m_rbuf->row_ptr(x, y++, 1) + x + x + x;
-
-                        copy_or_blend_pix(p, *colors++, cover);
-                    }
-                    while(--len);
-                }
-            }
-        }
-
-        //--------------------------------------------------------------------
-        template<class Function> void for_each_pixel(Function f)
-        {
-            unsigned y;
-            for(y = 0; y < height(); ++y)
-            {
-                row_data r = m_rbuf->row(y);
-                if(r.ptr)
-                {
-                    unsigned len = r.x2 - r.x1 + 1;
-                    value_type* p = (value_type*)
-                        m_rbuf->row_ptr(r.x1, y, len) + r.x1 * 3;
-                    do
-                    {
-                        f(p);
-                        p += 3;
-                    }
-                    while(--len);
-                }
-            }
-        }
-
-        //--------------------------------------------------------------------
-        template<class GammaLut> void apply_gamma_dir(const GammaLut& g)
-        {
-            for_each_pixel(apply_gamma_dir_rgb<color_type, order_type, GammaLut>(g));
-        }
-
-        //--------------------------------------------------------------------
-        template<class GammaLut> void apply_gamma_inv(const GammaLut& g)
-        {
-            for_each_pixel(apply_gamma_inv_rgb<color_type, order_type, GammaLut>(g));
-        }
-
-        //--------------------------------------------------------------------
-        template<class RenBuf2>
-        void copy_from(const RenBuf2& from, 
-                       int xdst, int ydst,
-                       int xsrc, int ysrc,
-                       unsigned len)
-        {
-            const int8u* p = from.row_ptr(ysrc);
-            if(p)
-            {
-                memmove(m_rbuf->row_ptr(xdst, ydst, len) + xdst * pix_width, 
-                        p + xsrc * pix_width, 
-                        len * pix_width);
-            }
-        }
-
-
-        //--------------------------------------------------------------------
-        template<class SrcPixelFormatRenderer>
-        void blend_from(const SrcPixelFormatRenderer& from, 
-                        int xdst, int ydst,
-                        int xsrc, int ysrc,
-                        unsigned len,
-                        int8u cover)
-        {
-            typedef typename SrcPixelFormatRenderer::order_type src_order;
-
-            const value_type* psrc = (const value_type*)from.row_ptr(ysrc);
-            if(psrc)
-            {
-                psrc += xsrc * 4;
-                value_type* pdst = 
-                    (value_type*)m_rbuf->row_ptr(xdst, ydst, len) + xdst * 3;   
-
-                if(cover == 255)
-                {
-                    do 
-                    {
-                        value_type alpha = psrc[src_order::A];
-                        if(alpha)
-                        {
-                            if(alpha == base_mask)
-                            {
-                                pdst[order_type::R] = psrc[src_order::R];
-                                pdst[order_type::G] = psrc[src_order::G];
-                                pdst[order_type::B] = psrc[src_order::B];
-                            }
-                            else
-                            {
-                                m_blender.blend_pix(pdst, 
-                                                    psrc[src_order::R],
-                                                    psrc[src_order::G],
-                                                    psrc[src_order::B],
-                                                    alpha);
-                            }
-                        }
-                        psrc += 4;
-                        pdst += 3;
-                    }
-                    while(--len);
-                }
-                else
-                {
-                    color_type color;
-                    do 
-                    {
-                        color.r = psrc[src_order::R];
-                        color.g = psrc[src_order::G];
-                        color.b = psrc[src_order::B];
-                        color.a = psrc[src_order::A];
-                        copy_or_blend_pix(pdst, color, cover);
-                        psrc += 4;
-                        pdst += 3;
-                    }
-                    while(--len);
-                }
-            }
-        }
-
-        //--------------------------------------------------------------------
-        template<class SrcPixelFormatRenderer>
-        void blend_from_color(const SrcPixelFormatRenderer& from, 
-                              const color_type& color,
-                              int xdst, int ydst,
-                              int xsrc, int ysrc,
-                              unsigned len,
-                              int8u cover)
-        {
-            typedef typename SrcPixelFormatRenderer::value_type src_value_type;
-            const src_value_type* psrc = (src_value_type*)from.row_ptr(ysrc);
-            if(psrc)
-            {
-                value_type* pdst = 
-                    (value_type*)m_rbuf->row_ptr(xdst, ydst, len) + xdst * 3;
-                do 
-                {
-                    copy_or_blend_pix(pdst, 
-                                      color, 
-                                      (*psrc * cover + base_mask) >> base_shift);
-                    ++psrc;
-                    pdst += 3;
-                }
-                while(--len);
-            }
-        }
-
-        //--------------------------------------------------------------------
-        template<class SrcPixelFormatRenderer>
-        void blend_from_lut(const SrcPixelFormatRenderer& from, 
-                            const color_type* color_lut,
-                            int xdst, int ydst,
-                            int xsrc, int ysrc,
-                            unsigned len,
-                            int8u cover)
-        {
-            typedef typename SrcPixelFormatRenderer::value_type src_value_type;
-            const src_value_type* psrc = (src_value_type*)from.row_ptr(ysrc);
-            if(psrc)
-            {
-                value_type* pdst = 
-                    (value_type*)m_rbuf->row_ptr(xdst, ydst, len) + xdst * 3;
-
-                if(cover == 255)
-                {
-                    do 
-                    {
-                        const color_type& color = color_lut[*psrc];
-                        m_blender.blend_pix(pdst, 
-                                            color.r, color.g, color.b, color.a);
-                        ++psrc;
-                        pdst += 3;
-                    }
-                    while(--len);
-                }
-                else
-                {
-                    do 
-                    {
-                        copy_or_blend_pix(pdst, color_lut[*psrc], cover);
-                        ++psrc;
-                        pdst += 3;
-                    }
-                    while(--len);
-                }
-            }
-        }
-
-    private:
-        rbuf_type* m_rbuf;
-        Blender    m_blender;
-    };
-
-    typedef pixfmt_alpha_blend_rgb<blender_rgb<rgba8,  order_rgb>, rendering_buffer> pixfmt_rgb24;    //----pixfmt_rgb24
-    typedef pixfmt_alpha_blend_rgb<blender_rgb<rgba8,  order_bgr>, rendering_buffer> pixfmt_bgr24;    //----pixfmt_bgr24
-    typedef pixfmt_alpha_blend_rgb<blender_rgb<rgba16, order_rgb>, rendering_buffer> pixfmt_rgb48;    //----pixfmt_rgb48
-    typedef pixfmt_alpha_blend_rgb<blender_rgb<rgba16, order_bgr>, rendering_buffer> pixfmt_bgr48;    //----pixfmt_bgr48
-
-    typedef pixfmt_alpha_blend_rgb<blender_rgb_pre<rgba8,  order_rgb>, rendering_buffer> pixfmt_rgb24_pre; //----pixfmt_rgb24_pre
-    typedef pixfmt_alpha_blend_rgb<blender_rgb_pre<rgba8,  order_bgr>, rendering_buffer> pixfmt_bgr24_pre; //----pixfmt_bgr24_pre
-    typedef pixfmt_alpha_blend_rgb<blender_rgb_pre<rgba16, order_rgb>, rendering_buffer> pixfmt_rgb48_pre; //----pixfmt_rgb48_pre
-    typedef pixfmt_alpha_blend_rgb<blender_rgb_pre<rgba16, order_bgr>, rendering_buffer> pixfmt_bgr48_pre; //----pixfmt_bgr48_pre
-
-    //-----------------------------------------------------pixfmt_rgb24_gamma
-    template<class Gamma> class pixfmt_rgb24_gamma : 
-    public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_rgb, Gamma>, rendering_buffer>
-    {
-    public:
-        pixfmt_rgb24_gamma(rendering_buffer& rb, const Gamma& g) :
-            pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_rgb, Gamma>, rendering_buffer>(rb) 
-        {
-            this->blender().gamma(g);
-        }
-    };
-        
-    //-----------------------------------------------------pixfmt_bgr24_gamma
-    template<class Gamma> class pixfmt_bgr24_gamma : 
-    public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_bgr, Gamma>, rendering_buffer>
-    {
-    public:
-        pixfmt_bgr24_gamma(rendering_buffer& rb, const Gamma& g) :
-            pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_bgr, Gamma>, rendering_buffer>(rb) 
-        {
-            this->blender().gamma(g);
-        }
-    };
-
-    //-----------------------------------------------------pixfmt_rgb48_gamma
-    template<class Gamma> class pixfmt_rgb48_gamma : 
-    public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_rgb, Gamma>, rendering_buffer>
-    {
-    public:
-        pixfmt_rgb48_gamma(rendering_buffer& rb, const Gamma& g) :
-            pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_rgb, Gamma>, rendering_buffer>(rb) 
-        {
-            this->blender().gamma(g);
-        }
-    };
-        
-    //-----------------------------------------------------pixfmt_bgr48_gamma
-    template<class Gamma> class pixfmt_bgr48_gamma : 
-    public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_bgr, Gamma>, rendering_buffer>
-    {
-    public:
-        pixfmt_bgr48_gamma(rendering_buffer& rb, const Gamma& g) :
-            pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_bgr, Gamma>, rendering_buffer>(rb) 
-        {
-            this->blender().gamma(g);
-        }
-    };
-
-
-}
-
-#endif
-

Sources/libagg/agg-2.4/agg_pixfmt_transposer.h

@@ -1,157 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-
-#ifndef AGG_PIXFMT_TRANSPOSER_INCLUDED
-#define AGG_PIXFMT_TRANSPOSER_INCLUDED
-
-#include "agg_basics.h"
-
-namespace agg
-{
-    //=======================================================pixfmt_transposer
-    template<class PixFmt> class pixfmt_transposer
-    {
-    public:
-        typedef PixFmt pixfmt_type;
-        typedef typename pixfmt_type::color_type color_type;
-        typedef typename pixfmt_type::row_data row_data;
-        typedef typename color_type::value_type value_type;
-        typedef typename color_type::calc_type calc_type;
-
-        //--------------------------------------------------------------------
-        pixfmt_transposer() : m_pixf(0) {}
-        explicit pixfmt_transposer(pixfmt_type& pixf) : m_pixf(&pixf) {}
-        void attach(pixfmt_type& pixf) { m_pixf = &pixf; }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE unsigned width()  const { return m_pixf->height();  }
-        AGG_INLINE unsigned height() const { return m_pixf->width(); }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE color_type pixel(int x, int y) const
-        {
-            return m_pixf->pixel(y, x);
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE void copy_pixel(int x, int y, const color_type& c)
-        {
-            m_pixf->copy_pixel(y, x, c);
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE void blend_pixel(int x, int y, 
-                                    const color_type& c, 
-                                    int8u cover)
-        {
-            m_pixf->blend_pixel(y, x, c, cover);
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE void copy_hline(int x, int y, 
-                                   unsigned len, 
-                                   const color_type& c)
-        {
-            m_pixf->copy_vline(y, x, len, c);
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE void copy_vline(int x, int y,
-                                   unsigned len, 
-                                   const color_type& c)
-        {
-            m_pixf->copy_hline(y, x, len, c);
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE void blend_hline(int x, int y,
-                                    unsigned len, 
-                                    const color_type& c,
-                                    int8u cover)
-        {
-            m_pixf->blend_vline(y, x, len, c, cover);
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE void blend_vline(int x, int y,
-                                    unsigned len, 
-                                    const color_type& c,
-                                    int8u cover)
-        {
-            m_pixf->blend_hline(y, x, len, c, cover);
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE void blend_solid_hspan(int x, int y,
-                                          unsigned len, 
-                                          const color_type& c,
-                                          const int8u* covers)
-        {
-            m_pixf->blend_solid_vspan(y, x, len, c, covers);
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE void blend_solid_vspan(int x, int y,
-                                          unsigned len, 
-                                          const color_type& c,
-                                          const int8u* covers)
-        {
-            m_pixf->blend_solid_hspan(y, x, len, c, covers);
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE void copy_color_hspan(int x, int y,
-                                         unsigned len, 
-                                         const color_type* colors)
-        {
-            m_pixf->copy_color_vspan(y, x, len, colors);
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE void copy_color_vspan(int x, int y,
-                                         unsigned len, 
-                                         const color_type* colors)
-        {
-            m_pixf->copy_color_hspan(y, x, len, colors);
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE void blend_color_hspan(int x, int y,
-                                          unsigned len, 
-                                          const color_type* colors,
-                                          const int8u* covers,
-                                          int8u cover)
-        {
-            m_pixf->blend_color_vspan(y, x, len, colors, covers, cover);
-        }
-
-        //--------------------------------------------------------------------
-        AGG_INLINE void blend_color_vspan(int x, int y,
-                               unsigned len, 
-                               const color_type* colors,
-                               const int8u* covers,
-                               int8u cover)
-        {
-            m_pixf->blend_color_hspan(y, x, len, colors, covers, cover);
-        }
-
-    private:
-        pixfmt_type* m_pixf;
-    };
-}
-
-#endif
-
-

Sources/libagg/agg-2.4/agg_rasterizer_cells_aa.h

@@ -1,754 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-//
-// The author gratefully acknowleges the support of David Turner, 
-// Robert Wilhelm, and Werner Lemberg - the authors of the FreeType 
-// libray - in producing this work. See http://www.freetype.org for details.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// Adaptation for 32-bit screen coordinates has been sponsored by 
-// Liberty Technology Systems, Inc., visit http://lib-sys.com
-//
-// Liberty Technology Systems, Inc. is the provider of
-// PostScript and PDF technology for software developers.
-// 
-//----------------------------------------------------------------------------
-#ifndef AGG_RASTERIZER_CELLS_AA_INCLUDED
-#define AGG_RASTERIZER_CELLS_AA_INCLUDED
-
-#include <string.h>
-#include <math.h>
-#include "agg_math.h"
-#include "agg_array.h"
-
-
-namespace agg
-{
-
-    //-----------------------------------------------------rasterizer_cells_aa
-    // An internal class that implements the main rasterization algorithm.
-    // Used in the rasterizer. Should not be used direcly.
-    template<class Cell> class rasterizer_cells_aa
-    {
-        enum cell_block_scale_e
-        {
-            cell_block_shift = 12,
-            cell_block_size  = 1 << cell_block_shift,
-            cell_block_mask  = cell_block_size - 1,
-            cell_block_pool  = 256,
-            cell_block_limit = 1024
-        };
-
-        struct sorted_y
-        {
-            unsigned start;
-            unsigned num;
-        };
-
-    public:
-        typedef Cell cell_type;
-        typedef rasterizer_cells_aa<Cell> self_type;
-
-        ~rasterizer_cells_aa();
-        rasterizer_cells_aa();
-
-        void reset();
-        void style(const cell_type& style_cell);
-        void line(int x1, int y1, int x2, int y2);
-
-        int min_x() const { return m_min_x; }
-        int min_y() const { return m_min_y; }
-        int max_x() const { return m_max_x; }
-        int max_y() const { return m_max_y; }
-
-        void sort_cells();
-
-        unsigned total_cells() const 
-        {
-            return m_num_cells;
-        }
-
-        unsigned scanline_num_cells(unsigned y) const 
-        { 
-            return m_sorted_y[y - m_min_y].num; 
-        }
-
-        const cell_type* const* scanline_cells(unsigned y) const
-        { 
-            return m_sorted_cells.data() + m_sorted_y[y - m_min_y].start; 
-        }
-
-        bool sorted() const { return m_sorted; }
-
-    private:
-        rasterizer_cells_aa(const self_type&);
-        const self_type& operator = (const self_type&);
-
-        void set_curr_cell(int x, int y);
-        void add_curr_cell();
-        void render_hline(int ey, int x1, int y1, int x2, int y2);
-        void allocate_block();
-        
-    private:
-        unsigned                m_num_blocks;
-        unsigned                m_max_blocks;
-        unsigned                m_curr_block;
-        unsigned                m_num_cells;
-        cell_type**             m_cells;
-        cell_type*              m_curr_cell_ptr;
-        pod_vector<cell_type*>  m_sorted_cells;
-        pod_vector<sorted_y>    m_sorted_y;
-        cell_type               m_curr_cell;
-        cell_type               m_style_cell;
-        int                     m_min_x;
-        int                     m_min_y;
-        int                     m_max_x;
-        int                     m_max_y;
-        bool                    m_sorted;
-    };
-
-
-
-
-    //------------------------------------------------------------------------
-    template<class Cell> 
-    rasterizer_cells_aa<Cell>::~rasterizer_cells_aa()
-    {
-        if(m_num_blocks)
-        {
-            cell_type** ptr = m_cells + m_num_blocks - 1;
-            while(m_num_blocks--)
-            {
-                pod_allocator<cell_type>::deallocate(*ptr, cell_block_size);
-                ptr--;
-            }
-            pod_allocator<cell_type*>::deallocate(m_cells, m_max_blocks);
-        }
-    }
-
-    //------------------------------------------------------------------------
-    template<class Cell> 
-    rasterizer_cells_aa<Cell>::rasterizer_cells_aa() :
-        m_num_blocks(0),
-        m_max_blocks(0),
-        m_curr_block(0),
-        m_num_cells(0),
-        m_cells(0),
-        m_curr_cell_ptr(0),
-        m_sorted_cells(),
-        m_sorted_y(),
-        m_min_x(0x7FFFFFFF),
-        m_min_y(0x7FFFFFFF),
-        m_max_x(-0x7FFFFFFF),
-        m_max_y(-0x7FFFFFFF),
-        m_sorted(false)
-    {
-        m_style_cell.initial();
-        m_curr_cell.initial();
-    }
-
-    //------------------------------------------------------------------------
-    template<class Cell> 
-    void rasterizer_cells_aa<Cell>::reset()
-    {
-        m_num_cells = 0; 
-        m_curr_block = 0;
-        m_curr_cell.initial();
-        m_style_cell.initial();
-        m_sorted = false;
-        m_min_x =  0x7FFFFFFF;
-        m_min_y =  0x7FFFFFFF;
-        m_max_x = -0x7FFFFFFF;
-        m_max_y = -0x7FFFFFFF;
-    }
-
-    //------------------------------------------------------------------------
-    template<class Cell> 
-    AGG_INLINE void rasterizer_cells_aa<Cell>::add_curr_cell()
-    {
-        if(m_curr_cell.area | m_curr_cell.cover)
-        {
-            if((m_num_cells & cell_block_mask) == 0)
-            {
-                if(m_num_blocks >= cell_block_limit) return;
-                allocate_block();
-            }
-            *m_curr_cell_ptr++ = m_curr_cell;
-            ++m_num_cells;
-        }
-    }
-
-    //------------------------------------------------------------------------
-    template<class Cell> 
-    AGG_INLINE void rasterizer_cells_aa<Cell>::set_curr_cell(int x, int y)
-    {
-        if(m_curr_cell.not_equal(x, y, m_style_cell))
-        {
-            add_curr_cell();
-            m_curr_cell.style(m_style_cell);
-            m_curr_cell.x     = x;
-            m_curr_cell.y     = y;
-            m_curr_cell.cover = 0;
-            m_curr_cell.area  = 0;
-        }
-    }
-
-    //------------------------------------------------------------------------
-    template<class Cell> 
-    AGG_INLINE void rasterizer_cells_aa<Cell>::render_hline(int ey, 
-                                                            int x1, int y1, 
-                                                            int x2, int y2)
-    {
-        int ex1 = x1 >> poly_subpixel_shift;
-        int ex2 = x2 >> poly_subpixel_shift;
-        int fx1 = x1 & poly_subpixel_mask;
-        int fx2 = x2 & poly_subpixel_mask;
-
-        int delta, p, first, dx;
-        int incr, lift, mod, rem;
-
-        //trivial case. Happens often
-        if(y1 == y2)
-        {
-            set_curr_cell(ex2, ey);
-            return;
-        }
-
-        //everything is located in a single cell.  That is easy!
-        if(ex1 == ex2)
-        {
-            delta = y2 - y1;
-            m_curr_cell.cover += delta;
-            m_curr_cell.area  += (fx1 + fx2) * delta;
-            return;
-        }
-
-        //ok, we'll have to render a run of adjacent cells on the same
-        //hline...
-        p     = (poly_subpixel_scale - fx1) * (y2 - y1);
-        first = poly_subpixel_scale;
-        incr  = 1;
-
-        dx = x2 - x1;
-
-        if(dx < 0)
-        {
-            p     = fx1 * (y2 - y1);
-            first = 0;
-            incr  = -1;
-            dx    = -dx;
-        }
-
-        delta = p / dx;
-        mod   = p % dx;
-
-        if(mod < 0)
-        {
-            delta--;
-            mod += dx;
-        }
-
-        m_curr_cell.cover += delta;
-        m_curr_cell.area  += (fx1 + first) * delta;
-
-        ex1 += incr;
-        set_curr_cell(ex1, ey);
-        y1  += delta;
-
-        if(ex1 != ex2)
-        {
-            p     = poly_subpixel_scale * (y2 - y1 + delta);
-            lift  = p / dx;
-            rem   = p % dx;
-
-            if (rem < 0)
-            {
-                lift--;
-                rem += dx;
-            }
-
-            mod -= dx;
-
-            while (ex1 != ex2)
-            {
-                delta = lift;
-                mod  += rem;
-                if(mod >= 0)
-                {
-                    mod -= dx;
-                    delta++;
-                }
-
-                m_curr_cell.cover += delta;
-                m_curr_cell.area  += poly_subpixel_scale * delta;
-                y1  += delta;
-                ex1 += incr;
-                set_curr_cell(ex1, ey);
-            }
-        }
-        delta = y2 - y1;
-        m_curr_cell.cover += delta;
-        m_curr_cell.area  += (fx2 + poly_subpixel_scale - first) * delta;
-    }
-
-    //------------------------------------------------------------------------
-    template<class Cell> 
-    AGG_INLINE void rasterizer_cells_aa<Cell>::style(const cell_type& style_cell)
-    { 
-        m_style_cell.style(style_cell); 
-    }
-
-    //------------------------------------------------------------------------
-    template<class Cell> 
-    void rasterizer_cells_aa<Cell>::line(int x1, int y1, int x2, int y2)
-    {
-        enum dx_limit_e { dx_limit = 16384 << poly_subpixel_shift };
-
-        int dx = x2 - x1;
-
-        if(dx >= dx_limit || dx <= -dx_limit)
-        {
-            int cx = (x1 + x2) >> 1;
-            int cy = (y1 + y2) >> 1;
-            line(x1, y1, cx, cy);
-            line(cx, cy, x2, y2);
-        }
-
-        int dy = y2 - y1;
-        int ex1 = x1 >> poly_subpixel_shift;
-        int ex2 = x2 >> poly_subpixel_shift;
-        int ey1 = y1 >> poly_subpixel_shift;
-        int ey2 = y2 >> poly_subpixel_shift;
-        int fy1 = y1 & poly_subpixel_mask;
-        int fy2 = y2 & poly_subpixel_mask;
-
-        int x_from, x_to;
-        int p, rem, mod, lift, delta, first, incr;
-
-        if(ex1 < m_min_x) m_min_x = ex1;
-        if(ex1 > m_max_x) m_max_x = ex1;
-        if(ey1 < m_min_y) m_min_y = ey1;
-        if(ey1 > m_max_y) m_max_y = ey1;
-        if(ex2 < m_min_x) m_min_x = ex2;
-        if(ex2 > m_max_x) m_max_x = ex2;
-        if(ey2 < m_min_y) m_min_y = ey2;
-        if(ey2 > m_max_y) m_max_y = ey2;
-
-        set_curr_cell(ex1, ey1);
-
-        //everything is on a single hline
-        if(ey1 == ey2)
-        {
-            render_hline(ey1, x1, fy1, x2, fy2);
-            return;
-        }
-
-        //Vertical line - we have to calculate start and end cells,
-        //and then - the common values of the area and coverage for
-        //all cells of the line. We know exactly there's only one 
-        //cell, so, we don't have to call render_hline().
-        incr  = 1;
-        if(dx == 0)
-        {
-            int ex = x1 >> poly_subpixel_shift;
-            int two_fx = (x1 - (ex << poly_subpixel_shift)) << 1;
-            int area;
-
-            first = poly_subpixel_scale;
-            if(dy < 0)
-            {
-                first = 0;
-                incr  = -1;
-            }
-
-            x_from = x1;
-
-            //render_hline(ey1, x_from, fy1, x_from, first);
-            delta = first - fy1;
-            m_curr_cell.cover += delta;
-            m_curr_cell.area  += two_fx * delta;
-
-            ey1 += incr;
-            set_curr_cell(ex, ey1);
-
-            delta = first + first - poly_subpixel_scale;
-            area = two_fx * delta;
-            while(ey1 != ey2)
-            {
-                //render_hline(ey1, x_from, poly_subpixel_scale - first, x_from, first);
-                m_curr_cell.cover = delta;
-                m_curr_cell.area  = area;
-                ey1 += incr;
-                set_curr_cell(ex, ey1);
-            }
-            //render_hline(ey1, x_from, poly_subpixel_scale - first, x_from, fy2);
-            delta = fy2 - poly_subpixel_scale + first;
-            m_curr_cell.cover += delta;
-            m_curr_cell.area  += two_fx * delta;
-            return;
-        }
-
-        //ok, we have to render several hlines
-        p     = (poly_subpixel_scale - fy1) * dx;
-        first = poly_subpixel_scale;
-
-        if(dy < 0)
-        {
-            p     = fy1 * dx;
-            first = 0;
-            incr  = -1;
-            dy    = -dy;
-        }
-
-        delta = p / dy;
-        mod   = p % dy;
-
-        if(mod < 0)
-        {
-            delta--;
-            mod += dy;
-        }
-
-        x_from = x1 + delta;
-        render_hline(ey1, x1, fy1, x_from, first);
-
-        ey1 += incr;
-        set_curr_cell(x_from >> poly_subpixel_shift, ey1);
-
-        if(ey1 != ey2)
-        {
-            p     = poly_subpixel_scale * dx;
-            lift  = p / dy;
-            rem   = p % dy;
-
-            if(rem < 0)
-            {
-                lift--;
-                rem += dy;
-            }
-            mod -= dy;
-
-            while(ey1 != ey2)
-            {
-                delta = lift;
-                mod  += rem;
-                if (mod >= 0)
-                {
-                    mod -= dy;
-                    delta++;
-                }
-
-                x_to = x_from + delta;
-                render_hline(ey1, x_from, poly_subpixel_scale - first, x_to, first);
-                x_from = x_to;
-
-                ey1 += incr;
-                set_curr_cell(x_from >> poly_subpixel_shift, ey1);
-            }
-        }
-        render_hline(ey1, x_from, poly_subpixel_scale - first, x2, fy2);
-    }
-
-    //------------------------------------------------------------------------
-    template<class Cell> 
-    void rasterizer_cells_aa<Cell>::allocate_block()
-    {
-        if(m_curr_block >= m_num_blocks)
-        {
-            if(m_num_blocks >= m_max_blocks)
-            {
-                cell_type** new_cells = 
-                    pod_allocator<cell_type*>::allocate(m_max_blocks + 
-                                                        cell_block_pool);
-
-                if(m_cells)
-                {
-                    memcpy(new_cells, m_cells, m_max_blocks * sizeof(cell_type*));
-                    pod_allocator<cell_type*>::deallocate(m_cells, m_max_blocks);
-                }
-                m_cells = new_cells;
-                m_max_blocks += cell_block_pool;
-            }
-
-            m_cells[m_num_blocks++] = 
-                pod_allocator<cell_type>::allocate(cell_block_size);
-
-        }
-        m_curr_cell_ptr = m_cells[m_curr_block++];
-    }
-
-
-
-    //------------------------------------------------------------------------
-    template <class T> static AGG_INLINE void swap_cells(T* a, T* b)
-    {
-        T temp = *a;
-        *a = *b;
-        *b = temp;
-    }
-
-
-    //------------------------------------------------------------------------
-    enum
-    {
-        qsort_threshold = 9
-    };
-
-
-    //------------------------------------------------------------------------
-    template<class Cell>
-    void qsort_cells(Cell** start, unsigned num)
-    {
-        Cell**  stack[80];
-        Cell*** top; 
-        Cell**  limit;
-        Cell**  base;
-
-        limit = start + num;
-        base  = start;
-        top   = stack;
-
-        for (;;)
-        {
-            int len = int(limit - base);
-
-            Cell** i;
-            Cell** j;
-            Cell** pivot;
-
-            if(len > qsort_threshold)
-            {
-                // we use base + len/2 as the pivot
-                pivot = base + len / 2;
-                swap_cells(base, pivot);
-
-                i = base + 1;
-                j = limit - 1;
-
-                // now ensure that *i <= *base <= *j 
-                if((*j)->x < (*i)->x)
-                {
-                    swap_cells(i, j);
-                }
-
-                if((*base)->x < (*i)->x)
-                {
-                    swap_cells(base, i);
-                }
-
-                if((*j)->x < (*base)->x)
-                {
-                    swap_cells(base, j);
-                }
-
-                for(;;)
-                {
-                    int x = (*base)->x;
-                    do i++; while( (*i)->x < x );
-                    do j--; while( x < (*j)->x );
-
-                    if(i > j)
-                    {
-                        break;
-                    }
-
-                    swap_cells(i, j);
-                }
-
-                swap_cells(base, j);
-
-                // now, push the largest sub-array
-                if(j - base > limit - i)
-                {
-                    top[0] = base;
-                    top[1] = j;
-                    base   = i;
-                }
-                else
-                {
-                    top[0] = i;
-                    top[1] = limit;
-                    limit  = j;
-                }
-                top += 2;
-            }
-            else
-            {
-                // the sub-array is small, perform insertion sort
-                j = base;
-                i = j + 1;
-
-                for(; i < limit; j = i, i++)
-                {
-                    for(; j[1]->x < (*j)->x; j--)
-                    {
-                        swap_cells(j + 1, j);
-                        if (j == base)
-                        {
-                            break;
-                        }
-                    }
-                }
-
-                if(top > stack)
-                {
-                    top  -= 2;
-                    base  = top[0];
-                    limit = top[1];
-                }
-                else
-                {
-                    break;
-                }
-            }
-        }
-    }
-
-
-    //------------------------------------------------------------------------
-    template<class Cell> 
-    void rasterizer_cells_aa<Cell>::sort_cells()
-    {
-        if(m_sorted) return; //Perform sort only the first time.
-
-        add_curr_cell();
-        m_curr_cell.x     = 0x7FFFFFFF;
-        m_curr_cell.y     = 0x7FFFFFFF;
-        m_curr_cell.cover = 0;
-        m_curr_cell.area  = 0;
-
-        if(m_num_cells == 0) return;
-
-// DBG: Check to see if min/max works well.
-//for(unsigned nc = 0; nc < m_num_cells; nc++)
-//{
-//    cell_type* cell = m_cells[nc >> cell_block_shift] + (nc & cell_block_mask);
-//    if(cell->x < m_min_x || 
-//       cell->y < m_min_y || 
-//       cell->x > m_max_x || 
-//       cell->y > m_max_y)
-//    {
-//        cell = cell; // Breakpoint here
-//    }
-//}
-        // Allocate the array of cell pointers
-        m_sorted_cells.allocate(m_num_cells, 16);
-
-        // Allocate and zero the Y array
-        m_sorted_y.allocate(m_max_y - m_min_y + 1, 16);
-        m_sorted_y.zero();
-
-        // Create the Y-histogram (count the numbers of cells for each Y)
-        cell_type** block_ptr = m_cells;
-        cell_type*  cell_ptr;
-        unsigned nb = m_num_cells >> cell_block_shift;
-        unsigned i;
-        while(nb--)
-        {
-            cell_ptr = *block_ptr++;
-            i = cell_block_size;
-            while(i--) 
-            {
-                m_sorted_y[cell_ptr->y - m_min_y].start++;
-                ++cell_ptr;
-            }
-        }
-
-        cell_ptr = *block_ptr++;
-        i = m_num_cells & cell_block_mask;
-        while(i--) 
-        {
-            m_sorted_y[cell_ptr->y - m_min_y].start++;
-            ++cell_ptr;
-        }
-
-        // Convert the Y-histogram into the array of starting indexes
-        unsigned start = 0;
-        for(i = 0; i < m_sorted_y.size(); i++)
-        {
-            unsigned v = m_sorted_y[i].start;
-            m_sorted_y[i].start = start;
-            start += v;
-        }
-
-        // Fill the cell pointer array sorted by Y
-        block_ptr = m_cells;
-        nb = m_num_cells >> cell_block_shift;
-        while(nb--)
-        {
-            cell_ptr = *block_ptr++;
-            i = cell_block_size;
-            while(i--) 
-            {
-                sorted_y& curr_y = m_sorted_y[cell_ptr->y - m_min_y];
-                m_sorted_cells[curr_y.start + curr_y.num] = cell_ptr;
-                ++curr_y.num;
-                ++cell_ptr;
-            }
-        }
-        
-        cell_ptr = *block_ptr++;
-        i = m_num_cells & cell_block_mask;
-        while(i--) 
-        {
-            sorted_y& curr_y = m_sorted_y[cell_ptr->y - m_min_y];
-            m_sorted_cells[curr_y.start + curr_y.num] = cell_ptr;
-            ++curr_y.num;
-            ++cell_ptr;
-        }
-
-        // Finally arrange the X-arrays
-        for(i = 0; i < m_sorted_y.size(); i++)
-        {
-            const sorted_y& curr_y = m_sorted_y[i];
-            if(curr_y.num)
-            {
-                qsort_cells(m_sorted_cells.data() + curr_y.start, curr_y.num);
-            }
-        }
-        m_sorted = true;
-    }
-
-
-
-    //------------------------------------------------------scanline_hit_test
-    class scanline_hit_test
-    {
-    public:
-        scanline_hit_test(int x) : m_x(x), m_hit(false) {}
-
-        void reset_spans() {}
-        void finalize(int) {}
-        void add_cell(int x, int)
-        {
-            if(m_x == x) m_hit = true;
-        }
-        void add_span(int x, int len, int)
-        {
-            if(m_x >= x && m_x < x+len) m_hit = true;
-        }
-        unsigned num_spans() const { return 1; }
-        bool hit() const { return m_hit; }
-
-    private:
-        int  m_x;
-        bool m_hit;
-    };
-
-
-}
-
-#endif

Sources/libagg/agg-2.4/agg_rasterizer_compound_aa.h

@@ -1,698 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.3
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-//
-// The author gratefully acknowleges the support of David Turner, 
-// Robert Wilhelm, and Werner Lemberg - the authors of the FreeType 
-// libray - in producing this work. See http://www.freetype.org for details.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// Adaptation for 32-bit screen coordinates has been sponsored by 
-// Liberty Technology Systems, Inc., visit http://lib-sys.com
-//
-// Liberty Technology Systems, Inc. is the provider of
-// PostScript and PDF technology for software developers.
-// 
-//----------------------------------------------------------------------------
-#ifndef AGG_RASTERIZER_COMPOUND_AA_INCLUDED
-#define AGG_RASTERIZER_COMPOUND_AA_INCLUDED
-
-#include "agg_rasterizer_cells_aa.h"
-#include "agg_rasterizer_sl_clip.h"
-
-namespace agg
-{
-
-    //-----------------------------------------------------------cell_style_aa
-    // A pixel cell. There're no constructors defined and it was done 
-    // intentionally in order to avoid extra overhead when allocating an 
-    // array of cells.
-    struct cell_style_aa
-    {
-        int   x;
-        int   y;
-        int   cover;
-        int   area;
-        int16 left, right;
-
-        void initial()
-        {
-            x     = 0x7FFFFFFF;
-            y     = 0x7FFFFFFF;
-            cover = 0;
-            area  = 0;
-            left  = -1;
-            right = -1;
-        }
-
-        void style(const cell_style_aa& c)
-        {
-            left  = c.left;
-            right = c.right;
-        }
-
-        int not_equal(int ex, int ey, const cell_style_aa& c) const
-        {
-            return (ex - x) | (ey - y) | (left - c.left) | (right - c.right);
-        }
-    };
-
-
-    //===========================================================layer_order_e
-    enum layer_order_e
-    {
-        layer_unsorted, //------layer_unsorted
-        layer_direct,   //------layer_direct
-        layer_inverse   //------layer_inverse
-    };
-
-
-    //==================================================rasterizer_compound_aa
-    template<class Clip=rasterizer_sl_clip_int> class rasterizer_compound_aa
-    {
-        struct style_info 
-        { 
-            unsigned start_cell;
-            unsigned num_cells;
-            int      last_x;
-        };
-
-        struct cell_info
-        {
-            int x, area, cover; 
-        };
-
-    public:
-        typedef Clip                      clip_type;
-        typedef typename Clip::conv_type  conv_type;
-        typedef typename Clip::coord_type coord_type;
-
-        enum aa_scale_e
-        {
-            aa_shift  = 8,
-            aa_scale  = 1 << aa_shift,
-            aa_mask   = aa_scale - 1,
-            aa_scale2 = aa_scale * 2,
-            aa_mask2  = aa_scale2 - 1
-        };
-
-        //--------------------------------------------------------------------
-        rasterizer_compound_aa() : 
-            m_outline(),
-            m_clipper(),
-            m_filling_rule(fill_non_zero),
-            m_layer_order(layer_direct),
-            m_styles(),  // Active Styles
-            m_ast(),     // Active Style Table (unique values)
-            m_asm(),     // Active Style Mask 
-            m_cells(),
-            m_cover_buf(),
-            m_master_alpha(),
-            m_min_style(0x7FFFFFFF),
-            m_max_style(-0x7FFFFFFF),
-            m_start_x(0),
-            m_start_y(0),
-            m_scan_y(0x7FFFFFFF),
-            m_sl_start(0),
-            m_sl_len(0)
-        {}
-
-        //--------------------------------------------------------------------
-        void reset(); 
-        void reset_clipping();
-        void clip_box(double x1, double y1, double x2, double y2);
-        void filling_rule(filling_rule_e filling_rule);
-        void layer_order(layer_order_e order);
-        void master_alpha(int style, double alpha);
-
-        //--------------------------------------------------------------------
-        void styles(int left, int right);
-        void move_to(int x, int y);
-        void line_to(int x, int y);
-        void move_to_d(double x, double y);
-        void line_to_d(double x, double y);
-        void add_vertex(double x, double y, unsigned cmd);
-
-        void edge(int x1, int y1, int x2, int y2);
-        void edge_d(double x1, double y1, double x2, double y2);
-
-        //-------------------------------------------------------------------
-        template<class VertexSource>
-        void add_path(VertexSource& vs, unsigned path_id=0)
-        {
-            double x;
-            double y;
-
-            unsigned cmd;
-            vs.rewind(path_id);
-            if(m_outline.sorted()) reset();
-            while(!is_stop(cmd = vs.vertex(&x, &y)))
-            {
-                add_vertex(x, y, cmd);
-            }
-        }
-
-        
-        //--------------------------------------------------------------------
-        int min_x()     const { return m_outline.min_x(); }
-        int min_y()     const { return m_outline.min_y(); }
-        int max_x()     const { return m_outline.max_x(); }
-        int max_y()     const { return m_outline.max_y(); }
-        int min_style() const { return m_min_style; }
-        int max_style() const { return m_max_style; }
-
-        //--------------------------------------------------------------------
-        void sort();
-        bool rewind_scanlines();
-        unsigned sweep_styles();
-        int      scanline_start()  const { return m_sl_start; }
-        unsigned scanline_length() const { return m_sl_len;   }
-        unsigned style(unsigned style_idx) const;
-
-        cover_type* allocate_cover_buffer(unsigned len);
-
-        //--------------------------------------------------------------------
-        bool navigate_scanline(int y); 
-        bool hit_test(int tx, int ty);
-
-        //--------------------------------------------------------------------
-        AGG_INLINE unsigned calculate_alpha(int area, unsigned master_alpha) const
-        {
-            int cover = area >> (poly_subpixel_shift*2 + 1 - aa_shift);
-            if(cover < 0) cover = -cover;
-            if(m_filling_rule == fill_even_odd)
-            {
-                cover &= aa_mask2;
-                if(cover > aa_scale)
-                {
-                    cover = aa_scale2 - cover;
-                }
-            }
-            if(cover > aa_mask) cover = aa_mask;
-            return (cover * master_alpha + aa_mask) >> aa_shift;
-        }
-
-        //--------------------------------------------------------------------
-        // Sweeps one scanline with one style index. The style ID can be 
-        // determined by calling style(). 
-        template<class Scanline> bool sweep_scanline(Scanline& sl, int style_idx)
-        {
-            int scan_y = m_scan_y - 1;
-            if(scan_y > m_outline.max_y()) return false;
-
-            sl.reset_spans();
-
-            unsigned master_alpha = aa_mask;
-
-            if(style_idx < 0) 
-            {
-                style_idx = 0;
-            }
-            else 
-            {
-                style_idx++;
-                master_alpha = m_master_alpha[m_ast[style_idx] + m_min_style - 1];
-            }
-
-            const style_info& st = m_styles[m_ast[style_idx]];
-
-            unsigned num_cells = st.num_cells;
-            cell_info* cell = &m_cells[st.start_cell];
-
-            int cover = 0;
-            while(num_cells--)
-            {
-                unsigned alpha;
-                int x = cell->x;
-                int area = cell->area;
-
-                cover += cell->cover;
-
-                ++cell;
-
-                if(area)
-                {
-                    alpha = calculate_alpha((cover << (poly_subpixel_shift + 1)) - area,
-                                            master_alpha);
-                    sl.add_cell(x, alpha);
-                    x++;
-                }
-
-                if(num_cells && cell->x > x)
-                {
-                    alpha = calculate_alpha(cover << (poly_subpixel_shift + 1),
-                                            master_alpha);
-                    if(alpha)
-                    {
-                        sl.add_span(x, cell->x - x, alpha);
-                    }
-                }
-            }
-
-            if(sl.num_spans() == 0) return false;
-            sl.finalize(scan_y);
-            return true;
-        }
-
-    private:
-        void add_style(int style_id);
-        void allocate_master_alpha();
-
-        //--------------------------------------------------------------------
-        // Disable copying
-        rasterizer_compound_aa(const rasterizer_compound_aa<Clip>&);
-        const rasterizer_compound_aa<Clip>& 
-        operator = (const rasterizer_compound_aa<Clip>&);
-
-    private:
-        rasterizer_cells_aa<cell_style_aa> m_outline;
-        clip_type              m_clipper;
-        filling_rule_e         m_filling_rule;
-        layer_order_e          m_layer_order;
-        pod_vector<style_info> m_styles;  // Active Styles
-        pod_vector<unsigned>   m_ast;     // Active Style Table (unique values)
-        pod_vector<int8u>      m_asm;     // Active Style Mask 
-        pod_vector<cell_info>  m_cells;
-        pod_vector<cover_type> m_cover_buf;
-        pod_bvector<unsigned>  m_master_alpha;
-
-        int        m_min_style;
-        int        m_max_style;
-        coord_type m_start_x;
-        coord_type m_start_y;
-        int        m_scan_y;
-        int        m_sl_start;
-        unsigned   m_sl_len;
-    };
-
-
-
-
-
-
-
-
-
-
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    void rasterizer_compound_aa<Clip>::reset() 
-    { 
-        m_outline.reset(); 
-        m_min_style =  0x7FFFFFFF;
-        m_max_style = -0x7FFFFFFF;
-        m_scan_y    =  0x7FFFFFFF;
-        m_sl_start  =  0;
-        m_sl_len    = 0;
-    }
-
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    void rasterizer_compound_aa<Clip>::filling_rule(filling_rule_e filling_rule) 
-    { 
-        m_filling_rule = filling_rule; 
-    }
-
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    void rasterizer_compound_aa<Clip>::layer_order(layer_order_e order)
-    {
-        m_layer_order = order;
-    }
-
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    void rasterizer_compound_aa<Clip>::clip_box(double x1, double y1, 
-                                                double x2, double y2)
-    {
-        reset();
-        m_clipper.clip_box(conv_type::upscale(x1), conv_type::upscale(y1), 
-                           conv_type::upscale(x2), conv_type::upscale(y2));
-    }
-
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    void rasterizer_compound_aa<Clip>::reset_clipping()
-    {
-        reset();
-        m_clipper.reset_clipping();
-    }
-
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    void rasterizer_compound_aa<Clip>::styles(int left, int right)
-    {
-        cell_style_aa cell;
-        cell.initial();
-        cell.left = (int16)left;
-        cell.right = (int16)right;
-        m_outline.style(cell);
-        if(left  >= 0 && left  < m_min_style) m_min_style = left;
-        if(left  >= 0 && left  > m_max_style) m_max_style = left;
-        if(right >= 0 && right < m_min_style) m_min_style = right;
-        if(right >= 0 && right > m_max_style) m_max_style = right;
-    }
-
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    void rasterizer_compound_aa<Clip>::move_to(int x, int y)
-    {
-        if(m_outline.sorted()) reset();
-        m_clipper.move_to(m_start_x = conv_type::downscale(x), 
-                          m_start_y = conv_type::downscale(y));
-    }
-
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    void rasterizer_compound_aa<Clip>::line_to(int x, int y)
-    {
-        m_clipper.line_to(m_outline, 
-                          conv_type::downscale(x), 
-                          conv_type::downscale(y));
-    }
-
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    void rasterizer_compound_aa<Clip>::move_to_d(double x, double y) 
-    { 
-        if(m_outline.sorted()) reset();
-        m_clipper.move_to(m_start_x = conv_type::upscale(x), 
-                          m_start_y = conv_type::upscale(y)); 
-    }
-
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    void rasterizer_compound_aa<Clip>::line_to_d(double x, double y) 
-    { 
-        m_clipper.line_to(m_outline, 
-                          conv_type::upscale(x), 
-                          conv_type::upscale(y)); 
-    }
-
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    void rasterizer_compound_aa<Clip>::add_vertex(double x, double y, unsigned cmd)
-    {
-        if(is_move_to(cmd)) 
-        {
-            move_to_d(x, y);
-        }
-        else 
-        if(is_vertex(cmd))
-        {
-            line_to_d(x, y);
-        }
-        else
-        if(is_close(cmd))
-        {
-            m_clipper.line_to(m_outline, m_start_x, m_start_y);
-        }
-    }
-
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    void rasterizer_compound_aa<Clip>::edge(int x1, int y1, int x2, int y2)
-    {
-        if(m_outline.sorted()) reset();
-        m_clipper.move_to(conv_type::downscale(x1), conv_type::downscale(y1));
-        m_clipper.line_to(m_outline, 
-                          conv_type::downscale(x2), 
-                          conv_type::downscale(y2));
-    }
-    
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    void rasterizer_compound_aa<Clip>::edge_d(double x1, double y1, 
-                                              double x2, double y2)
-    {
-        if(m_outline.sorted()) reset();
-        m_clipper.move_to(conv_type::upscale(x1), conv_type::upscale(y1)); 
-        m_clipper.line_to(m_outline, 
-                          conv_type::upscale(x2), 
-                          conv_type::upscale(y2)); 
-    }
-
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    AGG_INLINE void rasterizer_compound_aa<Clip>::sort()
-    {
-        m_outline.sort_cells();
-    }
-
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    AGG_INLINE bool rasterizer_compound_aa<Clip>::rewind_scanlines()
-    {
-        m_outline.sort_cells();
-        if(m_outline.total_cells() == 0) 
-        {
-            return false;
-        }
-        if(m_max_style < m_min_style)
-        {
-            return false;
-        }
-        m_scan_y = m_outline.min_y();
-        m_styles.allocate(m_max_style - m_min_style + 2, 128);
-        allocate_master_alpha();
-        return true;
-    }
-
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    AGG_INLINE void rasterizer_compound_aa<Clip>::add_style(int style_id)
-    {
-        if(style_id < 0) style_id  = 0;
-        else             style_id -= m_min_style - 1;
-
-        unsigned nbyte = style_id >> 3;
-        unsigned mask = 1 << (style_id & 7);
-
-        style_info* style = &m_styles[style_id];
-        if((m_asm[nbyte] & mask) == 0)
-        {
-            m_ast.add(style_id);
-            m_asm[nbyte] |= mask;
-            style->start_cell = 0;
-            style->num_cells = 0;
-            style->last_x = -0x7FFFFFFF;
-        }
-        ++style->start_cell;
-    }
-
-    //------------------------------------------------------------------------
-    // Returns the number of styles
-    template<class Clip> 
-    unsigned rasterizer_compound_aa<Clip>::sweep_styles()
-    {
-        for(;;)
-        {
-            if(m_scan_y > m_outline.max_y()) return 0;
-            unsigned num_cells = m_outline.scanline_num_cells(m_scan_y);
-            const cell_style_aa* const* cells = m_outline.scanline_cells(m_scan_y);
-            unsigned num_styles = m_max_style - m_min_style + 2;
-            const cell_style_aa* curr_cell;
-            unsigned style_id;
-            style_info* style;
-            cell_info* cell;
-
-            m_cells.allocate(num_cells * 2, 256); // Each cell can have two styles
-            m_ast.capacity(num_styles, 64);
-            m_asm.allocate((num_styles + 7) >> 3, 8);
-            m_asm.zero();
-
-            if(num_cells)
-            {
-                // Pre-add zero (for no-fill style, that is, -1).
-                // We need that to ensure that the "-1 style" would go first.
-                m_asm[0] |= 1; 
-                m_ast.add(0);
-                style = &m_styles[0];
-                style->start_cell = 0;
-                style->num_cells = 0;
-                style->last_x = -0x7FFFFFFF;
-
-                m_sl_start = cells[0]->x;
-                m_sl_len   = cells[num_cells-1]->x - m_sl_start + 1;
-                while(num_cells--)
-                {
-                    curr_cell = *cells++;
-                    add_style(curr_cell->left);
-                    add_style(curr_cell->right);
-                }
-
-                // Convert the Y-histogram into the array of starting indexes
-                unsigned i;
-                unsigned start_cell = 0;
-                for(i = 0; i < m_ast.size(); i++)
-                {
-                    style_info& st = m_styles[m_ast[i]];
-                    unsigned v = st.start_cell;
-                    st.start_cell = start_cell;
-                    start_cell += v;
-                }
-
-                cells = m_outline.scanline_cells(m_scan_y);
-                num_cells = m_outline.scanline_num_cells(m_scan_y);
-
-                while(num_cells--)
-                {
-                    curr_cell = *cells++;
-                    style_id = (curr_cell->left < 0) ? 0 : 
-                                curr_cell->left - m_min_style + 1;
-
-                    style = &m_styles[style_id];
-                    if(curr_cell->x == style->last_x)
-                    {
-                        cell = &m_cells[style->start_cell + style->num_cells - 1];
-                        cell->area  += curr_cell->area;
-                        cell->cover += curr_cell->cover;
-                    }
-                    else
-                    {
-                        cell = &m_cells[style->start_cell + style->num_cells];
-                        cell->x       = curr_cell->x;
-                        cell->area    = curr_cell->area;
-                        cell->cover   = curr_cell->cover;
-                        style->last_x = curr_cell->x;
-                        style->num_cells++;
-                    }
-
-                    style_id = (curr_cell->right < 0) ? 0 : 
-                                curr_cell->right - m_min_style + 1;
-
-                    style = &m_styles[style_id];
-                    if(curr_cell->x == style->last_x)
-                    {
-                        cell = &m_cells[style->start_cell + style->num_cells - 1];
-                        cell->area  -= curr_cell->area;
-                        cell->cover -= curr_cell->cover;
-                    }
-                    else
-                    {
-                        cell = &m_cells[style->start_cell + style->num_cells];
-                        cell->x       =  curr_cell->x;
-                        cell->area    = -curr_cell->area;
-                        cell->cover   = -curr_cell->cover;
-                        style->last_x =  curr_cell->x;
-                        style->num_cells++;
-                    }
-                }
-            }
-            if(m_ast.size() > 1) break;
-            ++m_scan_y;
-        }
-        ++m_scan_y;
-
-        if(m_layer_order != layer_unsorted)
-        {
-            range_adaptor<pod_vector<unsigned> > ra(m_ast, 1, m_ast.size() - 1);
-            if(m_layer_order == layer_direct) quick_sort(ra, unsigned_greater);
-            else                              quick_sort(ra, unsigned_less);
-        }
-
-        return m_ast.size() - 1;
-    }
-
-    //------------------------------------------------------------------------
-    // Returns style ID depending of the existing style index
-    template<class Clip> 
-    AGG_INLINE 
-    unsigned rasterizer_compound_aa<Clip>::style(unsigned style_idx) const
-    {
-        return m_ast[style_idx + 1] + m_min_style - 1;
-    }
-
-    //------------------------------------------------------------------------ 
-    template<class Clip> 
-    AGG_INLINE bool rasterizer_compound_aa<Clip>::navigate_scanline(int y)
-    {
-        m_outline.sort_cells();
-        if(m_outline.total_cells() == 0) 
-        {
-            return false;
-        }
-        if(m_max_style < m_min_style)
-        {
-            return false;
-        }
-        if(y < m_outline.min_y() || y > m_outline.max_y()) 
-        {
-            return false;
-        }
-        m_scan_y = y;
-        m_styles.allocate(m_max_style - m_min_style + 2, 128);
-        allocate_master_alpha();
-        return true;
-    }
-    
-    //------------------------------------------------------------------------ 
-    template<class Clip> 
-    bool rasterizer_compound_aa<Clip>::hit_test(int tx, int ty)
-    {
-        if(!navigate_scanline(ty)) 
-        {
-            return false;
-        }
-
-        unsigned num_styles = sweep_styles(); 
-        if(num_styles <= 0)
-        {
-            return false;
-        }
-
-        scanline_hit_test sl(tx);
-        sweep_scanline(sl, -1);
-        return sl.hit();
-    }
-
-    //------------------------------------------------------------------------ 
-    template<class Clip> 
-    cover_type* rasterizer_compound_aa<Clip>::allocate_cover_buffer(unsigned len)
-    {
-        m_cover_buf.allocate(len, 256);
-        return &m_cover_buf[0];
-    }
-
-    //------------------------------------------------------------------------ 
-    template<class Clip> 
-    void rasterizer_compound_aa<Clip>::allocate_master_alpha()
-    {
-        while((int)m_master_alpha.size() <= m_max_style)
-        {
-            m_master_alpha.add(aa_mask);
-        }
-    }
-
-    //------------------------------------------------------------------------ 
-    template<class Clip> 
-    void rasterizer_compound_aa<Clip>::master_alpha(int style, double alpha)
-    {
-        if(style >= 0)
-        {
-            while((int)m_master_alpha.size() <= style)
-            {
-                m_master_alpha.add(aa_mask);
-            }
-            m_master_alpha[style] = uround(alpha * aa_mask);
-        }
-    }
-
-}
-
-
-
-#endif
-

Sources/libagg/agg-2.4/agg_rasterizer_outline.h

@@ -1,147 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-#ifndef AGG_RASTERIZER_OUTLINE_INCLUDED
-#define AGG_RASTERIZER_OUTLINE_INCLUDED
-
-#include "agg_basics.h"
-
-namespace agg
-{
-    //======================================================rasterizer_outline
-    template<class Renderer> class rasterizer_outline
-    {
-    public:
-        explicit rasterizer_outline(Renderer& ren) : 
-            m_ren(&ren), 
-            m_start_x(0), 
-            m_start_y(0), 
-            m_vertices(0)
-        {}
-        void attach(Renderer& ren) { m_ren = &ren; }
-
-
-        //--------------------------------------------------------------------
-        void move_to(int x, int y)
-        {
-            m_vertices = 1;
-            m_ren->move_to(m_start_x = x, m_start_y = y);
-        }
-
-        //--------------------------------------------------------------------
-        void line_to(int x, int y)
-        {
-            ++m_vertices;
-            m_ren->line_to(x, y);
-        }
-
-        //--------------------------------------------------------------------
-        void move_to_d(double x, double y)
-        {
-            move_to(m_ren->coord(x), m_ren->coord(y));
-        }
-
-        //--------------------------------------------------------------------
-        void line_to_d(double x, double y)
-        {
-            line_to(m_ren->coord(x), m_ren->coord(y));
-        }
-
-        //--------------------------------------------------------------------
-        void close()
-        {
-            if(m_vertices > 2)
-            {
-                line_to(m_start_x, m_start_y);
-            }
-            m_vertices = 0;
-        }
-
-        //--------------------------------------------------------------------
-        void add_vertex(double x, double y, unsigned cmd)
-        {
-            if(is_move_to(cmd)) 
-            {
-                move_to_d(x, y);
-            }
-            else 
-            {
-                if(is_end_poly(cmd))
-                {
-                    if(is_closed(cmd)) close();
-                }
-                else
-                {
-                    line_to_d(x, y);
-                }
-            }
-        }
-
-
-        //--------------------------------------------------------------------
-        template<class VertexSource>
-        void add_path(VertexSource& vs, unsigned path_id=0)
-        {
-            double x;
-            double y;
-
-            unsigned cmd;
-            vs.rewind(path_id);
-            while(!is_stop(cmd = vs.vertex(&x, &y)))
-            {
-                add_vertex(x, y, cmd);
-            }
-        }
-
-
-        //--------------------------------------------------------------------
-        template<class VertexSource, class ColorStorage, class PathId>
-        void render_all_paths(VertexSource& vs, 
-                              const ColorStorage& colors, 
-                              const PathId& path_id,
-                              unsigned num_paths)
-        {
-            for(unsigned i = 0; i < num_paths; i++)
-            {
-                m_ren->line_color(colors[i]);
-                add_path(vs, path_id[i]);
-            }
-        }
-
-
-        //--------------------------------------------------------------------
-        template<class Ctrl> void render_ctrl(Ctrl& c)
-        {
-            unsigned i;
-            for(i = 0; i < c.num_paths(); i++)
-            {
-                m_ren->line_color(c.color(i));
-                add_path(c, i);
-            }
-        }
-
-
-    private:
-        Renderer* m_ren;
-        int       m_start_x;
-        int       m_start_y;
-        unsigned  m_vertices;
-    };
-
-
-}
-
-
-#endif
-

Sources/libagg/agg-2.4/agg_rasterizer_outline_aa.h

@@ -1,599 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-#ifndef AGG_RASTERIZER_OUTLINE_AA_INCLUDED
-#define AGG_RASTERIZER_OUTLINE_AA_INCLUDED
-
-#include "agg_basics.h"
-#include "agg_line_aa_basics.h"
-#include "agg_vertex_sequence.h"
-
-namespace agg
-{
-
-    //-------------------------------------------------------------------------
-    inline bool cmp_dist_start(int d) { return d > 0;  }
-    inline bool cmp_dist_end(int d)   { return d <= 0; }
-
-
-
-    //-----------------------------------------------------------line_aa_vertex
-    // Vertex (x, y) with the distance to the next one. The last vertex has 
-    // the distance between the last and the first points
-    struct line_aa_vertex
-    {
-        int x;
-        int y;
-        int len;
-
-        line_aa_vertex() {}
-        line_aa_vertex(int x_, int y_) :
-            x(x_),
-            y(y_),
-            len(0)
-        {
-        }
-
-        bool operator () (const line_aa_vertex& val)
-        {
-            double dx = val.x - x;
-            double dy = val.y - y;
-            return (len = uround(sqrt(dx * dx + dy * dy))) > 
-                   (line_subpixel_scale + line_subpixel_scale / 2);
-        }
-    };
-
-
-    //----------------------------------------------------------outline_aa_join_e
-    enum outline_aa_join_e
-    {
-        outline_no_join,             //-----outline_no_join
-        outline_miter_join,          //-----outline_miter_join
-        outline_round_join,          //-----outline_round_join
-        outline_miter_accurate_join  //-----outline_accurate_join
-    };
-
-    //=======================================================rasterizer_outline_aa
-    template<class Renderer, class Coord=line_coord> class rasterizer_outline_aa
-    {
-    private:
-        //------------------------------------------------------------------------
-        struct draw_vars
-        {
-            unsigned idx;
-            int x1, y1, x2, y2;
-            line_parameters curr, next;
-            int lcurr, lnext;
-            int xb1, yb1, xb2, yb2;
-            unsigned flags;
-        };
-
-        void draw(draw_vars& dv, unsigned start, unsigned end);
-
-    public:
-        typedef line_aa_vertex                  vertex_type;
-        typedef vertex_sequence<vertex_type, 6> vertex_storage_type;
-
-        explicit rasterizer_outline_aa(Renderer& ren) : 
-            m_ren(&ren), 
-            m_line_join(ren.accurate_join_only() ? 
-                            outline_miter_accurate_join : 
-                            outline_round_join),
-            m_round_cap(false),
-            m_start_x(0),
-            m_start_y(0)
-        {}
-        void attach(Renderer& ren) { m_ren = &ren; }
-
-        //------------------------------------------------------------------------
-        void line_join(outline_aa_join_e join) 
-        { 
-            m_line_join = m_ren->accurate_join_only() ? 
-                outline_miter_accurate_join : 
-                join; 
-        }
-        bool line_join() const { return m_line_join; }
-
-        //------------------------------------------------------------------------
-        void round_cap(bool v) { m_round_cap = v; }
-        bool round_cap() const { return m_round_cap; }
-
-        //------------------------------------------------------------------------
-        void move_to(int x, int y)
-        {
-            m_src_vertices.modify_last(vertex_type(m_start_x = x, m_start_y = y));
-        }
-
-        //------------------------------------------------------------------------
-        void line_to(int x, int y)
-        {
-            m_src_vertices.add(vertex_type(x, y));
-        }
-
-        //------------------------------------------------------------------------
-        void move_to_d(double x, double y)
-        {
-            move_to(Coord::conv(x), Coord::conv(y));
-        }
-
-        //------------------------------------------------------------------------
-        void line_to_d(double x, double y)
-        {
-            line_to(Coord::conv(x), Coord::conv(y));
-        }
-
-        //------------------------------------------------------------------------
-        void render(bool close_polygon);
-
-        //------------------------------------------------------------------------
-        void add_vertex(double x, double y, unsigned cmd)
-        {
-            if(is_move_to(cmd)) 
-            {
-                render(false);
-                move_to_d(x, y);
-            }
-            else 
-            {
-                if(is_end_poly(cmd))
-                {
-                    render(is_closed(cmd));
-                    if(is_closed(cmd)) 
-                    {
-                        move_to(m_start_x, m_start_y);
-                    }
-                }
-                else
-                {
-                    line_to_d(x, y);
-                }
-            }
-        }
-
-        //------------------------------------------------------------------------
-        template<class VertexSource>
-        void add_path(VertexSource& vs, unsigned path_id=0)
-        {
-            double x;
-            double y;
-
-            unsigned cmd;
-            vs.rewind(path_id);
-            while(!is_stop(cmd = vs.vertex(&x, &y)))
-            {
-                add_vertex(x, y, cmd);
-            }
-            render(false);
-        }
-
-
-        //------------------------------------------------------------------------
-        template<class VertexSource, class ColorStorage, class PathId>
-        void render_all_paths(VertexSource& vs, 
-                              const ColorStorage& colors, 
-                              const PathId& path_id,
-                              unsigned num_paths)
-        {
-            for(unsigned i = 0; i < num_paths; i++)
-            {
-                m_ren->color(colors[i]);
-                add_path(vs, path_id[i]);
-            }
-        }
-
-
-        //------------------------------------------------------------------------
-        template<class Ctrl> void render_ctrl(Ctrl& c)
-        {
-            unsigned i;
-            for(i = 0; i < c.num_paths(); i++)
-            {
-                m_ren->color(c.color(i));
-                add_path(c, i);
-            }
-        }
-
-    private:
-        rasterizer_outline_aa(const rasterizer_outline_aa<Renderer, Coord>&);
-        const rasterizer_outline_aa<Renderer, Coord>& operator = 
-            (const rasterizer_outline_aa<Renderer, Coord>&);
-
-        Renderer*           m_ren;
-        vertex_storage_type m_src_vertices;
-        outline_aa_join_e   m_line_join;
-        bool                m_round_cap;
-        int                 m_start_x;
-        int                 m_start_y;
-    };
-
-
-
-
-
-
-
-
-    //----------------------------------------------------------------------------
-    template<class Renderer, class Coord> 
-    void rasterizer_outline_aa<Renderer, Coord>::draw(draw_vars& dv, 
-                                                      unsigned start, 
-                                                      unsigned end)
-    {
-        unsigned i;
-        const vertex_storage_type::value_type* v;
-
-        for(i = start; i < end; i++)
-        {
-            if(m_line_join == outline_round_join)
-            {
-                dv.xb1 = dv.curr.x1 + (dv.curr.y2 - dv.curr.y1); 
-                dv.yb1 = dv.curr.y1 - (dv.curr.x2 - dv.curr.x1); 
-                dv.xb2 = dv.curr.x2 + (dv.curr.y2 - dv.curr.y1); 
-                dv.yb2 = dv.curr.y2 - (dv.curr.x2 - dv.curr.x1);
-            }
-
-            switch(dv.flags)
-            {
-            case 0: m_ren->line3(dv.curr, dv.xb1, dv.yb1, dv.xb2, dv.yb2); break;
-            case 1: m_ren->line2(dv.curr, dv.xb2, dv.yb2); break;
-            case 2: m_ren->line1(dv.curr, dv.xb1, dv.yb1); break;
-            case 3: m_ren->line0(dv.curr); break;
-            }
-
-            if(m_line_join == outline_round_join && (dv.flags & 2) == 0)
-            {
-                m_ren->pie(dv.curr.x2, dv.curr.y2, 
-                           dv.curr.x2 + (dv.curr.y2 - dv.curr.y1),
-                           dv.curr.y2 - (dv.curr.x2 - dv.curr.x1),
-                           dv.curr.x2 + (dv.next.y2 - dv.next.y1),
-                           dv.curr.y2 - (dv.next.x2 - dv.next.x1));
-            }
-
-            dv.x1 = dv.x2;
-            dv.y1 = dv.y2;
-            dv.lcurr = dv.lnext;
-            dv.lnext = m_src_vertices[dv.idx].len;
-
-            ++dv.idx;
-            if(dv.idx >= m_src_vertices.size()) dv.idx = 0; 
-
-            v = &m_src_vertices[dv.idx];
-            dv.x2 = v->x;
-            dv.y2 = v->y;
-
-            dv.curr = dv.next;
-            dv.next = line_parameters(dv.x1, dv.y1, dv.x2, dv.y2, dv.lnext);
-            dv.xb1 = dv.xb2;
-            dv.yb1 = dv.yb2;
-
-            switch(m_line_join)
-            {
-            case outline_no_join:
-                dv.flags = 3;
-                break;
-
-            case outline_miter_join:
-                dv.flags >>= 1;
-                dv.flags |= ((dv.curr.diagonal_quadrant() == 
-                              dv.next.diagonal_quadrant()) << 1);
-                if((dv.flags & 2) == 0)
-                {
-                    bisectrix(dv.curr, dv.next, &dv.xb2, &dv.yb2);
-                }
-                break;
-
-            case outline_round_join:
-                dv.flags >>= 1;
-                dv.flags |= ((dv.curr.diagonal_quadrant() == 
-                              dv.next.diagonal_quadrant()) << 1);
-                break;
-
-            case outline_miter_accurate_join:
-                dv.flags = 0;
-                bisectrix(dv.curr, dv.next, &dv.xb2, &dv.yb2);
-                break;
-            }
-        }
-    }
-
-
-
-
-    //----------------------------------------------------------------------------
-    template<class Renderer, class Coord> 
-    void rasterizer_outline_aa<Renderer, Coord>::render(bool close_polygon)
-    {
-        m_src_vertices.close(close_polygon);
-        draw_vars dv;
-        const vertex_storage_type::value_type* v;
-        int x1;
-        int y1;
-        int x2;
-        int y2;
-        int lprev;
-
-        if(close_polygon)
-        {
-            if(m_src_vertices.size() >= 3)
-            {
-                dv.idx = 2;
-
-                v     = &m_src_vertices[m_src_vertices.size() - 1];
-                x1    = v->x;
-                y1    = v->y;
-                lprev = v->len;
-
-                v  = &m_src_vertices[0];
-                x2 = v->x;
-                y2 = v->y;
-                dv.lcurr = v->len;
-                line_parameters prev(x1, y1, x2, y2, lprev);
-
-                v = &m_src_vertices[1];
-                dv.x1    = v->x;
-                dv.y1    = v->y;
-                dv.lnext = v->len;
-                dv.curr = line_parameters(x2, y2, dv.x1, dv.y1, dv.lcurr);
-
-                v = &m_src_vertices[dv.idx];
-                dv.x2 = v->x;
-                dv.y2 = v->y;
-                dv.next = line_parameters(dv.x1, dv.y1, dv.x2, dv.y2, dv.lnext);
-
-                dv.xb1 = 0;
-                dv.yb1 = 0;
-                dv.xb2 = 0;
-                dv.yb2 = 0;
-
-                switch(m_line_join)
-                {
-                case outline_no_join:
-                    dv.flags = 3;
-                    break;
-
-                case outline_miter_join:
-                case outline_round_join:
-                    dv.flags = 
-                            (prev.diagonal_quadrant() == dv.curr.diagonal_quadrant()) |
-                        ((dv.curr.diagonal_quadrant() == dv.next.diagonal_quadrant()) << 1);
-                    break;
-
-                case outline_miter_accurate_join:
-                    dv.flags = 0;
-                    break;
-                }
-
-                if((dv.flags & 1) == 0 && m_line_join != outline_round_join)
-                {
-                    bisectrix(prev, dv.curr, &dv.xb1, &dv.yb1);
-                }
-
-                if((dv.flags & 2) == 0 && m_line_join != outline_round_join)
-                {
-                    bisectrix(dv.curr, dv.next, &dv.xb2, &dv.yb2);
-                }
-                draw(dv, 0, m_src_vertices.size());
-            }
-        }
-        else
-        {
-            switch(m_src_vertices.size())
-            {
-                case 0:
-                case 1:
-                    break;
-
-                case 2:
-                {
-                    v     = &m_src_vertices[0];
-                    x1    = v->x;
-                    y1    = v->y;
-                    lprev = v->len;
-                    v     = &m_src_vertices[1];
-                    x2    = v->x;
-                    y2    = v->y;
-                    line_parameters lp(x1, y1, x2, y2, lprev);
-                    if(m_round_cap) 
-                    {
-                        m_ren->semidot(cmp_dist_start, x1, y1, x1 + (y2 - y1), y1 - (x2 - x1));
-                    }
-                    m_ren->line3(lp, 
-                                 x1 + (y2 - y1), 
-                                 y1 - (x2 - x1),
-                                 x2 + (y2 - y1), 
-                                 y2 - (x2 - x1));
-                    if(m_round_cap) 
-                    {
-                        m_ren->semidot(cmp_dist_end, x2, y2, x2 + (y2 - y1), y2 - (x2 - x1));
-                    }
-                }
-                break;
-
-                case 3:
-                {
-                    int x3, y3;
-                    int lnext;
-                    v     = &m_src_vertices[0];
-                    x1    = v->x;
-                    y1    = v->y;
-                    lprev = v->len;
-                    v     = &m_src_vertices[1];
-                    x2    = v->x;
-                    y2    = v->y;
-                    lnext = v->len;
-                    v     = &m_src_vertices[2];
-                    x3    = v->x;
-                    y3    = v->y;
-                    line_parameters lp1(x1, y1, x2, y2, lprev);
-                    line_parameters lp2(x2, y2, x3, y3, lnext);
-
-                    if(m_round_cap) 
-                    {
-                        m_ren->semidot(cmp_dist_start, x1, y1, x1 + (y2 - y1), y1 - (x2 - x1));
-                    }
-
-                    if(m_line_join == outline_round_join)
-                    {
-                        m_ren->line3(lp1, x1 + (y2 - y1), y1 - (x2 - x1), 
-                                          x2 + (y2 - y1), y2 - (x2 - x1));
-
-                        m_ren->pie(x2, y2, x2 + (y2 - y1), y2 - (x2 - x1),
-                                           x2 + (y3 - y2), y2 - (x3 - x2));
-
-                        m_ren->line3(lp2, x2 + (y3 - y2), y2 - (x3 - x2),
-                                          x3 + (y3 - y2), y3 - (x3 - x2));
-                    }
-                    else
-                    {
-                        bisectrix(lp1, lp2, &dv.xb1, &dv.yb1);
-                        m_ren->line3(lp1, x1 + (y2 - y1), y1 - (x2 - x1),
-                                          dv.xb1,         dv.yb1);
-
-                        m_ren->line3(lp2, dv.xb1,         dv.yb1,
-                                          x3 + (y3 - y2), y3 - (x3 - x2));
-                    }
-                    if(m_round_cap) 
-                    {
-                        m_ren->semidot(cmp_dist_end, x3, y3, x3 + (y3 - y2), y3 - (x3 - x2));
-                    }
-                }
-                break;
-
-                default:
-                {
-                    dv.idx = 3;
-
-                    v     = &m_src_vertices[0];
-                    x1    = v->x;
-                    y1    = v->y;
-                    lprev = v->len;
-
-                    v  = &m_src_vertices[1];
-                    x2 = v->x;
-                    y2 = v->y;
-                    dv.lcurr = v->len;
-                    line_parameters prev(x1, y1, x2, y2, lprev);
-
-                    v = &m_src_vertices[2];
-                    dv.x1    = v->x;
-                    dv.y1    = v->y;
-                    dv.lnext = v->len;
-                    dv.curr = line_parameters(x2, y2, dv.x1, dv.y1, dv.lcurr);
-
-                    v = &m_src_vertices[dv.idx];
-                    dv.x2 = v->x;
-                    dv.y2 = v->y;
-                    dv.next = line_parameters(dv.x1, dv.y1, dv.x2, dv.y2, dv.lnext);
-
-                    dv.xb1 = 0;
-                    dv.yb1 = 0;
-                    dv.xb2 = 0;
-                    dv.yb2 = 0;
-
-                    switch(m_line_join)
-                    {
-                    case outline_no_join:
-                        dv.flags = 3;
-                        break;
-
-                    case outline_miter_join:
-                    case outline_round_join:
-                        dv.flags = 
-                                (prev.diagonal_quadrant() == dv.curr.diagonal_quadrant()) |
-                            ((dv.curr.diagonal_quadrant() == dv.next.diagonal_quadrant()) << 1);
-                        break;
-
-                    case outline_miter_accurate_join:
-                        dv.flags = 0;
-                        break;
-                    }
-
-                    if(m_round_cap) 
-                    {
-                        m_ren->semidot(cmp_dist_start, x1, y1, x1 + (y2 - y1), y1 - (x2 - x1));
-                    }
-                    if((dv.flags & 1) == 0)
-                    {
-                        if(m_line_join == outline_round_join)
-                        {
-                            m_ren->line3(prev, x1 + (y2 - y1), y1 - (x2 - x1),
-                                               x2 + (y2 - y1), y2 - (x2 - x1));
-                            m_ren->pie(prev.x2, prev.y2, 
-                                       x2 + (y2 - y1), y2 - (x2 - x1),
-                                       dv.curr.x1 + (dv.curr.y2 - dv.curr.y1), 
-                                       dv.curr.y1 - (dv.curr.x2 - dv.curr.x1));
-                        }
-                        else
-                        {
-                            bisectrix(prev, dv.curr, &dv.xb1, &dv.yb1);
-                            m_ren->line3(prev, x1 + (y2 - y1), y1 - (x2 - x1),
-                                               dv.xb1,         dv.yb1);
-                        }
-                    }
-                    else
-                    {
-                        m_ren->line1(prev, 
-                                     x1 + (y2 - y1), 
-                                     y1 - (x2 - x1));
-                    }
-                    if((dv.flags & 2) == 0 && m_line_join != outline_round_join)
-                    {
-                        bisectrix(dv.curr, dv.next, &dv.xb2, &dv.yb2);
-                    }
-
-                    draw(dv, 1, m_src_vertices.size() - 2);
-
-                    if((dv.flags & 1) == 0)
-                    {
-                        if(m_line_join == outline_round_join)
-                        {
-                            m_ren->line3(dv.curr, 
-                                         dv.curr.x1 + (dv.curr.y2 - dv.curr.y1), 
-                                         dv.curr.y1 - (dv.curr.x2 - dv.curr.x1),
-                                         dv.curr.x2 + (dv.curr.y2 - dv.curr.y1), 
-                                         dv.curr.y2 - (dv.curr.x2 - dv.curr.x1));
-                        }
-                        else
-                        {
-                            m_ren->line3(dv.curr, dv.xb1, dv.yb1,
-                                         dv.curr.x2 + (dv.curr.y2 - dv.curr.y1), 
-                                         dv.curr.y2 - (dv.curr.x2 - dv.curr.x1));
-                        }
-                    }
-                    else
-                    {
-                        m_ren->line2(dv.curr, 
-                                     dv.curr.x2 + (dv.curr.y2 - dv.curr.y1), 
-                                     dv.curr.y2 - (dv.curr.x2 - dv.curr.x1));
-                    }
-                    if(m_round_cap) 
-                    {
-                        m_ren->semidot(cmp_dist_end, dv.curr.x2, dv.curr.y2,
-                                       dv.curr.x2 + (dv.curr.y2 - dv.curr.y1),
-                                       dv.curr.y2 - (dv.curr.x2 - dv.curr.x1));
-                    }
-
-                }
-                break;
-            }
-        }
-        m_src_vertices.remove_all();
-    }
-
-
-}
-
-
-#endif
-

Sources/libagg/agg-2.4/agg_rasterizer_scanline_aa.h

@@ -1,510 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-//
-// The author gratefully acknowleges the support of David Turner, 
-// Robert Wilhelm, and Werner Lemberg - the authors of the FreeType 
-// libray - in producing this work. See http://www.freetype.org for details.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// Adaptation for 32-bit screen coordinates has been sponsored by 
-// Liberty Technology Systems, Inc., visit http://lib-sys.com
-//
-// Liberty Technology Systems, Inc. is the provider of
-// PostScript and PDF technology for software developers.
-// 
-//----------------------------------------------------------------------------
-#ifndef AGG_RASTERIZER_SCANLINE_AA_INCLUDED
-#define AGG_RASTERIZER_SCANLINE_AA_INCLUDED
-
-#include "agg_rasterizer_cells_aa.h"
-#include "agg_rasterizer_sl_clip.h"
-#include "agg_gamma_functions.h"
-
-
-namespace agg
-{
-
-
-    //-----------------------------------------------------------------cell_aa
-    // A pixel cell. There're no constructors defined and it was done 
-    // intentionally in order to avoid extra overhead when allocating an 
-    // array of cells.
-    struct cell_aa
-    {
-        int x;
-        int y;
-        int cover;
-        int area;
-
-        void initial()
-        {
-            x = 0x7FFFFFFF;
-            y = 0x7FFFFFFF;
-            cover = 0;
-            area  = 0;
-        }
-
-        void style(const cell_aa&) {}
-
-        int not_equal(int ex, int ey, const cell_aa&) const
-        {
-            return (ex - x) | (ey - y);
-        }
-    };
-
-
-    //==================================================rasterizer_scanline_aa
-    // Polygon rasterizer that is used to render filled polygons with 
-    // high-quality Anti-Aliasing. Internally, by default, the class uses 
-    // integer coordinates in format 24.8, i.e. 24 bits for integer part 
-    // and 8 bits for fractional - see poly_subpixel_shift. This class can be 
-    // used in the following  way:
-    //
-    // 1. filling_rule(filling_rule_e ft) - optional.
-    //
-    // 2. gamma() - optional.
-    //
-    // 3. reset()
-    //
-    // 4. move_to(x, y) / line_to(x, y) - make the polygon. One can create 
-    //    more than one contour, but each contour must consist of at least 3
-    //    vertices, i.e. move_to(x1, y1); line_to(x2, y2); line_to(x3, y3);
-    //    is the absolute minimum of vertices that define a triangle.
-    //    The algorithm does not check either the number of vertices nor
-    //    coincidence of their coordinates, but in the worst case it just 
-    //    won't draw anything.
-    //    The orger of the vertices (clockwise or counterclockwise) 
-    //    is important when using the non-zero filling rule (fill_non_zero).
-    //    In this case the vertex order of all the contours must be the same
-    //    if you want your intersecting polygons to be without "holes".
-    //    You actually can use different vertices order. If the contours do not 
-    //    intersect each other the order is not important anyway. If they do, 
-    //    contours with the same vertex order will be rendered without "holes" 
-    //    while the intersecting contours with different orders will have "holes".
-    //
-    // filling_rule() and gamma() can be called anytime before "sweeping".
-    //------------------------------------------------------------------------
-    template<class Clip=rasterizer_sl_clip_int> class rasterizer_scanline_aa
-    {
-        enum status
-        {
-            status_initial,
-            status_move_to,
-            status_line_to,
-            status_closed
-        };
-
-    public:
-        typedef Clip                      clip_type;
-        typedef typename Clip::conv_type  conv_type;
-        typedef typename Clip::coord_type coord_type;
-
-        enum aa_scale_e
-        {
-            aa_shift  = 8,
-            aa_scale  = 1 << aa_shift,
-            aa_mask   = aa_scale - 1,
-            aa_scale2 = aa_scale * 2,
-            aa_mask2  = aa_scale2 - 1
-        };
-
-        //--------------------------------------------------------------------
-        rasterizer_scanline_aa() : 
-            m_outline(),
-            m_clipper(),
-            m_filling_rule(fill_non_zero),
-            m_auto_close(true),
-            m_start_x(0),
-            m_start_y(0),
-            m_status(status_initial)
-        {
-            int i;
-            for(i = 0; i < aa_scale; i++) m_gamma[i] = i;
-        }
-
-        //--------------------------------------------------------------------
-        template<class GammaF> 
-        rasterizer_scanline_aa(const GammaF& gamma_function) : 
-            m_outline(),
-            m_clipper(m_outline),
-            m_filling_rule(fill_non_zero),
-            m_auto_close(true),
-            m_start_x(0),
-            m_start_y(0),
-            m_status(status_initial)
-        {
-            gamma(gamma_function);
-        }
-
-        //--------------------------------------------------------------------
-        void reset(); 
-        void reset_clipping();
-        void clip_box(double x1, double y1, double x2, double y2);
-        void filling_rule(filling_rule_e filling_rule);
-        void auto_close(bool flag) { m_auto_close = flag; }
-
-        //--------------------------------------------------------------------
-        template<class GammaF> void gamma(const GammaF& gamma_function)
-        { 
-            int i;
-            for(i = 0; i < aa_scale; i++)
-            {
-                m_gamma[i] = uround(gamma_function(double(i) / aa_mask) * aa_mask);
-            }
-        }
-
-        //--------------------------------------------------------------------
-        unsigned apply_gamma(unsigned cover) const 
-        { 
-            return m_gamma[cover]; 
-        }
-
-        //--------------------------------------------------------------------
-        void move_to(int x, int y);
-        void line_to(int x, int y);
-        void move_to_d(double x, double y);
-        void line_to_d(double x, double y);
-        void close_polygon();
-        void add_vertex(double x, double y, unsigned cmd);
-
-        void edge(int x1, int y1, int x2, int y2);
-        void edge_d(double x1, double y1, double x2, double y2);
-
-        //-------------------------------------------------------------------
-        template<class VertexSource>
-        void add_path(VertexSource& vs, unsigned path_id=0)
-        {
-            double x;
-            double y;
-
-            unsigned cmd;
-            vs.rewind(path_id);
-            if(m_outline.sorted()) reset();
-            while(!is_stop(cmd = vs.vertex(&x, &y)))
-            {
-                add_vertex(x, y, cmd);
-            }
-        }
-        
-        //--------------------------------------------------------------------
-        int min_x() const { return m_outline.min_x(); }
-        int min_y() const { return m_outline.min_y(); }
-        int max_x() const { return m_outline.max_x(); }
-        int max_y() const { return m_outline.max_y(); }
-
-        //--------------------------------------------------------------------
-        void sort();
-        bool rewind_scanlines();
-        bool navigate_scanline(int y);
-
-        //--------------------------------------------------------------------
-        AGG_INLINE unsigned calculate_alpha(int area) const
-        {
-            int cover = area >> (poly_subpixel_shift*2 + 1 - aa_shift);
-
-            if(cover < 0) cover = -cover;
-            if(m_filling_rule == fill_even_odd)
-            {
-                cover &= aa_mask2;
-                if(cover > aa_scale)
-                {
-                    cover = aa_scale2 - cover;
-                }
-            }
-            if(cover > aa_mask) cover = aa_mask;
-            return m_gamma[cover];
-        }
-
-        //--------------------------------------------------------------------
-        template<class Scanline> bool sweep_scanline(Scanline& sl)
-        {
-            for(;;)
-            {
-                if(m_scan_y > m_outline.max_y()) return false;
-                sl.reset_spans();
-                unsigned num_cells = m_outline.scanline_num_cells(m_scan_y);
-                const cell_aa* const* cells = m_outline.scanline_cells(m_scan_y);
-                int cover = 0;
-
-                while(num_cells)
-                {
-                    const cell_aa* cur_cell = *cells;
-                    int x    = cur_cell->x;
-                    int area = cur_cell->area;
-                    unsigned alpha;
-
-                    cover += cur_cell->cover;
-
-                    //accumulate all cells with the same X
-                    while(--num_cells)
-                    {
-                        cur_cell = *++cells;
-                        if(cur_cell->x != x) break;
-                        area  += cur_cell->area;
-                        cover += cur_cell->cover;
-                    }
-
-                    if(area)
-                    {
-                        alpha = calculate_alpha((cover << (poly_subpixel_shift + 1)) - area);
-                        if(alpha)
-                        {
-                            sl.add_cell(x, alpha);
-                        }
-                        x++;
-                    }
-
-                    if(num_cells && cur_cell->x > x)
-                    {
-                        alpha = calculate_alpha(cover << (poly_subpixel_shift + 1));
-                        if(alpha)
-                        {
-                            sl.add_span(x, cur_cell->x - x, alpha);
-                        }
-                    }
-                }
-        
-                if(sl.num_spans()) break;
-                ++m_scan_y;
-            }
-
-            sl.finalize(m_scan_y);
-            ++m_scan_y;
-            return true;
-        }
-
-        //--------------------------------------------------------------------
-        bool hit_test(int tx, int ty);
-
-
-    private:
-        //--------------------------------------------------------------------
-        // Disable copying
-        rasterizer_scanline_aa(const rasterizer_scanline_aa<Clip>&);
-        const rasterizer_scanline_aa<Clip>& 
-        operator = (const rasterizer_scanline_aa<Clip>&);
-
-    private:
-        rasterizer_cells_aa<cell_aa> m_outline;
-        clip_type      m_clipper;
-        int            m_gamma[aa_scale];
-        filling_rule_e m_filling_rule;
-        bool           m_auto_close;
-        coord_type     m_start_x;
-        coord_type     m_start_y;
-        unsigned       m_status;
-        int            m_scan_y;
-    };
-
-
-
-
-
-
-
-
-
-
-
-
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    void rasterizer_scanline_aa<Clip>::reset() 
-    { 
-        m_outline.reset(); 
-        m_status = status_initial;
-    }
-
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    void rasterizer_scanline_aa<Clip>::filling_rule(filling_rule_e filling_rule) 
-    { 
-        m_filling_rule = filling_rule; 
-    }
-
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    void rasterizer_scanline_aa<Clip>::clip_box(double x1, double y1, 
-                                                double x2, double y2)
-    {
-        reset();
-        m_clipper.clip_box(conv_type::upscale(x1), conv_type::upscale(y1), 
-                           conv_type::upscale(x2), conv_type::upscale(y2));
-    }
-
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    void rasterizer_scanline_aa<Clip>::reset_clipping()
-    {
-        reset();
-        m_clipper.reset_clipping();
-    }
-
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    void rasterizer_scanline_aa<Clip>::close_polygon()
-    {
-        if(m_status == status_line_to)
-        {
-            m_clipper.line_to(m_outline, m_start_x, m_start_y);
-            m_status = status_closed;
-        }
-    }
-
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    void rasterizer_scanline_aa<Clip>::move_to(int x, int y)
-    {
-        if(m_outline.sorted()) reset();
-        if(m_auto_close) close_polygon();
-        m_clipper.move_to(m_start_x = conv_type::downscale(x), 
-                          m_start_y = conv_type::downscale(y));
-        m_status = status_move_to;
-    }
-
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    void rasterizer_scanline_aa<Clip>::line_to(int x, int y)
-    {
-        m_clipper.line_to(m_outline, 
-                          conv_type::downscale(x), 
-                          conv_type::downscale(y));
-        m_status = status_line_to;
-    }
-
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    void rasterizer_scanline_aa<Clip>::move_to_d(double x, double y) 
-    { 
-        if(m_outline.sorted()) reset();
-        if(m_auto_close) close_polygon();
-        m_clipper.move_to(m_start_x = conv_type::upscale(x), 
-                          m_start_y = conv_type::upscale(y)); 
-        m_status = status_move_to;
-    }
-
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    void rasterizer_scanline_aa<Clip>::line_to_d(double x, double y) 
-    { 
-        m_clipper.line_to(m_outline, 
-                          conv_type::upscale(x), 
-                          conv_type::upscale(y)); 
-        m_status = status_line_to;
-    }
-
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    void rasterizer_scanline_aa<Clip>::add_vertex(double x, double y, unsigned cmd)
-    {
-        if(is_move_to(cmd)) 
-        {
-            move_to_d(x, y);
-        }
-        else 
-        if(is_vertex(cmd))
-        {
-            line_to_d(x, y);
-        }
-        else
-        if(is_close(cmd))
-        {
-            close_polygon();
-        }
-    }
-
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    void rasterizer_scanline_aa<Clip>::edge(int x1, int y1, int x2, int y2)
-    {
-        if(m_outline.sorted()) reset();
-        m_clipper.move_to(conv_type::downscale(x1), conv_type::downscale(y1));
-        m_clipper.line_to(m_outline, 
-                          conv_type::downscale(x2), 
-                          conv_type::downscale(y2));
-        m_status = status_move_to;
-    }
-    
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    void rasterizer_scanline_aa<Clip>::edge_d(double x1, double y1, 
-                                              double x2, double y2)
-    {
-        if(m_outline.sorted()) reset();
-        m_clipper.move_to(conv_type::upscale(x1), conv_type::upscale(y1)); 
-        m_clipper.line_to(m_outline, 
-                          conv_type::upscale(x2), 
-                          conv_type::upscale(y2)); 
-        m_status = status_move_to;
-    }
-
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    void rasterizer_scanline_aa<Clip>::sort()
-    {
-        if(m_auto_close) close_polygon();
-        m_outline.sort_cells();
-    }
-
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    AGG_INLINE bool rasterizer_scanline_aa<Clip>::rewind_scanlines()
-    {
-        if(m_auto_close) close_polygon();
-        m_outline.sort_cells();
-        if(m_outline.total_cells() == 0) 
-        {
-            return false;
-        }
-        m_scan_y = m_outline.min_y();
-        return true;
-    }
-
-
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    AGG_INLINE bool rasterizer_scanline_aa<Clip>::navigate_scanline(int y)
-    {
-        if(m_auto_close) close_polygon();
-        m_outline.sort_cells();
-        if(m_outline.total_cells() == 0 || 
-           y < m_outline.min_y() || 
-           y > m_outline.max_y()) 
-        {
-            return false;
-        }
-        m_scan_y = y;
-        return true;
-    }
-
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    bool rasterizer_scanline_aa<Clip>::hit_test(int tx, int ty)
-    {
-        if(!navigate_scanline(ty)) return false;
-        scanline_hit_test sl(tx);
-        sweep_scanline(sl);
-        return sl.hit();
-    }
-
-
-
-}
-
-
-
-#endif
-

Sources/libagg/agg-2.4/agg_rasterizer_sl_clip.h

@@ -1,351 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-#ifndef AGG_RASTERIZER_SL_CLIP_INCLUDED
-#define AGG_RASTERIZER_SL_CLIP_INCLUDED
-
-#include "agg_clip_liang_barsky.h"
-
-namespace agg
-{
-    //--------------------------------------------------------poly_max_coord_e
-    enum poly_max_coord_e
-    {
-        poly_max_coord = (1 << 30) - 1 //----poly_max_coord
-    };
-    
-    //------------------------------------------------------------ras_conv_int
-    struct ras_conv_int
-    {
-        typedef int coord_type;
-        static AGG_INLINE int mul_div(double a, double b, double c)
-        {
-            return iround(a * b / c);
-        }
-        static int xi(int v) { return v; }
-        static int yi(int v) { return v; }
-        static int upscale(double v) { return iround(v * poly_subpixel_scale); }
-        static int downscale(int v)  { return v; }
-    };
-
-    //--------------------------------------------------------ras_conv_int_sat
-    struct ras_conv_int_sat
-    {
-        typedef int coord_type;
-        static AGG_INLINE int mul_div(double a, double b, double c)
-        {
-            return saturation<poly_max_coord>::iround(a * b / c);
-        }
-        static int xi(int v) { return v; }
-        static int yi(int v) { return v; }
-        static int upscale(double v) 
-        { 
-            return saturation<poly_max_coord>::iround(v * poly_subpixel_scale); 
-        }
-        static int downscale(int v) { return v; }
-    };
-
-    //---------------------------------------------------------ras_conv_int_3x
-    struct ras_conv_int_3x
-    {
-        typedef int coord_type;
-        static AGG_INLINE int mul_div(double a, double b, double c)
-        {
-            return iround(a * b / c);
-        }
-        static int xi(int v) { return v * 3; }
-        static int yi(int v) { return v; }
-        static int upscale(double v) { return iround(v * poly_subpixel_scale); }
-        static int downscale(int v)  { return v; }
-    };
-
-    //-----------------------------------------------------------ras_conv_dbl
-    struct ras_conv_dbl
-    {
-        typedef double coord_type;
-        static AGG_INLINE double mul_div(double a, double b, double c)
-        {
-            return a * b / c;
-        }
-        static int xi(double v) { return iround(v * poly_subpixel_scale); }
-        static int yi(double v) { return iround(v * poly_subpixel_scale); }
-        static double upscale(double v) { return v; }
-        static double downscale(int v)  { return v / double(poly_subpixel_scale); }
-    };
-
-    //--------------------------------------------------------ras_conv_dbl_3x
-    struct ras_conv_dbl_3x
-    {
-        typedef double coord_type;
-        static AGG_INLINE double mul_div(double a, double b, double c)
-        {
-            return a * b / c;
-        }
-        static int xi(double v) { return iround(v * poly_subpixel_scale * 3); }
-        static int yi(double v) { return iround(v * poly_subpixel_scale); }
-        static double upscale(double v) { return v; }
-        static double downscale(int v)  { return v / double(poly_subpixel_scale); }
-    };
-
-
-
-
-
-    //------------------------------------------------------rasterizer_sl_clip
-    template<class Conv> class rasterizer_sl_clip
-    {
-    public:
-        typedef Conv                      conv_type;
-        typedef typename Conv::coord_type coord_type;
-        typedef rect_base<coord_type>     rect_type;
-
-        //--------------------------------------------------------------------
-        rasterizer_sl_clip() :  
-            m_clip_box(0,0,0,0),
-            m_x1(0),
-            m_y1(0),
-            m_f1(0),
-            m_clipping(false) 
-        {}
-
-        //--------------------------------------------------------------------
-        void reset_clipping()
-        {
-            m_clipping = false;
-        }
-
-        //--------------------------------------------------------------------
-        void clip_box(coord_type x1, coord_type y1, coord_type x2, coord_type y2)
-        {
-            m_clip_box = rect_type(x1, y1, x2, y2);
-            m_clip_box.normalize();
-            m_clipping = true;
-        }
-
-        //--------------------------------------------------------------------
-        void move_to(coord_type x1, coord_type y1)
-        {
-            m_x1 = x1;
-            m_y1 = y1;
-            if(m_clipping) m_f1 = clipping_flags(x1, y1, m_clip_box);
-        }
-
-    private:
-        //------------------------------------------------------------------------
-        template<class Rasterizer>
-        AGG_INLINE void line_clip_y(Rasterizer& ras,
-                                    coord_type x1, coord_type y1, 
-                                    coord_type x2, coord_type y2, 
-                                    unsigned   f1, unsigned   f2) const
-        {
-            f1 &= 10;
-            f2 &= 10;
-            if((f1 | f2) == 0)
-            {
-                // Fully visible
-                ras.line(Conv::xi(x1), Conv::yi(y1), Conv::xi(x2), Conv::yi(y2)); 
-            }
-            else
-            {
-                if(f1 == f2)
-                {
-                    // Invisible by Y
-                    return;
-                }
-
-                coord_type tx1 = x1;
-                coord_type ty1 = y1;
-                coord_type tx2 = x2;
-                coord_type ty2 = y2;
-
-                if(f1 & 8) // y1 < clip.y1
-                {
-                    tx1 = x1 + Conv::mul_div(m_clip_box.y1-y1, x2-x1, y2-y1);
-                    ty1 = m_clip_box.y1;
-                }
-
-                if(f1 & 2) // y1 > clip.y2
-                {
-                    tx1 = x1 + Conv::mul_div(m_clip_box.y2-y1, x2-x1, y2-y1);
-                    ty1 = m_clip_box.y2;
-                }
-
-                if(f2 & 8) // y2 < clip.y1
-                {
-                    tx2 = x1 + Conv::mul_div(m_clip_box.y1-y1, x2-x1, y2-y1);
-                    ty2 = m_clip_box.y1;
-                }
-
-                if(f2 & 2) // y2 > clip.y2
-                {
-                    tx2 = x1 + Conv::mul_div(m_clip_box.y2-y1, x2-x1, y2-y1);
-                    ty2 = m_clip_box.y2;
-                }
-                ras.line(Conv::xi(tx1), Conv::yi(ty1), 
-                         Conv::xi(tx2), Conv::yi(ty2)); 
-            }
-        }
-
-
-    public:
-        //--------------------------------------------------------------------
-        template<class Rasterizer>
-        void line_to(Rasterizer& ras, coord_type x2, coord_type y2)
-        {
-            if(m_clipping)
-            {
-                unsigned f2 = clipping_flags(x2, y2, m_clip_box);
-
-                if((m_f1 & 10) == (f2 & 10) && (m_f1 & 10) != 0)
-                {
-                    // Invisible by Y
-                    m_x1 = x2;
-                    m_y1 = y2;
-                    m_f1 = f2;
-                    return;
-                }
-
-                coord_type x1 = m_x1;
-                coord_type y1 = m_y1;
-                unsigned   f1 = m_f1;
-                coord_type y3, y4;
-                unsigned   f3, f4;
-
-                switch(((f1 & 5) << 1) | (f2 & 5))
-                {
-                case 0: // Visible by X
-                    line_clip_y(ras, x1, y1, x2, y2, f1, f2);
-                    break;
-
-                case 1: // x2 > clip.x2
-                    y3 = y1 + Conv::mul_div(m_clip_box.x2-x1, y2-y1, x2-x1);
-                    f3 = clipping_flags_y(y3, m_clip_box);
-                    line_clip_y(ras, x1, y1, m_clip_box.x2, y3, f1, f3);
-                    line_clip_y(ras, m_clip_box.x2, y3, m_clip_box.x2, y2, f3, f2);
-                    break;
-
-                case 2: // x1 > clip.x2
-                    y3 = y1 + Conv::mul_div(m_clip_box.x2-x1, y2-y1, x2-x1);
-                    f3 = clipping_flags_y(y3, m_clip_box);
-                    line_clip_y(ras, m_clip_box.x2, y1, m_clip_box.x2, y3, f1, f3);
-                    line_clip_y(ras, m_clip_box.x2, y3, x2, y2, f3, f2);
-                    break;
-
-                case 3: // x1 > clip.x2 && x2 > clip.x2
-                    line_clip_y(ras, m_clip_box.x2, y1, m_clip_box.x2, y2, f1, f2);
-                    break;
-
-                case 4: // x2 < clip.x1
-                    y3 = y1 + Conv::mul_div(m_clip_box.x1-x1, y2-y1, x2-x1);
-                    f3 = clipping_flags_y(y3, m_clip_box);
-                    line_clip_y(ras, x1, y1, m_clip_box.x1, y3, f1, f3);
-                    line_clip_y(ras, m_clip_box.x1, y3, m_clip_box.x1, y2, f3, f2);
-                    break;
-
-                case 6: // x1 > clip.x2 && x2 < clip.x1
-                    y3 = y1 + Conv::mul_div(m_clip_box.x2-x1, y2-y1, x2-x1);
-                    y4 = y1 + Conv::mul_div(m_clip_box.x1-x1, y2-y1, x2-x1);
-                    f3 = clipping_flags_y(y3, m_clip_box);
-                    f4 = clipping_flags_y(y4, m_clip_box);
-                    line_clip_y(ras, m_clip_box.x2, y1, m_clip_box.x2, y3, f1, f3);
-                    line_clip_y(ras, m_clip_box.x2, y3, m_clip_box.x1, y4, f3, f4);
-                    line_clip_y(ras, m_clip_box.x1, y4, m_clip_box.x1, y2, f4, f2);
-                    break;
-
-                case 8: // x1 < clip.x1
-                    y3 = y1 + Conv::mul_div(m_clip_box.x1-x1, y2-y1, x2-x1);
-                    f3 = clipping_flags_y(y3, m_clip_box);
-                    line_clip_y(ras, m_clip_box.x1, y1, m_clip_box.x1, y3, f1, f3);
-                    line_clip_y(ras, m_clip_box.x1, y3, x2, y2, f3, f2);
-                    break;
-
-                case 9:  // x1 < clip.x1 && x2 > clip.x2
-                    y3 = y1 + Conv::mul_div(m_clip_box.x1-x1, y2-y1, x2-x1);
-                    y4 = y1 + Conv::mul_div(m_clip_box.x2-x1, y2-y1, x2-x1);
-                    f3 = clipping_flags_y(y3, m_clip_box);
-                    f4 = clipping_flags_y(y4, m_clip_box);
-                    line_clip_y(ras, m_clip_box.x1, y1, m_clip_box.x1, y3, f1, f3);
-                    line_clip_y(ras, m_clip_box.x1, y3, m_clip_box.x2, y4, f3, f4);
-                    line_clip_y(ras, m_clip_box.x2, y4, m_clip_box.x2, y2, f4, f2);
-                    break;
-
-                case 12: // x1 < clip.x1 && x2 < clip.x1
-                    line_clip_y(ras, m_clip_box.x1, y1, m_clip_box.x1, y2, f1, f2);
-                    break;
-                }
-                m_f1 = f2;
-            }
-            else
-            {
-                ras.line(Conv::xi(m_x1), Conv::yi(m_y1), 
-                         Conv::xi(x2),   Conv::yi(y2)); 
-            }
-            m_x1 = x2;
-            m_y1 = y2;
-        }
-
-
-    private:
-        rect_type        m_clip_box;
-        coord_type       m_x1;
-        coord_type       m_y1;
-        unsigned         m_f1;
-        bool             m_clipping;
-    };
-
-
-
-
-    //---------------------------------------------------rasterizer_sl_no_clip
-    class rasterizer_sl_no_clip
-    {
-    public:
-        typedef ras_conv_int conv_type;
-        typedef int          coord_type;
-
-        rasterizer_sl_no_clip() : m_x1(0), m_y1(0) {}
-
-        void reset_clipping() {}
-        void clip_box(coord_type x1, coord_type y1, coord_type x2, coord_type y2) {}
-        void move_to(coord_type x1, coord_type y1) { m_x1 = x1; m_y1 = y1; }
-
-        template<class Rasterizer>
-        void line_to(Rasterizer& ras, coord_type x2, coord_type y2) 
-        { 
-            ras.line(m_x1, m_y1, x2, y2); 
-            m_x1 = x2; 
-            m_y1 = y2;
-        }
-
-    private:
-        int m_x1, m_y1;
-    };
-
-
-    //                                         -----rasterizer_sl_clip_int
-    //                                         -----rasterizer_sl_clip_int_sat
-    //                                         -----rasterizer_sl_clip_int_3x
-    //                                         -----rasterizer_sl_clip_dbl
-    //                                         -----rasterizer_sl_clip_dbl_3x
-    //------------------------------------------------------------------------
-    typedef rasterizer_sl_clip<ras_conv_int>     rasterizer_sl_clip_int;
-    typedef rasterizer_sl_clip<ras_conv_int_sat> rasterizer_sl_clip_int_sat;
-    typedef rasterizer_sl_clip<ras_conv_int_3x>  rasterizer_sl_clip_int_3x;
-    typedef rasterizer_sl_clip<ras_conv_dbl>     rasterizer_sl_clip_dbl;
-    typedef rasterizer_sl_clip<ras_conv_dbl_3x>  rasterizer_sl_clip_dbl_3x;
-
-
-}
-
-#endif