Mirrors_UI_SDK/fltk
1
0
Fork 0
mirror of https://github.com/fltk/fltk.git synced 2026-02-06 00:01:57 +08:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Remove experimental platforms Android, Pico, SDL (PR #376)

Browse Source 
... as discussed in fltk.coredev: "FLTK 1.4.0 release schedule"
https://groups.google.com/g/fltkcoredev/c/PDbHTRpXVh0/m/JqboexZ_AwAJ
This commit is contained in:
Albrecht Schlosser
2022-01-23 01:33:47 +01:00
parent b275ff0715
commit 04ccc8cc46
84 changed files with 74 additions and 16613 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
.gitattributes vendored
View File

@@ -41,9 +41,6 @@ misc/update_config_scripts eol=lf
*.rc eol=crlf
*.bat eol=crlf
# Android Studio special support file (Windows .bat file)
ide/AndroidStudio3/gradlew.rename_to_bat eol=crlf
# binary files
*.ico binary

22
CMake/Android/AndroidManifest.xml.in
View File

@@ -1,22 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="org.fltk.@ANDROID_APP_NAME@"
android:versionCode="1"
android:versionName="1.0">
<application
android:allowBackup="false"
android:fullBackupContent="false"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:hasCode="false">
<activity android:name="android.app.NativeActivity"
android:label="@string/app_name">
<meta-data android:name="android.app.lib_name"
android:value="test_@ANDROID_APP_NAME@" />
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>

60
CMake/Android/CMakeList.txt.in
View File

@@ -1,60 +0,0 @@
#
# Copyright (C) The Android Open Source Project
#
# Licensed under the Apache 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
#
# http://www.apache.org/licenses/LICENSE-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.
#
# Modified to be a template for Android builds in FLTK
# Copyright 2019 Matthias Melcher and others
#
cmake_minimum_required(VERSION 3.4.1)
set(FLTK_DIR "@ANDROID_FLTK_DIR@")
set(FLTK_IDE_DIR "../../../..")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
# FIXME: this includes the entire CMakeLists again, creating an entire library
# build in every target
# TODO: create separate targets for all fltk libraries that can be easily
# linked by all app targets
add_subdirectory("${FLTK_DIR}/" "${CMAKE_CURRENT_BINARY_DIR}/lib" EXCLUDE_FROM_ALL)
# run Fluid build steps for every .fl file, if any
@ANDROID_FLUID_COMMANDS@
# now build app's shared lib
add_library(
test_@ANDROID_APP_NAME@ SHARED
@ANDROID_APP_SOURCES@)
target_include_directories(
test_@ANDROID_APP_NAME@ PRIVATE
${FLTK_DIR}/
${FLTK_IDE_DIR}/ )
# Export ANativeActivity_onCreate()
# Refer to: https://github.com/android-ndk/ndk/issues/381.
set(CMAKE_SHARED_LINKER_FLAGS
"${CMAKE_SHARED_LINKER_FLAGS} -u ANativeActivity_onCreate")
# add lib dependencies
# FIXME: apps may depend on additional fltk libraries; thise dependencies
# must be created in the CREATE_ANDROID_IDE_FOR_TEST macro
target_link_libraries(
test_@ANDROID_APP_NAME@
fltk
android
log
m
)

137
CMake/Android/HelloAndroid.cxx.in
View File

@@ -1,137 +0,0 @@
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache 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
*
* http://www.apache.org/licenses/LICENSE-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.
*
*/
#include "../../../test/@ANDROID_APP_NAME@.cxx"
/*
Missing:
- screen scale and size: most desktop apps expect to be in a draggable window
on a larger desktop surface. For Android, there is usually no desktop, and
screen resolution is often very high, so that a regular FLTK window would
hide as a tiny gray spot in the top left corner
* windows should probably be centered by default
? the screen resolution should adapt to the first opened window
? we should be able to hint at a prefered screen resolution
* drawing call must scale at some point (line width!)
* rotating the screen must call the app handler and(?) window resize
* proportions: pixels should be square
Need Work:
- Fl_Android_Graphics_Driver::pie(int) needs refactoring
- ...::line(...) has round ing issues (see rounded box type)
- grab() not working when leaving window (adjuster...)
- scrolling if implemented as a complete redraw. Must implement real scrolling
- the 'hotspot' idea to position dialogs under the mouse cursor makes little sense on touch screen devices
- fix screen when keyboard pops up in front of the text cursor or input field (temporarily shift up?)
- ending 'message' will not quit the app right away, but wait for some timeout
- no support for dead-key entry
- no Shift-Tab
* test/CubeMain.cxx : UNSUPPORTED - needs OpenGL
* test/CubeView.cxx : UNSUPPORTED - needs OpenGL
* test/shape.cxx : UNSUPPORTED - needs OpenGL
* test/cube.cxx : UNSUPPORTED - needs OpenGL
* test/fractals.cxx : UNSUPPORTED - needs OpenGL
* test/fracviewer.cxx : UNSUPPORTED - needs OpenGL
* test/fullscreen.cxx : UNSUPPORTED - needs OpenGL
* test/gl_overlay.cxx : UNSUPPORTED - needs OpenGL
* test/glpuzzle.cxx : UNSUPPORTED - needs OpenGL
* test/mandelbrot.cxx : UNSUPPORTED - needs Fluid
* test/keyboard.cxx : UNSUPPORTED - needs Fluid
* test/CubeViewUI.fl
* test/keyboard_ui.fl
* test/radio.fl
* test/tree.fl
* test/fast_slow.fl
* test/mandelbrot_ui.fl
* test/resize.fl
* test/valuators.fl
* test/inactive.fl
* test/preferences.fl
* test/tabs.fl
* test/cairo_test.cxx : UNSUPPORTED - needs Cairo
* test/tiled_image.cxx : UNSUPPORTED - X11 only
* test/forms.cxx : UNSUPPORTED - needs Forms
* test/doublebuffer.cxx : FIXME - redering is completely wrong
* test/line_style.cxx : TODO - no line styles yet
* test/list_visuals.cxx : TODO - needs config.h
* test/threads.cxx : TODO - needs config.h for pthreads
* test/animated.cxx : TODO - redering errors (alpha channel?)
* test/native-filechooser.cxx : TODO - not yet implemented
* test/blocks.cxx : TODO - needs config.h
* test/offscreen.cxx : TODO - not yet implemented
* test/overlay.cxx : TODO - no overlay yet
* test/pixmap_browser.cxx : TODO - filebrowser not yet implemented, no images, no printer
* test/clock.cxx : TODO - no system clock call yet
* test/resizebox.cxx : TODO - no window manager yet
* test/rotated_text.cxx : TODO - no rotated text
* test/subwindow.cxx : TODO - no subwindows yet
* test/sudoku.cxx : TODO - sound support is in our way
* test/demo.cxx : TODO - fails to open window, but is is useful at all?
* test/device.cxx : TODO - printing support
* test/tile.cxx : TODO - subwindow support
* test/editor.cxx : TODO - file chooser missing
* test/file_chooser.cxx : TODO - file chooser missing
* test/fonts.cxx : TODO - works, but does not list system fonts or resource fonts
* test/help_dialog.cxx : TODO - not implemented
* test/icon.cxx : TODO - what does this do on Android?
* test/iconize.cxx : TODO - no window manager
* test/utf8.cxx : TODO - window manager, clipping
* test/windowfocus.cxx : TODO - what does this do?
* test/browser.cxx : TODO - needs text resource to load browser content
* test/unittests.cxx : TODO - crashing, no alpha in image drawing, clipping issues
* test/image.cxx : + works
* test/twowin.cxx : + works
* test/table.cxx : + works, but window is much too large for mobile device
* test/cursor.cxx : + works, but no cursor on Android
* test/colbrowser.cxx : + works
* test/checkers.cxx : + works
* test/pixmap.cxx : + works
* test/navigation.cxx : + works
* test/curve.cxx : + works
* test/input_choice.cxx : + works
* test/input.cxx : + works
* test/scroll.cxx : - works ok
- some dirt when a popup draws over another menu button!?
- on touch-screens, menuitem should be selected when released
- on touch-screens, scroll groups should scroll on multitouch, or when not causing any other action
* test/bitmap.cxx : + 'bitmap' works
* test/message.cxx : - 'message' mostly works
- when ending the app, it will not close right away but instead hang around for a few seconds
* test/menubar.cxx : - 'menubar' mostly works including unicode
! pressing 'button' will hang the app
- shortcut modifiers don't work
- right-click does not work (should this be emulated via click-and-hold?)
* test/output.cxx : + 'output' works
* test/ask.cxx : + 'ask' works
* test/button.cxx : + 'button' works, including beep
* test/pack.cxx : + 'pack' works
* test/adjuster.cxx : + 'adjuster' works
* test/arc.cxx : + 'arc' works as expected
* test/minimum.cxx : + 'minimum' works
* test/boxtype.cxx : + 'boxtype' works
* test/buttons.cxx : + 'buttons' works
* test/color_chooser.cxx: + 'color_chooser' works
* test/symbols.cxx : + 'symbols' working as expected
* test/hello.cxx : + 'hello' works fine, italics, shadow, etc.
* test/label.cxx : + 'label' works
*/

BIN
CMake/Android/Roboto-Regular.ttf
View File

Binary file not shown.

26
CMake/Android/app.build.gradle.in
View File

@@ -1,26 +0,0 @@
apply plugin: 'com.android.application'
android {
compileSdkVersion 25
defaultConfig {
applicationId 'org.fltk.@ANDROID_APP_NAME@'
minSdkVersion 14
targetSdkVersion 25
externalNativeBuild {
cmake {
arguments '-DANDROID_STL=c++_shared'
}
}
}
buildTypes {
release {
minifyEnabled false
}
}
externalNativeBuild {
cmake {
path 'src/main/cpp/CMakeLists.txt'
}
}
}

17
CMake/Android/build.gradle.in
View File

@@ -1,17 +0,0 @@
// Top-level build file where you can add configuration options common to all sub-projects/modules.
buildscript {
repositories {
jcenter()
google()
}
dependencies {
classpath 'com.android.tools.build:gradle:3.2.1'
}
}
allprojects {
repositories {
jcenter()
google()
}
}

25
CMake/Android/fl_config.cmake.in
View File

@@ -1,25 +0,0 @@
/*
* Configuration file for the Fast Light Tool Kit (FLTK).
*
* Copyright 1998-2020 by Bill Spitzak and others.
*
* This library is free software. Distribution and use rights are outlined in
* the file "COPYING" which should have been included with this file. If this
* file is missing or damaged, see the license at:
*
* https://www.fltk.org/COPYING.php
*
* Please see the following page on how to report bugs and issues:
*
* https://www.fltk.org/bugs.php
*/
/*
============================================================================
DO NOT EDIT - This file is generated by CMake !
============================================================================
*/
/* define FL_ABI_VERSION as 10x0y for FLTK ABI version 1.x.y */
/* #undef FL_ABI_VERSION */

BIN
CMake/Android/hdpi.ic_launcher.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 3.0 KiB

BIN
CMake/Android/mdpi.ic_launcher.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 1.7 KiB

1
CMake/Android/settings.gradle.in
View File

@@ -1 +0,0 @@

4
CMake/Android/strings.xml.in
View File

@@ -1,4 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="app_name">@ANDROID_APP_NAME@</string>
</resources>

BIN
CMake/Android/xhdpi.ic_launcher.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 4.0 KiB

BIN
CMake/Android/xxhdpi.ic_launcher.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 7.1 KiB

169
CMake/FindSDL2.cmake
View File

@@ -1,169 +0,0 @@
# This module defines
# SDL2_LIBRARY, the name of the library to link against
# SDL2_FOUND, if false, do not try to link to SDL2
# SDL2_INCLUDE_DIR, where to find SDL.h
#
# This module responds to the the flag:
# SDL2_BUILDING_LIBRARY
# If this is defined, then no SDL2main will be linked in because
# only applications need main().
# Otherwise, it is assumed you are building an application and this
# module will attempt to locate and set the the proper link flags
# as part of the returned SDL2_LIBRARY variable.
#
# Don't forget to include SDLmain.h and SDLmain.m your project for the
# OS X framework based version. (Other versions link to -lSDL2main which
# this module will try to find on your behalf.) Also for OS X, this
# module will automatically add the -framework Cocoa on your behalf.
#
#
# Additional Note: If you see an empty SDL2_LIBRARY_TEMP in your configuration
# and no SDL2_LIBRARY, it means CMake did not find your SDL2 library
# (SDL2.dll, libsdl2.so, SDL2.framework, etc).
# Set SDL2_LIBRARY_TEMP to point to your SDL2 library, and configure again.
# Similarly, if you see an empty SDL2MAIN_LIBRARY, you should set this value
# as appropriate. These values are used to generate the final SDL2_LIBRARY
# variable, but when these values are unset, SDL2_LIBRARY does not get created.
#
#
# $SDL2DIR is an environment variable that would
# correspond to the ./configure --prefix=$SDL2DIR
# used in building SDL2.
# l.e.galup 9-20-02
#
# Modified by Eric Wing.
# Added code to assist with automated building by using environmental variables
# and providing a more controlled/consistent search behavior.
# Added new modifications to recognize OS X frameworks and
# additional Unix paths (FreeBSD, etc).
# Also corrected the header search path to follow "proper" SDL guidelines.
# Added a search for SDL2main which is needed by some platforms.
# Added a search for threads which is needed by some platforms.
# Added needed compile switches for MinGW.
#
# On OSX, this will prefer the Framework version (if found) over others.
# People will have to manually change the cache values of
# SDL2_LIBRARY to override this selection or set the CMake environment
# CMAKE_INCLUDE_PATH to modify the search paths.
#
# Note that the header path has changed from SDL2/SDL.h to just SDL.h
# This needed to change because "proper" SDL convention
# is #include "SDL.h", not <SDL2/SDL.h>. This is done for portability
# reasons because not all systems place things in SDL2/ (see FreeBSD).
#=============================================================================
# Copyright 2003-2009 Kitware, Inc.
#
# Distributed under the OSI-approved BSD License (the "License");
# see accompanying file Copyright.txt for details.
#
# This software is distributed WITHOUT ANY WARRANTY; without even the
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the License for more information.
#=============================================================================
# (To distribute this file outside of CMake, substitute the full
# License text for the above reference.)
message("<FindSDL2.cmake>")
SET(SDL2_SEARCH_PATHS
~/Library/Frameworks
/Library/Frameworks
/usr/local
/usr
/sw # Fink
/opt/local # DarwinPorts
/opt/csw # Blastwave
/opt
${SDL2_PATH}
)
FIND_PATH(SDL2_INCLUDE_DIR SDL.h
HINTS
$ENV{SDL2DIR}
PATH_SUFFIXES include/SDL2 include
PATHS ${SDL2_SEARCH_PATHS}
)
FIND_LIBRARY(SDL2_LIBRARY_TEMP
NAMES SDL2
HINTS
$ENV{SDL2DIR}
PATH_SUFFIXES lib64 lib
PATHS ${SDL2_SEARCH_PATHS}
)
IF(NOT SDL2_BUILDING_LIBRARY)
IF(NOT ${SDL2_INCLUDE_DIR} MATCHES ".framework")
# Non-OS X framework versions expect you to also dynamically link to
# SDL2main. This is mainly for Windows and OS X. Other (Unix) platforms
# seem to provide SDL2main for compatibility even though they don't
# necessarily need it.
FIND_LIBRARY(SDL2MAIN_LIBRARY
NAMES SDL2main
HINTS
$ENV{SDL2DIR}
PATH_SUFFIXES lib64 lib
PATHS ${SDL2_SEARCH_PATHS}
)
ENDIF(NOT ${SDL2_INCLUDE_DIR} MATCHES ".framework")
ENDIF(NOT SDL2_BUILDING_LIBRARY)
# SDL2 may require threads on your system.
# The Apple build may not need an explicit flag because one of the
# frameworks may already provide it.
# But for non-OSX systems, I will use the CMake Threads package.
IF(NOT APPLE)
FIND_PACKAGE(Threads)
ENDIF(NOT APPLE)
# MinGW needs an additional library, mwindows
# It's total link flags should look like -lmingw32 -lSDL2main -lSDL2 -lmwindows
# (Actually on second look, I think it only needs one of the m* libraries.)
IF(MINGW)
SET(MINGW32_LIBRARY mingw32 CACHE STRING "mwindows for MinGW")
ENDIF(MINGW)
IF(SDL2_LIBRARY_TEMP)
# For SDL2main
IF(NOT SDL2_BUILDING_LIBRARY)
IF(SDL2MAIN_LIBRARY)
SET(SDL2_LIBRARY_TEMP ${SDL2MAIN_LIBRARY} ${SDL2_LIBRARY_TEMP})
ENDIF(SDL2MAIN_LIBRARY)
ENDIF(NOT SDL2_BUILDING_LIBRARY)
# For OS X, SDL2 uses Cocoa as a backend so it must link to Cocoa.
# CMake doesn't display the -framework Cocoa string in the UI even
# though it actually is there if I modify a pre-used variable.
# I think it has something to do with the CACHE STRING.
# So I use a temporary variable until the end so I can set the
# "real" variable in one-shot.
IF(APPLE)
SET(SDL2_LIBRARY_TEMP ${SDL2_LIBRARY_TEMP} "-framework Cocoa")
ENDIF(APPLE)
# For threads, as mentioned Apple doesn't need this.
# In fact, there seems to be a problem if I used the Threads package
# and try using this line, so I'm just skipping it entirely for OS X.
IF(NOT APPLE)
SET(SDL2_LIBRARY_TEMP ${SDL2_LIBRARY_TEMP} ${CMAKE_THREAD_LIBS_INIT})
ENDIF(NOT APPLE)
# For MinGW library
IF(MINGW)
SET(SDL2_LIBRARY_TEMP ${MINGW32_LIBRARY} ${SDL2_LIBRARY_TEMP})
ENDIF(MINGW)
# Set the final string here so the GUI reflects the final state.
SET(SDL2_LIBRARY ${SDL2_LIBRARY_TEMP} CACHE STRING "Where the SDL2 Library can be found")
# Set the temp variable to INTERNAL so it is not seen in the CMake GUI
SET(SDL2_LIBRARY_TEMP "${SDL2_LIBRARY_TEMP}" CACHE INTERNAL "")
ENDIF(SDL2_LIBRARY_TEMP)
message("</FindSDL2.cmake>")
INCLUDE(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(SDL2 REQUIRED_VARS SDL2_LIBRARY SDL2_INCLUDE_DIR)

141
CMake/android.cmake
View File

@@ -1,141 +0,0 @@
#
# android.cmake to build the FLTK AndroidStudio project using CMake
# Written by Matthias Melcher
#
# Copyright 1998-2019 by Bill Spitzak and others.
#
# This library is free software. Distribution and use rights are outlined in
# the file "COPYING" which should have been included with this file. If this
# file is missing or damaged, see the license at:
#
# https://www.fltk.org/COPYING.php
#
# Please see the following page on how to report bugs and issues:
#
# https://www.fltk.org/bugs.php
#
# all target modules will be added here later
configure_file(
"${CMAKE_CURRENT_SOURCE_DIR}/CMake/Android/settings.gradle.in"
"${CMAKE_CURRENT_BINARY_DIR}/AndroidStudio/settings.gradle"
@ONLY
)
# configuration file for all modules
configure_file(
"${CMAKE_CURRENT_SOURCE_DIR}/CMake/Android/build.gradle.in"
"${CMAKE_CURRENT_BINARY_DIR}/AndroidStudio/build.gradle"
@ONLY
)
# create a custom abi file for this setup
configure_file(
"${CMAKE_CURRENT_SOURCE_DIR}/fl_config.cmake.in"
"${CMAKE_CURRENT_BINARY_DIR}/AndroidStudio/FL/fl_config.h"
@ONLY
)
# TODO: where should we create config.h?
macro(CREATE_ANDROID_IDE_FOR_TEST NAME SOURCES LIBRARIES)
# message(STATUS "Creating Android IDE for ${NAME}")
set (ANDROID_APP_NAME ${NAME})
set (ANDROID_FLTK_DIR ${CMAKE_SOURCE_DIR})
set (srcs)
set (ANDROID_APP_SOURCES)
set (ANDROID_FLUID_COMMANDS)
set (flsrcs) # fluid source files
foreach(src ${SOURCES})
if ("${src}" MATCHES "\\.fl$")
list(APPEND flsrcs ${src})
string(REGEX REPLACE "(.*).fl" \\1 basename ${src})
string(APPEND ANDROID_FLUID_COMMANDS
"add_custom_command(\n"
" OUTPUT \"\${FLTK_DIR}/test/${basename}.cxx\" \"\${FLTK_DIR}/test/${basename}.h\"\n"
" COMMAND fluid -c \"${src}\"\n"
" WORKING_DIRECTORY \"\${FLTK_DIR}/test\"\n"
" DEPENDS \"\${FLTK_DIR}/test/${src}\"\n"
" MAIN_DEPENDENCY \"\${FLTK_DIR}/test/${src}\"\n"
")\n\n"
)
file(TOUCH "${basename}.cxx")
file(TOUCH "${basename}.h")
file(TOUCH "${basename}.fl")
set(src_cxx ${basename}.cxx)
else ()
list(APPEND srcs ${src})
set(src_cxx ${src})
endif ("${src}" MATCHES "\\.fl$")
string(APPEND ANDROID_APP_SOURCES " \"\${FLTK_DIR}/test/${src_cxx}\"\n")
endforeach(src)
configure_file(
"${CMAKE_SOURCE_DIR}/CMake/Android/app.build.gradle.in"
"${CMAKE_BINARY_DIR}/AndroidStudio/${ANDROID_APP_NAME}/build.gradle"
@ONLY
)
configure_file(
"${CMAKE_SOURCE_DIR}/CMake/Android/AndroidManifest.xml.in"
"${CMAKE_BINARY_DIR}/AndroidStudio/${ANDROID_APP_NAME}/src/main/AndroidManifest.xml"
@ONLY
)
configure_file(
"${CMAKE_SOURCE_DIR}/CMake/Android/Roboto-Regular.ttf"
"${CMAKE_BINARY_DIR}/AndroidStudio/${ANDROID_APP_NAME}/src/main/assets/fonts/Roboto-Regular.ttf"
COPYONLY
)
configure_file(
"${CMAKE_SOURCE_DIR}/CMake/Android/mdpi.ic_launcher.png"
"${CMAKE_BINARY_DIR}/AndroidStudio/${ANDROID_APP_NAME}/src/main/res/mipmap-mdpi/ic_launcher.png"
COPYONLY
)
configure_file(
"${CMAKE_SOURCE_DIR}/CMake/Android/hdpi.ic_launcher.png"
"${CMAKE_BINARY_DIR}/AndroidStudio/${ANDROID_APP_NAME}/src/main/res/mipmap-hdpi/ic_launcher.png"
COPYONLY
)
configure_file(
"${CMAKE_SOURCE_DIR}/CMake/Android/xhdpi.ic_launcher.png"
"${CMAKE_BINARY_DIR}/AndroidStudio/${ANDROID_APP_NAME}/src/main/res/mipmap-xhdpi/ic_launcher.png"
COPYONLY
)
configure_file(
"${CMAKE_SOURCE_DIR}/CMake/Android/xxhdpi.ic_launcher.png"
"${CMAKE_BINARY_DIR}/AndroidStudio/${ANDROID_APP_NAME}/src/main/res/mipmap-xxhdpi/ic_launcher.png"
COPYONLY
)
configure_file(
"${CMAKE_SOURCE_DIR}/CMake/Android/strings.xml.in"
"${CMAKE_BINARY_DIR}/AndroidStudio/${ANDROID_APP_NAME}/src/main/res/values/strings.xml"
@ONLY
)
configure_file(
"${CMAKE_SOURCE_DIR}/CMake/Android/CMakeList.txt.in"
"${CMAKE_BINARY_DIR}/AndroidStudio/${ANDROID_APP_NAME}/src/main/cpp/CMakeLists.txt"
@ONLY
)
file(APPEND "${CMAKE_BINARY_DIR}/AndroidStudio/settings.gradle" "include ':${ANDROID_APP_NAME}'\n")
endmacro(CREATE_ANDROID_IDE_FOR_TEST NAME SOURCES LIBRARIES)
macro(CREATE_ANDROID_IDE_WRAPUP)
# message(STATUS "Wrapping up Android IDE creation")
endmacro(CREATE_ANDROID_IDE_WRAPUP)

25
CMake/fl_create_example.cmake
View File

@@ -46,8 +46,7 @@
# quotes if more than one library is required, e.g. "fltk_gl;fltk"
#
# CREATE_EXAMPLE can have an optional fourth argument with a list of options
# - the option ANDROID_OK is set if CREATE_EXAMPLE creates code for Android
# builds in addition to the native build
# - these options are currently not used
#
################################################################################
@@ -62,11 +61,11 @@ macro (CREATE_EXAMPLE NAME SOURCES LIBRARIES)
# create macOS bundle? 0 = no, 1 = yes
if (APPLE AND (NOT OPTION_APPLE_X11) AND (NOT OPTION_APPLE_SDL))
if (APPLE AND (NOT OPTION_APPLE_X11))
set (MAC_BUNDLE 1)
else ()
set (MAC_BUNDLE 0)
endif (APPLE AND (NOT OPTION_APPLE_X11) AND (NOT OPTION_APPLE_SDL))
endif (APPLE AND (NOT OPTION_APPLE_X11))
# rename target name "help" (reserved since CMake 2.8.12)
# FIXME: not necessary in FLTK 1.4 but left for compatibility (06/2020)
@@ -164,15 +163,17 @@ macro (CREATE_EXAMPLE NAME SOURCES LIBRARIES)
endif (MAC_BUNDLE)
######################################################################
# Parse optional fourth argument "ANDROID_OK", see description above.
# Parse optional fourth argument, see description above.
######################################################################
if (${ARGC} GREATER 3)
foreach (OPTION ${ARGV3})
if (${OPTION} STREQUAL "ANDROID_OK" AND OPTION_CREATE_ANDROID_STUDIO_IDE)
CREATE_ANDROID_IDE_FOR_TEST (${NAME} ${SOURCES} ${LIBRARIES})
endif ()
endforeach ()
endif ()
# code left commented out as an example
# *unused* # if (${ARGC} GREATER 3)
# *unused* # foreach (OPTION ${ARGV3})
# *unused* # if (${OPTION} STREQUAL "xxx")
# *unused* # # do something ...
# *unused* # endif ()
# *unused* # endforeach ()
# *unused* # endif ()
endmacro (CREATE_EXAMPLE NAME SOURCES LIBRARIES)

15
CMake/options.cmake
View File

@@ -65,7 +65,6 @@ endif (WIN32)
#######################################################################
if (APPLE)
option (OPTION_APPLE_X11 "use X11" OFF)
option (OPTION_APPLE_SDL "use SDL" OFF)
if (CMAKE_OSX_SYSROOT)
list (APPEND FLTK_CFLAGS "-isysroot ${CMAKE_OSX_SYSROOT}")
endif (CMAKE_OSX_SYSROOT)
@@ -100,14 +99,6 @@ if (OPTION_APPLE_X11)
endif (X11_INCLUDE_DIR)
endif (OPTION_APPLE_X11)
if (OPTION_APPLE_SDL)
find_package (SDL2 REQUIRED)
if (SDL2_FOUND)
set (USE_SDL 1)
list (APPEND FLTK_LDLIBS SDL2_LIBRARY)
endif (SDL2_FOUND)
endif (OPTION_APPLE_SDL)
#######################################################################
option (OPTION_USE_POLL "use poll if available" OFF)
mark_as_advanced (OPTION_USE_POLL)
@@ -238,8 +229,6 @@ if (OPTION_USE_GL)
set (OPENGL_LIBRARIES -L${PATH_TO_XLIBS} -lGLU -lGL)
unset(HAVE_GL_GLU_H CACHE)
find_file (HAVE_GL_GLU_H GL/glu.h PATHS ${X11_INCLUDE_DIR})
elseif (OPTION_APPLE_SDL)
set (OPENGL_FOUND FALSE)
else()
include (FindOpenGL)
if (APPLE)
@@ -618,10 +607,6 @@ else ()
endif (OPTION_USE_KDIALOG)
#######################################################################
#######################################################################
option (OPTION_CREATE_ANDROID_STUDIO_IDE "create files needed to compile FLTK for Android" OFF)
#######################################################################
#######################################################################
option (CMAKE_SUPPRESS_REGENERATION "suppress rules to re-run CMake on rebuild" OFF)
mark_as_advanced (CMAKE_SUPPRESS_REGENERATION)

3
CMake/setup.cmake
View File

@@ -89,9 +89,6 @@ if (APPLE)
if (NOT(${CMAKE_SYSTEM_VERSION} VERSION_LESS 17.0.0)) # a.k.a. macOS version ≥ 10.13
set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_LIBCPP_HAS_THREAD_API_PTHREAD")
endif (NOT(${CMAKE_SYSTEM_VERSION} VERSION_LESS 17.0.0))
elseif (OPTION_APPLE_SDL)
set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${SDL2_INCLUDE_DIRS} -U__APPLE__")
set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${SDL2_INCLUDE_DIRS} -U__APPLE__")
else ()
set (__APPLE_QUARTZ__ 1)
set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -framework Cocoa")

2
CMake/variables.cmake
View File

@@ -41,8 +41,6 @@ endif (DEBUG_VARIABLES_CMAKE)
if (WIN32)
list (APPEND FLTK_LDLIBS -lole32 -luuid -lcomctl32 -lws2_32)
elseif (APPLE AND OPTION_APPLE_SDL)
# FIXME: do nothing?
elseif (APPLE AND NOT OPTION_APPLE_X11)
list (APPEND FLTK_LDLIBS "-framework Cocoa")
else ()

19
CMakeLists.txt
View File

@@ -80,13 +80,6 @@ include (CMake/resources.cmake)
#######################################################################
include (CMake/options.cmake)
#######################################################################
# Android Studio setup
#######################################################################
if (OPTION_CREATE_ANDROID_STUDIO_IDE)
include (CMake/android.cmake)
endif (OPTION_CREATE_ANDROID_STUDIO_IDE)
#######################################################################
# print (debug) several build variables and options
#######################################################################
@@ -102,7 +95,6 @@ if (debug_build)
fl_debug_var (MSVC)
fl_debug_var (UNIX)
fl_debug_var (APPLE)
fl_debug_var (ANDROID)
fl_debug_var (CMAKE_BUILD_TYPE)
fl_debug_var (CMAKE_SIZEOF_VOID_P)
fl_debug_var (OPTION_OPTIM)
@@ -124,9 +116,7 @@ add_subdirectory(src)
# build fluid
#######################################################################
if (NOT ANDROID)
add_subdirectory(fluid)
endif()
add_subdirectory(fluid)
#######################################################################
# variables shared by export and install
@@ -159,13 +149,6 @@ if (FLTK_BUILD_EXAMPLES)
add_subdirectory (examples)
endif (FLTK_BUILD_EXAMPLES)
#######################################################################
# Android Studio wrapup
#######################################################################
if (OPTION_CREATE_ANDROID_STUDIO_IDE)
CREATE_ANDROID_IDE_WRAPUP()
endif (OPTION_CREATE_ANDROID_STUDIO_IDE)
#######################################################################
# installation
#######################################################################

159
FL/android.H
View File

@@ -1,159 +0,0 @@
//
// Template header file for the Fast Light Tool Kit (FLTK).
//
// Copyright 2016-2018 by Bill Spitzak and others.
//
// This library is free software. Distribution and use rights are outlined in
// the file "COPYING" which should have been included with this file. If this
// file is missing or damaged, see the license at:
//
// https://www.fltk.org/COPYING.php
//
// Please see the following page on how to report bugs and issues:
//
// https://www.fltk.org/bugs.php
//
// Do not directly include this file, instead use <FL/android.H>.
// These types and variables give access to internal, platform-specific data through the public API.
// They require to include platform.H (in contrast to types defined in platform_types.h)
#if !defined(FL_PLATFORM_H)
# error "Never use <FL/android.H> directly; include <FL/platform.H> instead."
#endif // !FL_PLATFORM_H
#ifdef __cplusplus
extern "C" {
#endif
/*
This is the function that application code must implement, representing
the main entry to the app.
*/
extern int main(int argc, char **argv);
#ifdef __cplusplus
}
#endif
typedef void *Window; // used by fl_find(), fl_xid() and class Fl_X
/* Reference to the current device context
For back-compatibility only. The preferred procedure to get this reference is
Fl_Surface_Device::surface()->driver()->gc().
*/
extern void *fl_gc;
/**
These events are specific to the Android OS driver system. They can
be read by adding a callback via Fl::add_system_handler() and reading Fl::event()
Don't change the order of these enums! See Fl_Android_Application.H .
*/
enum Fl_Android_Platform_Event
{
FL_ANDROID_EVENTS = 0x00010000,
/**
* Command from main thread: the AInputQueue has changed. Upon processing
* this command, android_app->inputQueue will be updated to the new queue
* (or NULL).
*/
FL_ANDROID_EVENT_INPUT_CHANGED,
/**
* Command from main thread: a new ANativeWindow is ready for use. Upon
* receiving this command, android_app->window will contain the new window
* surface.
*/
FL_ANDROID_EVENT_INIT_WINDOW,
/**
* Command from main thread: the existing ANativeWindow needs to be
* terminated. Upon receiving this command, android_app->window still
* contains the existing window; after calling android_app_exec_cmd
* it will be set to NULL.
*/
FL_ANDROID_EVENT_TERM_WINDOW,
/**
* Command from main thread: the current ANativeWindow has been resized.
* Please redraw with its new size.
*/
FL_ANDROID_EVENT_WINDOW_RESIZED,
/**
* Command from main thread: the system needs that the current ANativeWindow
* be redrawn. You should redraw the window before handing this to
* android_app_exec_cmd() in order to avoid transient drawing glitches.
*/
FL_ANDROID_EVENT_WINDOW_REDRAW_NEEDED,
/**
* Command from main thread: the content area of the window has changed,
* such as from the soft input window being shown or hidden. You can
* find the new content rect in android_app::contentRect.
*/
FL_ANDROID_EVENT_CONTENT_RECT_CHANGED,
/**
* Command from main thread: the app's activity window has gained
* input focus.
*/
FL_ANDROID_EVENT_GAINED_FOCUS,
/**
* Command from main thread: the app's activity window has lost
* input focus.
*/
FL_ANDROID_EVENT_LOST_FOCUS,
/**
* Command from main thread: the current device configuration has changed.
*/
FL_ANDROID_EVENT_CONFIG_CHANGED,
/**
* Command from main thread: the system is running low on memory.
* Try to reduce your memory use.
*/
FL_ANDROID_EVENT_LOW_MEMORY,
/**
* Command from main thread: the app's activity has been started.
*/
FL_ANDROID_EVENT_START,
/**
* Command from main thread: the app's activity has been resumed.
*/
FL_ANDROID_EVENT_RESUME,
/**
* Command from main thread: the app should generate a new saved state
* for itself, to restore from later if needed. If you have saved state,
* allocate it with malloc and place it in android_app.savedState with
* the size in android_app.savedStateSize. The will be freed for you
* later.
*/
FL_ANDROID_EVENT_SAVE_STATE,
/**
* Command from main thread: the app's activity has been paused.
*/
FL_ANDROID_EVENT_PAUSE,
/**
* Command from main thread: the app's activity has been stopped.
*/
FL_ANDROID_EVENT_STOP,
/**
* Command from main thread: the app's activity is being destroyed,
* and waiting for the app thread to clean up and exit before proceeding.
*/
FL_ANDROID_EVENT_DESTROY
};

2
FL/platform.H
View File

@@ -37,8 +37,6 @@ class Fl_Window;
# include "win32.H"
# elif defined(__APPLE__)
# include "mac.H"
# elif defined(__ANDROID__)
# include "android.H"
# elif defined(FLTK_USE_X11)
# include "x11.H"
# endif // _WIN32

22
FL/platform_types.h
View File

@@ -72,12 +72,6 @@ typedef opaque GLContext; /**< an OpenGL graphics context, into which all OpenGL
typedef intptr_t fl_intptr_t;
typedef uintptr_t fl_uintptr_t;
#elif defined(__ANDROID__)
#include <sys/stat.h>
typedef intptr_t fl_intptr_t;
typedef uintptr_t fl_uintptr_t;
#else /* ! _WIN64 */
typedef long fl_intptr_t;
@@ -122,22 +116,6 @@ typedef struct HGLRC__ *GLContext;
struct dirent {char d_name[1];};
#endif
#elif defined(__ANDROID__)
#ifdef __cplusplus
typedef class Fl_Rect_Region *Fl_Region;
#else
typedef struct Fl_Rect_Region *Fl_Region;
#endif
// TODO: the types below have not yet been ported
typedef unsigned long Fl_Offscreen;
typedef unsigned long Fl_Bitmask;
typedef int FL_SOCKET;
typedef struct __GLXcontextRec *GLContext;
#include <sys/types.h>
#include <dirent.h>
#elif defined(FLTK_USE_X11)
typedef unsigned long Fl_Offscreen;

80
README.Android.md
View File

@@ -1,80 +0,0 @@
README.Android.md
# Building and Running FLTK with Android Studio 3
WARNING: FLTK FOR ANDROID IS WORK IN PROGRESS IN A PRETTY EARLY STAGE.
## Contents
1. Building FLTK with Android Studio 3
2. Extensions and limitation of FLTK on Android
3. Document History
## Building FLTK with Android Studio 3
There is no need to ever write a single line of Java.
Download and install AndroidStudio on your developer machine. If you use
AndroidStudio for the first time, use the IDE to download and build the
"Native Plasm" sample app. In the process, all resources required to build
FLTK will be installed. Once Native Plasm runs on your emulator or physical
device, you are ready to install FLTK.
Build FLTK for your native platform first using CMake. AndroidStudio will need a native
version of the user interface design tool _Fluid_.
The following example is for the _Xcode_ IDE on _macOS_. The same should work for
other IDEs and Makefiles on other platforms that run _AndroidStudio_.
```bash
git clone https://github.com/fltk/fltk.git fltk-1.4.git
cd fltk-1.4.git
mkdir build
cd build
mkdir Xcode
cd Xcode
cmake -G "Unix Makefiles" \
-D OPTION_USE_SYSTEM_LIBJPEG=Off \
-D OPTION_USE_SYSTEM_ZLIB=Off \
-D OPTION_USE_SYSTEM_LIBPNG=Off \
-D OPTION_CREATE_ANDROID_STUDIO_IDE=On \
../..
```
Note the last option, `-D OPTION_CREATE_ANDROID_STUDIO_IDE=On`. This option will
create the file needed to create an FLTK demo project in
`fltk-1.4.git/build/Xcode/AndroidStudio`.
- open the `build/Xcode/AndroidStudio/` directory as a project in AndroidStudio3
- click "run"; the project should compile and run out of the box
## Extensions and limitation of FLTK on Android
Android support for FLTK is in an early stage. As of January 2019, most
rendering works, fonts work, bitmaps and pixmaps work, clipping works, window
layering works, and mouse clicks and keyboard events are handled
When loading fonts:
- font names starting with a $ will have the system font path inserted
- font names starting with an @ will be loaded via the Asset Manager
- all other names will be used verbatim
Limitations:
- the screen size is currently fixed to 600x800 and is scaled up
- many many big and little functions are not yet implemented
## Document History
Jan 15 2019 - matt: rewrote document to explain the new CMake process
Mar 29 2018 - matt: many graphics functions have been implemented, keyboard
Mar 17 2018 - matt: added Android extensions for fonts
Mar 12 2018 - matt: started list of limitation that serevs as information to the
user as much as a todo list for core developers
Mar 6 2018 - matt: moved project to ide/AndroidStudio3/
Mar 2 2018 - matt: rewriting Android port and documentation from scratch
Feb 9 2016 - matt: recreated document with more warnings and active support

10
README.IDE.txt
View File

@@ -3,10 +3,10 @@
-----------------------------------------
Since FLTK 1.4 we do no longer include IDE [1] solution files in our
source distribution. [2]
source distribution.
If you want to build the FLTK library with an IDE you need to use
CMake [3] to generate the IDE files from the source distribution.
CMake [2] to generate the IDE files from the source distribution.
The FLTK team will officially support generation of selected IDE projects,
particularly Visual C++ and Xcode. Older version support of these IDE
@@ -45,8 +45,4 @@ Note: "Not supported" doesn't mean that a particular generator does not work,
for instance Visual Studio, Xcode, Eclipse, ...
https://en.wikipedia.org/wiki/Integrated_development_environment
[2] The only exception is the Android Studio IDE in ide/AndroidStudio3
currently provided for testing. This IDE solution is likely to be
moved elsewhere or removed entirely before FLTK 1.4 will be released.
[3] https://cmake.org/
[2] https://cmake.org/

72
README.Pico.txt
View File

@@ -1,72 +0,0 @@
This documentation will explain how to quickly port FLTK to a new
platform using the Pico driver system. For now, only the sample
SDL Pico driver on macOS compiles and barely runs.
> mkdir build
> cd build
> mkdir XcodeSDL
> cd XcodeSDL
> cmake -G Xcode -D OPTION_APPLE_SDL=ON ../..
tl;dr - the recent commit should be transparent to all developers on
other platforms. On macOS, the CMake setup adds 'OPTION_APPLE_SDL=ON'
that will run FLTK on top of SDL, which in turn runs on top of the
new "Pico" driver set.
The greatest help I can get from the core developers is to continue
to refactor the platform specific functionalities into the drivers.
---
OK, long version. I know that I am repeating myself and I don't expect
those of you who "got it" weeks ago to read this again. Writing this
down is also for me to avoid losing track ;-)
Goal 1: find all the stuff that must still go into drivers
Goal 2: have a base driver for all future porting efforts
Goal 3: make porting fun with early gratification to the coder
Goal 4: extensively document a sample port (SDL), and how to improve it
Goal 5: use SDL as a base library, thereby porting FLTK to iOS and Android
This is the start of a new driver, named "Pico". "Pico" is here to
implement what I called the minimal driver.
"Pico" implements (eventually) a complete set of drivers. The drivers
will be limited in functionality, but they will be good enough to
allow basic UI's with most FLTK widget types.
If "Pico" compiles without any "USE_PICO" or similar defines, we
have reached goal 1.
"Pico" will implement all driver functionalities "in good faith",
meaning, in a way that FLTK runs without crashing. Only very very
basic functions are not implemented. A driver that derives from "Pico"
needs only to implement those missing functions, thereby reaching goals
2 and 3. As far as I can tell, those will be:
- open a single fixed size window
- setting a pixel in a color inside that window
- polling and waiting for PUSH and RELEASE events and their positions
By implementing these three simple functions in the SDL driver,
"test/hello" and quite a bunch of other tests will run (yes, they
will be slow, but the will work).
This will give the person who is porting FLTK to their platform a
very early confirmation that their build setup is working and a
very early gratification, reaching goal 3.
Obviously, SDL is much more powerful, and by the nature of the
virtual functions in the driver system, we can incrementally add
functionality to the SDL driver, and document this incremental
nature, reaching goal 4.
If we do all this right, we have goal 5.
If SDL is too big or complex for, say, Android, we can simply start
a new native Android driver set by implementing the three functions
mentioned above, and then go from there.
- Matthias

29
README.experimental.txt Normal file
View File

@@ -0,0 +1,29 @@
Removed Experimental Platforms
------------------------------
Removed platforms and drivers include:
- Android
- Pico
- PicoAndroid
- PicoSDL
These platforms and their drivers were experimental and undocumented.
They have been removed in January 2022 for maintenance reasons as
discussed in fltk.coredev: "FLTK 1.4.0 release schedule", see:
https://groups.google.com/g/fltkcoredev/c/PDbHTRpXVh0/m/JqboexZ_AwAJ
More information, for instance where to find further development
(if any) will be added in this file.
If you want to take a look at the removed drivers you can checkout
the git tag "experimental-2022-01":
$ git clone https://github.com/fltk/fltk.git fltk-experimental
$ cd fltk-experimental
$ git checkout experimental-2022-01
You can also browse the files on GitHub:
https://github.com/fltk/fltk/tree/b275ff07158e80d1744ddb2f6c51094a87cf079a

9
configh.cmake.in
View File

@@ -157,15 +157,6 @@
#cmakedefine __APPLE_QUARTZ__ 1
/*
* USE_SDL
*
* Should we use SDL for the current platform
*
*/
#cmakedefine USE_SDL 1
/*
* HAVE_GL_OVERLAY:
*

10
configh.in
View File

@@ -156,16 +156,6 @@
#undef __APPLE_QUARTZ__
/*
* USE_SDL
*
* Should we use SDL for the current platform
* *FIXME* USE_SDL not yet implemented in configure !
*
*/
#undef USE_SDL
/*
* HAVE_GL_OVERLAY:
*

2
examples/CMakeLists.txt
View File

@@ -146,7 +146,7 @@ endforeach (src)
# Note: macOS does not need libGLEW
if (APPLE AND (NOT OPTION_APPLE_X11) AND (NOT OPTION_APPLE_SDL))
if (APPLE AND (NOT OPTION_APPLE_X11))
if (NOT LIB_GLEW)
set (LIB_GLEW TRUE)
endif ()

8
fluid/CMakeLists.txt
View File

@@ -84,7 +84,7 @@ endif (WIN32)
source_group("Header Files" FILES ${HEADERFILES})
if (APPLE AND (NOT OPTION_APPLE_X11) AND (NOT OPTION_APPLE_SDL))
if (APPLE AND (NOT OPTION_APPLE_X11))
set (ICON_NAME fluid.icns)
set (ICON_PATH "${CMAKE_CURRENT_SOURCE_DIR}/icons/${ICON_NAME}")
add_executable (fluid MACOSX_BUNDLE ${CPPFILES} ${HEADERFILES} ${ICON_PATH})
@@ -104,7 +104,7 @@ if (APPLE AND (NOT OPTION_APPLE_X11) AND (NOT OPTION_APPLE_SDL))
else ()
add_executable (fluid WIN32 ${CPPFILES} ${HEADERFILES})
endif (APPLE AND (NOT OPTION_APPLE_X11) AND (NOT OPTION_APPLE_SDL))
endif (APPLE AND (NOT OPTION_APPLE_X11))
target_link_libraries (fluid fltk fltk_images)
@@ -123,7 +123,7 @@ endif (USE_GDIPLUS)
# install fluid
if (APPLE AND (NOT OPTION_APPLE_X11) AND (NOT OPTION_APPLE_SDL))
if (APPLE AND (NOT OPTION_APPLE_X11))
# On macOS, Fluid must be installed twice. The bundled version of Fluid needs
# to go into the /Applications folder to make it visible as a user App with
@@ -149,7 +149,7 @@ else()
LIBRARY DESTINATION ${FLTK_LIBDIR}
ARCHIVE DESTINATION ${FLTK_LIBDIR}
)
endif (APPLE AND (NOT OPTION_APPLE_X11) AND (NOT OPTION_APPLE_SDL))
endif (APPLE AND (NOT OPTION_APPLE_X11))
# install desktop files

69
src/CMakeLists.txt
View File

@@ -178,7 +178,7 @@ list (APPEND HEADER_FILES
set (GL_HEADER_FILES) # FIXME: not (yet?) defined
if ((FLTK_USE_X11 OR USE_SDL) AND NOT OPTION_PRINT_SUPPORT)
if (FLTK_USE_X11 AND NOT OPTION_PRINT_SUPPORT)
set (PSFILES
)
else ()
@@ -186,7 +186,7 @@ else ()
drivers/PostScript/Fl_PostScript.cxx
drivers/PostScript/Fl_PostScript_image.cxx
)
endif ((FLTK_USE_X11 OR USE_SDL) AND NOT OPTION_PRINT_SUPPORT)
endif (FLTK_USE_X11 AND NOT OPTION_PRINT_SUPPORT)
set (DRIVER_FILES)
@@ -241,35 +241,6 @@ if (FLTK_USE_X11)
drivers/Xlib/Fl_Font.H
)
elseif (USE_SDL)
# SDL2
set (DRIVER_FILES
drivers/Pico/Fl_Pico_System_Driver.cxx
drivers/Pico/Fl_Pico_Screen_Driver.cxx
drivers/Pico/Fl_Pico_Window_Driver.cxx
drivers/Pico/Fl_Pico_Graphics_Driver.cxx
drivers/Pico/Fl_Pico_Copy_Surface.cxx
drivers/Pico/Fl_Pico_Image_Surface.cxx
drivers/PicoSDL/Fl_PicoSDL_System_Driver.cxx
drivers/PicoSDL/Fl_PicoSDL_Screen_Driver.cxx
drivers/PicoSDL/Fl_PicoSDL_Window_Driver.cxx
drivers/PicoSDL/Fl_PicoSDL_Graphics_Driver.cxx
drivers/PicoSDL/Fl_PicoSDL_Copy_Surface.cxx
drivers/PicoSDL/Fl_PicoSDL_Image_Surface.cxx
)
set (DRIVER_HEADER_FILES
drivers/Pico/Fl_Pico_System_Driver.H
drivers/Pico/Fl_Pico_Screen_Driver.H
drivers/Pico/Fl_Pico_Window_Driver.H
drivers/Pico/Fl_Pico_Graphics_Driver.H
drivers/PicoSDL/Fl_PicoSDL_System_Driver.H
drivers/PicoSDL/Fl_PicoSDL_Screen_Driver.H
drivers/PicoSDL/Fl_PicoSDL_Window_Driver.H
drivers/PicoSDL/Fl_PicoSDL_Graphics_Driver.H
)
elseif (APPLE)
# Apple Quartz
@@ -302,34 +273,6 @@ elseif (APPLE)
drivers/Quartz/Fl_Font.H
)
elseif (ANDROID)
# Android
set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
set (DRIVER_FILES
drivers/Android/Fl_Android_Application.cxx
drivers/Android/Fl_Android_System_Driver.cxx
drivers/Android/Fl_Android_Screen_Driver.cxx
drivers/Android/Fl_Android_Screen_Keyboard.cxx
drivers/Android/Fl_Android_Window_Driver.cxx
drivers/Android/Fl_Android_Image_Surface_Driver.cxx
drivers/Android/Fl_Android_Graphics_Driver.cxx
drivers/Android/Fl_Android_Graphics_Clipping.cxx
drivers/Android/Fl_Android_Graphics_Font.cxx
)
set (DRIVER_HEADER_FILES
drivers/Android/Fl_Android_Application.H
drivers/Android/Fl_Android_System_Driver.H
drivers/Android/Fl_Android_Screen_Driver.H
drivers/Android/Fl_Android_Window_Driver.H
drivers/Android/Fl_Android_Graphics_Driver.H
drivers/Android/Fl_Android_Graphics_Clipping.H
drivers/Android/Fl_Android_Graphics_Font.H
)
else ()
# Windows (GDI)
@@ -473,7 +416,7 @@ if (WIN32)
)
endif (WIN32)
if (APPLE AND (NOT OPTION_APPLE_X11) AND (NOT OPTION_APPLE_SDL))
if (APPLE AND (NOT OPTION_APPLE_X11))
set (MMFILES
Fl_cocoa.mm
drivers/Cocoa/Fl_Cocoa_Printer_Driver.mm
@@ -483,7 +426,7 @@ if (APPLE AND (NOT OPTION_APPLE_X11) AND (NOT OPTION_APPLE_SDL))
else()
set (MMFILES
)
endif (APPLE AND (NOT OPTION_APPLE_X11) AND (NOT OPTION_APPLE_SDL))
endif (APPLE AND (NOT OPTION_APPLE_X11))
#######################################################################
@@ -519,10 +462,6 @@ if (FLTK_USE_X11)
list (APPEND OPTIONAL_LIBS ${X11_LIBRARIES})
endif (FLTK_USE_X11)
if (USE_SDL)
list (APPEND OPTIONAL_LIBS ${SDL2_LIBRARY})
endif (USE_SDL)
if (WIN32)
list (APPEND OPTIONAL_LIBS comctl32 ws2_32)
endif (WIN32)

2
src/Fl_Device.cxx
View File

@@ -50,7 +50,7 @@
|
+- Fl_PostScript_Graphics_Driver: platform-independent graphics driver for PostScript drawing
+- Fl_SVG_Graphics_Driver: platform-independent graphics driver for Scalable Vector Graphics drawing
+- Fl_..._Graphics_Driver: platform-specific graphics driver (MacOS, Android, Pico)
+- Fl_..._Graphics_Driver: platform-specific graphics driver (MacOS)
+- Fl_Quartz_Printer_Graphics_Driver: MacOS-specific, for drawing to printers
+- Fl_Scalable_Graphics_Driver: helper class to support GUI scaling
+- Fl_Xlib_Graphics_Driver: X11-specific graphics driver

2
src/Fl_System_Driver.cxx
View File

@@ -43,7 +43,7 @@ const int Fl_System_Driver::fl_YNegative = 0x0020;
// and/or use their own table. It is defined here "static" and assigned
// in the constructor to avoid static initialization race conditions.
//
// As of June 2018 these platforms are Windows and Android. X11 does not
// As of January 2022 the only platform is Windows. X11 does not
// use a key table at all.
// Platforms that use their own key tables must assign them in their
// constructors (which overwrites the pointer and size).

270
src/drivers/Android/Fl_Android_Application.H
View File

@@ -1,270 +0,0 @@
//
// Android Native Application interface
// for the Fast Light Tool Kit (FLTK).
//
// Copyright 2018 by Bill Spitzak and others.
//
// This library is free software. Distribution and use rights are outlined in
// the file "COPYING" which should have been included with this file. If this
// file is missing or damaged, see the license at:
//
// https://www.fltk.org/COPYING.php
//
// Please see the following page on how to report bugs and issues:
//
// https://www.fltk.org/bugs.php
//
/**
\file Fl_Android_Application.H
\brief Definition of Android Native Application interface
*/
#ifndef FL_ANDROID_APPLICATION_H
#define FL_ANDROID_APPLICATION_H
#include <FL/Fl.H>
extern void (*fl_unlock_function)();
extern void (*fl_lock_function)();
#include <poll.h>
#include <pthread.h>
#include <sched.h>
#include <android/configuration.h>
#include <android/looper.h>
#include <android/native_activity.h>
/**
A class to make Java calls from C++ easier.
*/
class Fl_Android_Java
{
JavaVM *pJavaVM = nullptr;
JNIEnv *pJNIEnv = nullptr;
jobject pNativeActivity;
jclass pNativeActivityClass;
bool pAttached = false;
public:
Fl_Android_Java();
~Fl_Android_Java();
bool is_attached() { return pAttached; }
JavaVM *VM() { return pJavaVM; }
JNIEnv *env() { return pJNIEnv; }
jobject native_ativity() { return pNativeActivity; }
jclass native_activity_class() { return pNativeActivityClass; }
};
/**
Static class that manages all interaction between the Android Native Activity
and the FLTK library. It also keeps often used data for global access.
On launch, it creates a main thread and communication pipe to
the Activity. All FLTK code will run in that thread. Activity
events will be polled by the Screen driver using the provided
Android Looper, and will also be routed back to this class as needed.
This code is based on the native activity interface
provided by <android/native_activity.h>. It is based on a set
of application-provided callbacks that will be called
by the Activity's main thread when certain events occur.
1/ The application must provide a function named "int main(argc, argv)" that
will be called when the activity is created, in a new thread that is
distinct from the activity's main thread.
2/ The application has access to a static "Fl_Android_Application" class
that contains references to other important objects, e.g. the
ANativeActivity object instance the application is running in.
3/ the "Fl_Android_Application" class holds an ALooper instance that already
listens to two important things:
- activity lifecycle events (e.g. "pause", "resume"). See APP_CMD_XXX
declarations below.
- input events coming from the AInputQueue attached to the activity.
Each of these correspond to an ALooper identifier returned by
ALooper_pollOnce with values of LOOPER_ID_MAIN and LOOPER_ID_INPUT,
respectively.
FLTK will add more items to the looper for timers and file and socket
communication. (fl_add_timeout, Fl::add_fd(), ...
*/
class Fl_Android_Application
{
public:
enum {
/**
* Looper data ID of commands coming from the app's main thread, which
* is returned as an identifier from ALooper_pollOnce(). The data for this
* identifier is a pointer to an android_poll_source structure.
* These can be retrieved and processed with android_app_read_cmd()
* and android_app_exec_cmd().
*/
LOOPER_ID_MAIN = 1,
/**
* Looper data ID of events coming from the AInputQueue of the
* application's window, which is returned as an identifier from
* ALooper_pollOnce(). The data for this identifier is a pointer to an
* android_poll_source structure. These can be read via the inputQueue
* object of android_app.
*/
LOOPER_ID_INPUT,
/**
* Timer data ID of all timer events coming from the Unix timer_create()
* and friends, used in fl_add_timeout() and colleagues.
*/
LOOPER_ID_TIMER,
/**
* Start of user-defined ALooper identifiers.
*/
LOOPER_ID_USER,
};
/**
* @see android.H Fl_Android_Platform_Event
*/
enum {
APP_CMD_INPUT_CHANGED,
APP_CMD_INIT_WINDOW,
APP_CMD_TERM_WINDOW,
APP_CMD_WINDOW_RESIZED,
APP_CMD_WINDOW_REDRAW_NEEDED,
APP_CMD_CONTENT_RECT_CHANGED,
APP_CMD_GAINED_FOCUS,
APP_CMD_LOST_FOCUS,
APP_CMD_CONFIG_CHANGED,
APP_CMD_LOW_MEMORY,
APP_CMD_START,
APP_CMD_RESUME,
APP_CMD_SAVE_STATE,
APP_CMD_PAUSE,
APP_CMD_STOP,
APP_CMD_DESTROY,
};
public:
// --- logging
static void log_e(const char *text, ...);
static void log_w(const char *text, ...);
static void log_i(const char *text, ...);
static void log_v(const char *text, ...);
// --- application state stuff
static int8_t read_cmd();
static void pre_exec_cmd(int8_t cmd);
static void post_exec_cmd(int8_t cmd);
static int destroy_requested() { return pDestroyRequested; }
static const char *get_internal_data_path() { return pActivity->internalDataPath; }
static const char *get_external_data_path() { return pActivity->externalDataPath; }
static AAssetManager *get_asset_manager() { return pActivity->assetManager; }
static ANativeActivity *get_activity() { return pActivity; }
// --- event handling
static AInputQueue *input_event_queue() { return pInputQueue; }
// --- screen stuff
static bool copy_screen();
static inline ANativeWindow *native_window() { return pNativeWindow; }
static inline ANativeWindow_Buffer &graphics_buffer() { return pApplicationWindowBuffer; }
// --- timer stuff
static void send_timer_index(uint8_t ix);
static uint8_t receive_timer_index();
protected:
static void free_saved_state();
static void print_cur_config();
static void destroy();
static void* thread_entry(void* param);
// --- screen handling stuff
static void allocate_screen();
static bool lock_screen();
static void unlock_and_post_screen();
static bool screen_is_locked();
// --- timer stuff
static void create_timer_handler();
static void destroy_timer_handler();
static ANativeActivity *pActivity;
static AConfiguration *pConfig;
static void *pSavedState;
static size_t pSavedStateSize;
static ALooper *pAppLooper;
static AInputQueue *pInputQueue;
static ANativeWindow *pNativeWindow;
static ANativeWindow_Buffer pNativeWindowBuffer;
static ANativeWindow_Buffer pApplicationWindowBuffer;
static int pActivityState;
static int pDestroyRequested;
// ---- no need to make these visible to the outside ----
static pthread_mutex_t pMutex;
static pthread_cond_t pCond;
static int pMsgReadPipe;
static int pMsgWritePipe;
static pthread_t pThread;
static int pRunning;
static int pStateSaved;
static int pDestroyed;
static AInputQueue* pPendingInputQueue;
static ANativeWindow* pPendingWindow;
// --- timer variables
static int pTimerReadPipe;
static int pTimerWritePipe;
};
class Fl_Android_Activity : public Fl_Android_Application
{
public:
static void create(ANativeActivity* activity, void* savedState, size_t savedStateSize);
private:
static void set_activity(ANativeActivity *a) { pActivity = a; }
static void set_callbacks();
// ---- Android Native Activity interface
static void write_cmd(int8_t cmd);
static void set_input(AInputQueue* inputQueue);
static void set_window(ANativeWindow* window);
static void set_activity_state(int8_t cmd);
static void close_activity();
// ---- Android Native Activity callbacks ----
static void onContentRectChanged(ANativeActivity *activity, const ARect *rect);
static void onNativeWindowRedrawNeeded(ANativeActivity *activity, ANativeWindow *window);
static void onNativeWindowResized(ANativeActivity *activity, ANativeWindow *window);
static void onDestroy(ANativeActivity* activity);
static void onStart(ANativeActivity* activity);
static void onResume(ANativeActivity* activity);
static void* onSaveInstanceState(ANativeActivity* activity, size_t* outLen);
static void onPause(ANativeActivity* activity);
static void onStop(ANativeActivity* activity);
static void onConfigurationChanged(ANativeActivity* activity);
static void onLowMemory(ANativeActivity* activity);
static void onWindowFocusChanged(ANativeActivity* activity, int focused);
static void onNativeWindowCreated(ANativeActivity* activity, ANativeWindow* window);
static void onNativeWindowDestroyed(ANativeActivity* activity, ANativeWindow* window);
static void onInputQueueCreated(ANativeActivity* activity, AInputQueue* queue);
static void onInputQueueDestroyed(ANativeActivity* activity, AInputQueue* queue);
};
#endif // FL_ANDROID_APPLICATION_H

843
src/drivers/Android/Fl_Android_Application.cxx
View File

File diff suppressed because it is too large Load Diff

183
src/drivers/Android/Fl_Android_Graphics_Clipping.H
View File

@@ -1,183 +0,0 @@
//
// Graphics regions and clipping for the Fast Light Tool Kit (FLTK).
//
// Copyright 2018 by Bill Spitzak and others.
//
// This library is free software. Distribution and use rights are outlined in
// the file "COPYING" which should have been included with this file. If this
// file is missing or damaged, see the license at:
//
// https://www.fltk.org/COPYING.php
//
// Please see the following page on how to report bugs and issues:
//
// https://www.fltk.org/bugs.php
//
/**
\file Fl_Android_Graphics_Clipping.H
\brief Graphics regions and clipping for the Fast Light Tool Kit (FLTK).
*/
#ifndef FL_ANDROID_GRAPHICS_CLIPPING_H
#define FL_ANDROID_GRAPHICS_CLIPPING_H
#include <FL/Fl_Graphics_Driver.H>
#include <limits.h>
class Fl_Android_Window_Driver;
/**
The Fl_Rect_Region describes a rectangular clipping region.
Contrary to common FLTK convention, rectangles are stored with coordinates
instead of their width and height to accelerate calculations. The discreet
constructor however uses the old convention for convenience.
*/
class Fl_Rect_Region
{
public:
enum Type {
EMPTY = 0, SAME, LESS, MORE, INFINITE
};
Fl_Rect_Region();
Fl_Rect_Region(int x, int y, int w, int h);
Fl_Rect_Region(const Fl_Rect_Region&);
Fl_Rect_Region(enum Type what);
virtual ~Fl_Rect_Region() { }
int x() const { return pLeft; }
int y() const { return pTop; }
int w() const { return pRight - pLeft; }
int h() const { return pBottom - pTop; }
int left() const { return pLeft; }
int top() const { return pTop; }
int right() const { return pRight; }
int bottom() const { return pBottom; }
bool is_empty() const;
bool is_infinite() const;
virtual void set_empty();
void set(int x, int y, int w, int h);
void set_ltrb(int l, int t, int r, int b);
virtual void set(const Fl_Rect_Region &r);
virtual int intersect_with(const Fl_Rect_Region &r);
void add_to_bbox(const Fl_Rect_Region &r);
virtual void print(const char*) const;
protected:
int pLeft, pTop, pRight, pBottom;
private:
Fl_Rect_Region& operator = (const Fl_Rect_Region& other);
};
/**
The Fl_Complex_Region represents a clipping region of any shape.
This class is organized in a tree-like structure. If the region is
rectangular, is_simple() returns 1 and the rectangle can be used just
as in Fl_Rect_Region.
If a more complex representation is needed, subregions are created which are
guaranteed to lie within the bounding box of the current region. Subregions
themselves can again contain sub-subregions to describe the entire clipping
region, effectively creating a tree where the leafs contain the rectangles
that together describe the clipping area.
To make life easier, Fl_Complex_Region provides two types of iterator to
travers the entire tree.
1. Fl_Complex_Region itself is compatible to C++11 range-based loops and
can bewalked simply by writing ``for (auto &&it: rgn) { ... }``.
2. Fl_Complex_Region provides an alternative iterator that loop only through
leafs that intersects with a given rectangle. The returned object
provides access to the readily clipped rectangle.
\code
Fl_Complex_Region rgn(something);
for (auto &&it: rgn.iterate(Fl_Rect_Region(0, 0, 100, 100)) {
draw_something(it->rect());
}
\endcode
*/
class Fl_Complex_Region : public Fl_Rect_Region
{
class Iterator {
public:
Iterator(Fl_Complex_Region *r);
bool operator!= (const Iterator& other) const;
const Iterator& operator++ ();
Fl_Complex_Region *operator* () const;
Fl_Complex_Region *pRegion;
};
class Overlapping {
class OverlappingIterator {
public:
OverlappingIterator(Overlapping *ov);
bool operator!= (const OverlappingIterator& other) const;
const OverlappingIterator& operator++ ();
Overlapping *operator* () const;
Overlapping *pOv;
};
public:
Overlapping(Fl_Complex_Region *rgn, const Fl_Rect_Region &rect);
OverlappingIterator begin();
OverlappingIterator end();
Fl_Rect_Region &clipped_rect();
bool intersects();
bool find_intersecting();
bool find_next();
Fl_Complex_Region *pRegion;
Fl_Rect_Region pOriginalRect;
Fl_Rect_Region pClippedRect;
};
public:
Fl_Complex_Region();
Fl_Complex_Region(const Fl_Rect_Region&);
virtual ~Fl_Complex_Region() override;
void delete_all_subregions();
virtual void set(const Fl_Rect_Region &r) override;
void set(const Fl_Complex_Region &r);
virtual void set_empty() override { delete pSubregion; pSubregion=0L; Fl_Rect_Region::set_empty(); }
Fl_Complex_Region *subregion() const { return pSubregion; }
Fl_Complex_Region *next() const { return pNext; }
Fl_Complex_Region *parent() const { return pParent; }
char is_simple() const { return pSubregion==0; }
char is_complex() const { return pSubregion!=0; }
virtual int intersect_with(const Fl_Rect_Region &r) override;
int subtract(const Fl_Rect_Region &r);
virtual void print(const char*) const override;
Iterator begin();
Iterator end();
Overlapping overlapping(const Fl_Rect_Region &r);
protected:
void print_data(int indent) const;
int subtract_smaller_region(const Fl_Rect_Region &r);
Fl_Complex_Region *add_subregion();
void compress();
Fl_Complex_Region *pSubregion = 0L;
Fl_Complex_Region *pParent = 0L;
Fl_Complex_Region *pNext = 0L;
};
#endif // FL_ANDROID_GRAPHICS_CLIPPING_H

808
src/drivers/Android/Fl_Android_Graphics_Clipping.cxx
View File

File diff suppressed because it is too large Load Diff

352
src/drivers/Android/Fl_Android_Graphics_Driver.H
View File

@@ -1,352 +0,0 @@
//
// Definition of classes Fl_Graphics_Driver, Fl_Surface_Device, Fl_Display_Device
// for the Fast Light Tool Kit (FLTK).
//
// Copyright 2018 by Bill Spitzak and others.
//
// This library is free software. Distribution and use rights are outlined in
// the file "COPYING" which should have been included with this file. If this
// file is missing or damaged, see the license at:
//
// https://www.fltk.org/COPYING.php
//
// Please see the following page on how to report bugs and issues:
//
// https://www.fltk.org/bugs.php
//
/**
\file Fl_Android_Graphics_Driver.H
\brief Definition of Android graphics driver.
*/
#ifndef FL_ANDROID_GRAPHICS_DRIVER_H
#define FL_ANDROID_GRAPHICS_DRIVER_H
#include <FL/Fl_Graphics_Driver.H>
#include "Fl_Android_Graphics_Clipping.H"
#include "Fl_Android_Graphics_Font.H"
#include <limits.h>
class Fl_Android_Window_Driver;
class Fl_Android_Bytemap;
class Fl_Android_565A_Map;
/**
\brief The Windows-specific graphics driver class.
This class is implemented only on the Windows platform.
*/
class FL_EXPORT Fl_Android_Graphics_Driver : public Fl_Graphics_Driver
{
// easy access to the super class
typedef Fl_Graphics_Driver super;
protected:
class Vertex; // see below
// --- this is a copy of Fl_Graphics_Driver ----------------------------------
// - use this to find unimplementet calls in the derived driver
// - excluded by #if/#endif means that we have not implemneted this yet
// - methods marked with // super: use the implemnetation of the super class
// - virtual ... override functions are implemented for Android
private:
virtual void draw_fixed(Fl_RGB_Image * rgb,int XP, int YP, int WP, int HP, int cx, int cy) override;
virtual void draw_fixed(Fl_Pixmap * pxm,int XP, int YP, int WP, int HP, int cx, int cy) override;
virtual void draw_fixed(Fl_Bitmap *bm, int XP, int YP, int WP, int HP, int cx, int cy) override;
// some platforms may need to reimplement this
// This is called from the surface device, see: end_current()
// super: virtual void set_current_();
protected:
/** Sets the current value of the scaling factor */
// super: virtual void scale(float f) { scale_ = f; } // we do not support any scaling at this point
protected:
// set fl_gc, which we do not use in the Android port at this point
// super: virtual void global_gc();
/** Support function for Fl_Pixmap drawing */
virtual void cache(Fl_Pixmap *img) override;
/** Support function for Fl_Bitmap drawing */
virtual void cache(Fl_Bitmap *img) override;
virtual void cache(Fl_RGB_Image *img) override;
/** Support function for Fl_RGB_Image drawing */
virtual void uncache(Fl_RGB_Image *img, fl_uintptr_t &id_, fl_uintptr_t &mask_) override;
// --- implementation is in src/drivers/xxx/Fl_xxx_Graphics_Driver_image.cxx
/** see fl_draw_image(const uchar* buf, int X,int Y,int W,int H, int D, int L) */
virtual void draw_image(const uchar* buf, int X,int Y,int W,int H, int D=3, int L=0) override;
/** see fl_draw_image_mono(const uchar* buf, int X,int Y,int W,int H, int D, int L) */
virtual void draw_image_mono(const uchar* buf, int X,int Y,int W,int H, int D=1, int L=0) override;
/** see fl_draw_image(Fl_Draw_Image_Cb cb, void* data, int X,int Y,int W,int H, int D) */
virtual void draw_image(Fl_Draw_Image_Cb cb, void* data, int X,int Y,int W,int H, int D=3) override;
/** see fl_draw_image_mono(Fl_Draw_Image_Cb cb, void* data, int X,int Y,int W,int H, int D) */
virtual void draw_image_mono(Fl_Draw_Image_Cb cb, void* data, int X,int Y,int W,int H, int D=1) override;
#if 0
// TODO: where are begine_, end_, create_, and delete_offscreen? Answer: Fl_Image_Surface - you know what to do!
virtual void copy_offscreen(int x, int y, int w, int h, Fl_Offscreen pixmap, int srcx, int srcy);
/** Support function for image drawing */
// TODO: these seem to be only needed if FL_Image and Fl_Pixmap store alpha values seperatley.
virtual Fl_Bitmask create_bitmask(int w, int h, const uchar *array) {return 0; }
#endif
// Support function for image drawing
virtual void uncache_pixmap(fl_uintptr_t p) override;
// Support function for image drawing
virtual void delete_bitmask(Fl_Bitmask bm) override;
public:
/** Constructor, C++11 initialises member variables in-line */
Fl_Android_Graphics_Driver();
/** destructor */
virtual ~Fl_Android_Graphics_Driver() override;
/** Return whether the graphics driver can do alpha blending */
virtual char can_do_alpha_blending() override { return 0; }
// --- implementation is in src/fl_rect.cxx which includes src/drivers/xxx/Fl_xxx_Graphics_Driver_rect.cxx
/** see fl_point() */
virtual void point(int x, int y) override;
/** see fl_rect() */
virtual void rect(int x, int y, int w, int h) override;
// super: virtual void focus_rect(int x, int y, int w, int h);
/** see fl_rectf() */
virtual void rectf(int x, int y, int w, int h) override;
/** see fl_line(int, int, int, int) */
virtual void line(int x, int y, int x1, int y1) override;
/** see fl_line(int, int, int, int, int, int) */
virtual void line(int x, int y, int x1, int y1, int x2, int y2) override;
/** see fl_xyline(int, int, int) */
virtual void xyline(int x, int y, int x1) override;
/** see fl_xyline(int, int, int, int) */
virtual void xyline(int x, int y, int x1, int y2) override;
/** see fl_xyline(int, int, int, int, int) */
virtual void xyline(int x, int y, int x1, int y2, int x3) override;
/** see fl_yxline(int, int, int) */
virtual void yxline(int x, int y, int y1) override;
/** see fl_yxline(int, int, int, int) */
virtual void yxline(int x, int y, int y1, int x2) override;
/** see fl_yxline(int, int, int, int, int) */
virtual void yxline(int x, int y, int y1, int x2, int y3) override;
/** see fl_loop(int, int, int, int, int, int) */
virtual void loop(int x0, int y0, int x1, int y1, int x2, int y2) override;
/** see fl_loop(int, int, int, int, int, int, int, int) */
virtual void loop(int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3) override;
/** see fl_polygon(int, int, int, int, int, int) */
virtual void polygon(int x0, int y0, int x1, int y1, int x2, int y2) override;
/** see fl_polygon(int, int, int, int, int, int, int, int) */
virtual void polygon(int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3) override;
// --- clipping
/** see fl_push_clip() */
virtual void push_clip(int x, int y, int w, int h) override;
/** see fl_clip_box() */
virtual int clip_box(int x, int y, int w, int h, int &X, int &Y, int &W, int &H) override;
/** see fl_not_clipped() */
virtual int not_clipped(int x, int y, int w, int h) override;
/** see fl_push_no_clip() */
virtual void push_no_clip() override;
/** see fl_pop_clip() */
virtual void pop_clip() override;
virtual Fl_Region clip_region() override;
virtual void clip_region(Fl_Region r) override;
virtual void restore_clip() override;
// --- implementation is in src/fl_vertex.cxx which includes src/drivers/xxx/Fl_xxx_Graphics_Driver_vertex.cxx
// super: virtual void push_matrix();
// super: virtual void pop_matrix();
// super: virtual void mult_matrix(double a, double b, double c, double d, double x, double y);
// super: virtual void rotate(double d);
// super: virtual void translate(double x,double y);
virtual void begin_points() override;
virtual void begin_line() override;
virtual void begin_loop() override;
virtual void begin_polygon() override;
virtual void begin_complex_polygon() override;
// super: virtual double transform_x(double x, double y);
// super: virtual double transform_y(double x, double y);
// super: virtual double transform_dx(double x, double y);
// super: virtual double transform_dy(double x, double y);
/** see fl_transformed_vertex() */
virtual void transformed_vertex(double xf, double yf) override;
/** see fl_vertex() */
virtual void vertex(double x, double y) override;
/** see fl_end_points() */
virtual void end_points() override;
/** see fl_end_line() */
virtual void end_line() override;
/** see fl_end_loop() */
virtual void end_loop() override;
/** see fl_end_polygon() */
virtual void end_polygon() override;
/** see fl_end_complex_polygon() */
virtual void end_complex_polygon() override;
/** see fl_gap() */
virtual void gap() override;
/** see fl_circle() */
virtual void circle(double x, double y, double r) override;
// --- implementation is in src/fl_arc.cxx which includes src/drivers/xxx/Fl_xxx_Graphics_Driver_arc.cxx if needed
virtual void arc(double x, double y, double r, double start, double end) override { super::arc(x, y, r, start, end); }
// --- implementation is in src/fl_arci.cxx which includes src/drivers/xxx/Fl_xxx_Graphics_Driver_arci.cxx
/** see fl_arc(int x, int y, int w, int h, double a1, double a2) */
virtual void arc(int x, int y, int w, int h, double a1, double a2) override;
/** see fl_pie() */
virtual void pie(int x, int y, int w, int h, double a1, double a2) override;
// --- implementation is in src/fl_curve.cxx which includes src/drivers/xxx/Fl_xxx_Graphics_Driver_curve.cxx if needed
// super: virtual void curve(double X0, double Y0, double X1, double Y1, double X2, double Y2, double X3, double Y3);
// --- implementation is in src/fl_line_style.cxx which includes src/cfg_gfx/xxx_line_style.cxx
// TODO: line_style()
/** see fl_line_style() */
virtual void line_style(int style, int width=0, char* dashes=0) override;
// --- implementation is in src/fl_color.cxx which includes src/cfg_gfx/xxx_color.cxx
/** see fl_color(Fl_Color) */
virtual void color(Fl_Color c) override { super::color(c); }
virtual void set_color(Fl_Color i, unsigned int c) override;
// super: virtual void free_color(Fl_Color i, int overlay);
/** see fl_color(void) */
virtual Fl_Color color() override { return super::color(); }
/** see fl_color(uchar, uchar, uchar) */
virtual void color(uchar r, uchar g, uchar b) override;
/** see fl_draw(const char *str, int n, int x, int y) */
virtual void draw(const char *str, int n, int x, int y) override;
/** Draw the first \p n bytes of the string \p str starting at position \p x , \p y */
// super: virtual void draw(const char *str, int n, float x, float y);
/** see fl_draw(int angle, const char *str, int n, int x, int y) */
// TODO: drawing text at an angle is not supported
virtual void draw(int angle, const char *str, int n, int x, int y) override { draw(str, n, x, y); }
/** see fl_rtl_draw(const char *str, int n, int x, int y) */
// TODO: drawing text right-to-left is not supported
virtual void rtl_draw(const char *str, int n, int x, int y) override { draw(str, n, x, y); }
/** Returns non-zero if the graphics driver possesses the \p feature */
// super: virtual int has_feature(driver_feature feature)
/** see fl_font(Fl_Font, Fl_Fontsize) */
virtual void font(Fl_Font face, Fl_Fontsize fsize) override;
/** see fl_font(void) */
virtual Fl_Font font() override { return super::font(); }
/** Return the current font size */
virtual Fl_Fontsize size() override;
/** Compute the width of the first \p n bytes of the string \p str if drawn with current font */
virtual double width(const char *str, int n) override;
/** Compute the width of Unicode character \p c if drawn with current font */
virtual double width(unsigned int c) override;
virtual void text_extents(const char*, int n, int& dx, int& dy, int& w, int& h) override;
/** Return the current line height */
virtual int height() override;
/** Return the current line descent */
virtual int descent() override;
/** Return the current Fl_Font_Descriptor */
// super: inline Fl_Font_Descriptor *font_descriptor() { return font_descriptor_;}
/** Set the current Fl_Font_Descriptor */
// super: virtual void font_descriptor(Fl_Font_Descriptor *d) { font_descriptor_ = d;}
#if 0
// FIXME: do we need to implement any of the functions below?
/** Sets the value of the driver-specific graphics context. */
virtual void gc(void*) {}
/** Returns the driver-specific graphics context, of NULL if there's none. */
virtual void *gc(void) {return NULL;}
/** Support for pixmap drawing */
virtual uchar **mask_bitmap() { return 0; }
/** Support for pixmap drawing */
virtual void mask_bitmap(uchar **) {}
#endif
// default implementation may be enough
/** Support for PostScript drawing */
virtual float scale_font_for_PostScript(Fl_Font_Descriptor *desc, int s) override { return float(s); }
// default implementation may be enough
/** Support for PostScript drawing - no documentation found on this call*/
// super: virtual float scale_bitmap_for_PostScript() { return 2; }
// super: virtual void set_spot(int font, int size, int X, int Y, int W, int H, Fl_Window *win);
// super: virtual void reset_spot();
// each platform implements these 3 functions its own way
/* TODO: Android: we can implement this to have a redraw region based on Fl::damage
* calls. Currently, we do not implement damage regions, but we can probably
* implement this using our clipping regions. This may become neccesary when
* we allow desktop-style window movement.
*/
// super: virtual void add_rectangle_to_region(Fl_Region r, int x, int y, int w, int h);
// super: virtual Fl_Region XRectangleRegion(int x, int y, int w, int h);
// super: virtual void XDestroyRegion(Fl_Region r);
/** Support for Fl::get_font_name() */
virtual const char* get_font_name(Fl_Font fnum, int* ap) override;
/** Support for Fl::get_font_sizes() */
virtual int get_font_sizes(Fl_Font fnum, int*& sizep) override;
/** Support for Fl::set_fonts() */
virtual Fl_Font set_fonts(const char *name) override;
/** Some platforms may need to implement this to support fonts */
// super: virtual Fl_Fontdesc* calc_fl_fonts(void) {return NULL;}
/** Support for Fl::set_font() */
// super: virtual unsigned font_desc_size();
/** Support for Fl::get_font() */
virtual const char *font_name(int num) override;
/** Support for Fl::set_font() */
virtual void font_name(int num, const char *name) override;
/** Support function for fl_overlay_rect() and scaled GUI.
Defaut implementation may be enough */
// super: virtual void overlay_rect(int x, int y, int w , int h) { loop(x, y, x+w-1, y, x+w-1, y+h-1, x, y+h-1); }
// --- end of original Fl_Graphics_Driver header -----------------------------
// --- start of Android additions --------------------------------------------
// start drawing with this driver into the given window
// The virtual call `set_current_()` changes surface, not windows
void make_current(Fl_Window*);
protected:
static uint16_t make565(uchar r, uchar g, uchar b);
static uint16_t make565(Fl_Color crgba);
void rectf_unclipped(int x, int y, int w, int h);
void xyline_unclipped(int x, int y, int x1);
void yxline_unclipped(int x, int y, int y1);
void end_polygon(int begin, int end);
void ellipse(double xt, double yt, double rx, double ry);
void draw(int xx, int yy, Fl_Android_565A_Map *bm, Fl_Rect_Region &r);
void draw(int x, int y, Fl_Android_Bytemap *bm, Fl_Rect_Region &r);
int render_letter(int xx, int yy, uint32_t c, Fl_Rect_Region &r);
// pointer into the screen buffer at the top left corner of the current window
uint16_t *pBits = nullptr;
// advance to next line in screen buffer
int32_t pStride = 0;
// TODO: current line style, temp kludge to make focus rect work.
int pLineStyle = 0;
// Clipping region of the current window in window coordinates (see: pStride and pBits)
Fl_Rect_Region pWindowRegion;
// clipping region of the window minus overlapping other windows
Fl_Complex_Region pDesktopWindowRegion;
// Final clipping region for all graphics calls to this class.
Fl_Complex_Region pClippingRegion;
// store vertices for begin_.../end_... drawing
class Vertex {
public:
void set(float x, float y, bool gap = false) { pX = x; pY = y; pIsGap = gap; }
float pX, pY;
bool pIsGap;
};
void begin_vertices();
void add_vertex(float x, float y, bool gap=false);
int pnVertex = 0, pNVertex = 0, pVertexGapStart = 0;
Vertex *pVertex = nullptr;
};
#if 0
/**
The graphics driver used when printing on Android.
*/
class FL_EXPORT Fl_Android_Printer_Graphics_Driver : public Fl_Android_Graphics_Driver {
#if 0
private:
typedef BOOL (WINAPI* transparent_f_type) (HDC,int,int,int,int,HDC,int,int,int,int,UINT);
transparent_f_type TransparentBlt();
public:
virtual int has_feature(driver_feature mask) { return mask & (NATIVE | PRINTER); }
void draw_unscaled(Fl_Pixmap *pxm, float s, int XP, int YP, int WP, int HP, int cx, int cy);
void draw_unscaled(Fl_Bitmap *bm, float s, int XP, int YP, int WP, int HP, int cx, int cy);
#endif
};
#endif
#endif // FL_ANDROID_GRAPHICS_DRIVER_H

1257
src/drivers/Android/Fl_Android_Graphics_Driver.cxx
View File

File diff suppressed because it is too large Load Diff

132
src/drivers/Android/Fl_Android_Graphics_Font.H
View File

@@ -1,132 +0,0 @@
//
// Font definitions for the Fast Light Tool Kit (FLTK).
//
// Copyright 1998-2018 by Bill Spitzak and others.
//
// This library is free software. Distribution and use rights are outlined in
// the file "COPYING" which should have been included with this file. If this
// file is missing or damaged, see the license at:
//
// https://www.fltk.org/COPYING.php
//
// Please see the following page on how to report bugs and issues:
//
// https://www.fltk.org/bugs.php
//
#ifndef FL_ANDROID_GRAPHICS_FONT_H
#define FL_ANDROID_GRAPHICS_FONT_H
#include "Fl_Android_Graphics_Driver.H"
// We violate FLTKs avoidance of STL because we live in a defined driver space
#define FL_ALLOW_STL 1
#ifdef FL_ALLOW_STL
#include <map>
#endif
#include "stb_truetype.h"
/**
A bytemap is an array of bytes, used as an alpha channel when redering glyphs
in a given color.
TODO: reate a class for RGB only and for grayscale and grayscale with alpha
TODO: derive all this from a baseclass, so we can create the correct class for the required image
*/
class Fl_Android_Bytemap
{
public:
Fl_Android_Bytemap();
Fl_Android_Bytemap(int w, int h);
~Fl_Android_Bytemap();
public:
int pWidth = 0, pHeight = 0, pStride = 0;
int pXOffset = 0, pYOffset = 0, pAdvance = 0;
unsigned char *pBytes = nullptr;
};
/**
A 565a map is an array of words for interleaved RGB and Alpha data.
565 is the number of bit per component, compatible with our screen memory
scheme. The second word is actually a byt containing the alpha value for
the previous pixel: rrrrrggg.gggbbbbb.aaaaaaaa.00000000
*/
class Fl_Android_565A_Map
{
public:
Fl_Android_565A_Map();
Fl_Android_565A_Map(int w, int h);
~Fl_Android_565A_Map();
static inline uint32_t toRGBA(uchar r, uchar g, uchar b, uchar a)
{
return ((((r << 8) & 0xf800) |
((g << 3) & 0x07e0) |
((b >> 3) & 0x001f)) << 16) | a;
}
public:
int pWidth = 0, pHeight = 0, pStride = 0;
int pXOffset = 0, pYOffset = 0;
uint32_t *pWords = nullptr;
};
/**
This class reads True Type Font files and creates Bytemaps for glyphs at the
requested height.
*/
class Fl_Android_Font_Source
{
private:
stbtt_fontinfo pFont;
uint8_t *pFileBuffer;
const char *pName;
Fl_Font pFontIndex;
bool pError;
bool load_font(const char *name);
bool load_font_file(const char *name);
bool load_font_asset(const char *name);
public:
Fl_Android_Font_Source(const char *fname, Fl_Font fnum);
~Fl_Android_Font_Source();
void load_font();
Fl_Android_Bytemap *get_bytemap(uint32_t c, int size);
float get_advance(uint32_t c, Fl_Fontsize size);
int get_descent(Fl_Fontsize size);
};
/**
This class caches glyphs of a font for a specified height.
*/
class Fl_Android_Font_Descriptor : public Fl_Font_Descriptor
{
#ifdef FL_ALLOW_STL
typedef std::map<uint32_t, Fl_Android_Bytemap*> BytemapTable;
#else
typedef Fl_Android_Bytemap* BytemapTable[256];
#endif
private:
Fl_Android_Font_Source *pFontSource;
Fl_Font pFontIndex;
BytemapTable pBytemapTable;
public:
Fl_Android_Font_Descriptor(const char *fname, Fl_Android_Font_Source *fsrc, Fl_Font fnum, Fl_Fontsize size);
~Fl_Android_Font_Descriptor();
float get_advance(uint32_t c);
Fl_Android_Bytemap *get_bytemap(uint32_t c);
Fl_Android_Font_Source *get_font_source() { return pFontSource; }
int get_descent();
static Fl_Android_Font_Descriptor* find(Fl_Font fnum, Fl_Fontsize size);
};
#endif // FL_ANDROID_GRAPHICS_FONT_H

797
src/drivers/Android/Fl_Android_Graphics_Font.cxx
View File

File diff suppressed because it is too large Load Diff

115
src/drivers/Android/Fl_Android_Image_Surface_Driver.cxx
View File

@@ -1,115 +0,0 @@
//
// Draw-to-image code for the Fast Light Tool Kit (FLTK).
//
// Copyright 2018 by Bill Spitzak and others.
//
// This library is free software. Distribution and use rights are outlined in
// the file "COPYING" which should have been included with this file. If this
// file is missing or damaged, see the license at:
//
// https://www.fltk.org/COPYING.php
//
// Please see the following page on how to report bugs and issues:
//
// https://www.fltk.org/bugs.php
//
#include <config.h>
#include "Fl_Android_Graphics_Driver.H"
//#include "../WinAPI/Fl_WinAPI_Screen_Driver.H"
#include <FL/Fl_Image_Surface.H>
#include <FL/fl_draw.H>
#include <FL/platform.H>
//#include <windows.h>
class Fl_Android_Image_Surface_Driver : public Fl_Image_Surface_Driver {
#if 0
virtual void end_current_(Fl_Surface_Device*);
public:
Window pre_window;
int _savedc;
#endif
public:
Fl_Android_Image_Surface_Driver(int w, int h, int high_res, Fl_Offscreen off)
: Fl_Image_Surface_Driver(w, h, high_res, off) {}
#if 0
~Fl_GDI_Image_Surface_Driver();
POINT origin;
#endif
void set_current() override { } // TODO: write me
void translate(int x, int y) override { } // TODO: write me
void untranslate() override { } // TODO: write me
Fl_RGB_Image *image() override { return nullptr; } // TODO: write me
};
Fl_Image_Surface_Driver *Fl_Image_Surface_Driver::newImageSurfaceDriver(int w, int h, int high_res, Fl_Offscreen off)
{
return new Fl_Android_Image_Surface_Driver(w, h, high_res, off);
}
#if 0
Fl_GDI_Image_Surface_Driver::Fl_GDI_Image_Surface_Driver(int w, int h, int high_res, Fl_Offscreen off) : Fl_Image_Surface_Driver(w, h, high_res, 0) {
float d = fl_graphics_driver->scale();
if (!off && d != 1 && high_res) {
w = int(w*d);
h = int(h*d);
}
HDC gc = (HDC)Fl_Graphics_Driver::default_driver().gc();
offscreen = off ? off : CreateCompatibleBitmap( (gc ? gc : fl_GetDC(0) ) , w, h);
if (!offscreen) offscreen = CreateCompatibleBitmap(fl_GetDC(0), w, h);
driver(new Fl_GDI_Graphics_Driver);
if (d != 1 && high_res) ((Fl_GDI_Graphics_Driver*)driver())->scale(d);
origin.x = origin.y = 0;
}
Fl_GDI_Image_Surface_Driver::~Fl_GDI_Image_Surface_Driver() {
if (offscreen) DeleteObject(offscreen);
delete driver();
}
void Fl_GDI_Image_Surface_Driver::set_current() {
HDC gc = fl_makeDC(offscreen);
driver()->gc(gc);
SetWindowOrgEx(gc, origin.x, origin.y, NULL);
Fl_Surface_Device::set_current();
pre_window = fl_window;
_savedc = SaveDC(gc);
fl_window=(HWND)offscreen;
}
void Fl_GDI_Image_Surface_Driver::translate(int x, int y) {
((Fl_GDI_Graphics_Driver*)driver())->translate_all(x, y);
}
void Fl_GDI_Image_Surface_Driver::untranslate() {
((Fl_GDI_Graphics_Driver*)driver())->untranslate_all();
}
Fl_RGB_Image* Fl_GDI_Image_Surface_Driver::image()
{
Fl_RGB_Image *image = Fl::screen_driver()->read_win_rectangle( 0, 0, width, height);
return image;
}
void Fl_GDI_Image_Surface_Driver::end_current_(Fl_Surface_Device*)
{
HDC gc = (HDC)driver()->gc();
GetWindowOrgEx(gc, &origin);
RestoreDC(gc, _savedc);
DeleteDC(gc);
fl_window = pre_window;
}
#endif

176
src/drivers/Android/Fl_Android_Screen_Driver.H
View File

@@ -1,176 +0,0 @@
//
// Definition of Android screen interface
// for the Fast Light Tool Kit (FLTK).
//
// Copyright 2018 by Bill Spitzak and others.
//
// This library is free software. Distribution and use rights are outlined in
// the file "COPYING" which should have been included with this file. If this
// file is missing or damaged, see the license at:
//
// https://www.fltk.org/COPYING.php
//
// Please see the following page on how to report bugs and issues:
//
// https://www.fltk.org/bugs.php
//
/**
\file Fl_Android_Screen_Driver.H
\brief Definition of Android screen interface.
*/
#ifndef FL_ANDROID_SCREEN_DRIVER_H
#define FL_ANDROID_SCREEN_DRIVER_H
#include "../../Fl_Screen_Driver.H"
#include <FL/Fl_Rect.H>
#include <android/input.h>
//#include <windows.h>
extern void (*fl_unlock_function)();
extern void (*fl_lock_function)();
class Fl_Window;
class FL_EXPORT Fl_Android_Screen_Driver : public Fl_Screen_Driver
{
// easy access to the super class
typedef Fl_Screen_Driver super;
#if 0
// No, this is not how we will implement this.
enum {
/// request attribute for a specific screen; default to screen 0
INDEX = 0x0001, // add an integer in the vararg list
/// allow or lock screen rotation
ROTATION_MASK = 0x0006, ROTATION_KEEP = 0x0000,
MAY_ROTATE = 0x0006, LOCK_TO_PORTRAIT = 0x0002, LOCK_TO_LANDSCAPE = 0x0004,
/// screen size
SIZE_MASK = 0x0038, SIZE_KEEP = 0x0000,
NATIVE_SIZE = 0x0008, // keep the full native screen size
FIRST_WINDOW = 0x0010, // adapt the screen to the size of the first window
ALL_WINDOWS = 0x0018, // adapt the screen to show all windows
FIXED_DIAGONAL = 0x0020, // keep aspect ration at 1:1, add an int for the length of the diagonal
// fixed size override the previous flags for portrait and/or landscape
FIXED_PORTRAIT_SIZE = 0x0040, // add two int width and height
NO_FIXED_PORTRAIT_SIZE = 0x80000040, // release fixed portrait size
FIXED_LANDSCAPE_SIZE = 0x0080, // add two int width and height
NO_FIXED_LANDSCAPE_SIZE = 0x80000080, // release fixed landscape size
// show or hide mobile device screen items
SHOW_STATUS_BAR = 0x0080, // top of the screen
HIDE_STATUS_BAR = 0x80000080, // top of the screen
SHOW_NAVIGATION_BAR = 0x0100, // bottom of the screen
HIDE_NAVIGATION_BAR = 0x0100, // bottom of the screen
};
/// request some attributes from a screen that may or may not be met
virtual hint(unsigned int flags, ...);
#endif
private:
int handle_queued_events(double time_to_wait);
int handle_app_command();
int handle_input_event();
int handle_keyboard_event(AInputQueue*, AInputEvent*);
int handle_mouse_event(AInputQueue*, AInputEvent*);
public:
Fl_Android_Screen_Driver();
virtual void add_timeout(double time, Fl_Timeout_Handler cb, void *argp) override;
virtual void repeat_timeout(double time, Fl_Timeout_Handler cb, void *argp) override;
virtual int has_timeout(Fl_Timeout_Handler cb, void *argp) override;
virtual void remove_timeout(Fl_Timeout_Handler cb, void *argp) override;
virtual int compose(int &del) override;
virtual void request_keyboard() override;
virtual void release_keyboard() override;
int pKeyboardCount = 0;
#if 0
Fl_WinAPI_Screen_Driver() : Fl_Screen_Driver() {
for (int i = 0; i < MAX_SCREENS; i++) scale_of_screen[i] = 1;
}
// --- display management
virtual int visual(int flags);
// --- screen configuration
virtual void init();
#endif
virtual int x() override { return 0; } // FIXME:
virtual int y() override { return 0; } // FIXME:
virtual int w() override { return 600; } // FIXME:
virtual int h() override { return 800; } // FIXME:
virtual void screen_xywh(int &X, int &Y, int &W, int &H, int n) override
{ X = 0; Y = 0; W = 600; H = 800; } // FIXME:
#if 0
virtual void screen_dpi(float &h, float &v, int n=0);
int screen_num_unscaled(int x, int y);
#endif
virtual void screen_work_area(int &X, int &Y, int &W, int &H, int n) override
{ X = 0; Y = 0; W = 600; H = 800; } // FIXME:
// --- audible output
virtual void beep(int type) override;
// --- global events
virtual void flush() override;
virtual double wait(double time_to_wait) override;
#if 0
virtual int ready();
#endif
virtual void grab(Fl_Window* win) override;
#if 0
// --- global colors
virtual void get_system_colors();
virtual const char *get_system_scheme();
// --- global timers
virtual int dnd(int unused);
virtual int compose(int &del);
virtual Fl_RGB_Image *read_win_rectangle(int X, int Y, int w, int h);
Fl_RGB_Image *read_win_rectangle_unscaled(int X, int Y, int w, int h);
#endif
virtual int get_mouse(int &x, int &y) override;
#if 0
virtual void enable_im();
virtual void disable_im();
virtual void open_display_platform();
virtual void offscreen_size(Fl_Offscreen off, int &width, int &height);
#if defined(FLTK_HIDPI_SUPPORT)
virtual APP_SCALING_CAPABILITY rescalable() {
return PER_SCREEN_APP_SCALING;
}
virtual float scale(int n) {
return scale_of_screen[n];
}
virtual void scale(int n, float f) {
scale_of_screen[n] = f;
}
#else
float DWM_scaling_factor();
#endif
virtual float desktop_scale_factor();
#endif
#if 0
protected:
RECT screens[MAX_SCREENS];
RECT work_area[MAX_SCREENS];
float dpi[MAX_SCREENS][2];
float scale_of_screen[MAX_SCREENS];
static BOOL CALLBACK screen_cb(HMONITOR mon, HDC, LPRECT r, LPARAM);
BOOL screen_cb(HMONITOR mon, HDC, LPRECT r);
int get_mouse_unscaled(int &mx, int &my);
#ifdef FLTK_HIDPI_SUPPORT
void init_screen_scale_factors();
#endif
#endif
bool pContentChanged;
bool pClearDesktop;
};
#endif // FL_ANDROID_SCREEN_DRIVER_H

568
src/drivers/Android/Fl_Android_Screen_Driver.cxx
View File

File diff suppressed because it is too large Load Diff

452
src/drivers/Android/Fl_Android_Screen_Keyboard.cxx
View File

@@ -1,452 +0,0 @@
//
// Android screen interface for the Fast Light Tool Kit (FLTK).
//
// Copyright 1998-2018 by Bill Spitzak and others.
//
// This library is free software. Distribution and use rights are outlined in
// the file "COPYING" which should have been included with this file. If this
// file is missing or damaged, see the license at:
//
// https://www.fltk.org/COPYING.php
//
// Please see the following page on how to report bugs and issues:
//
// https://www.fltk.org/bugs.php
//
#include <config.h>
#include "Fl_Android_Screen_Driver.H"
#include "Fl_Android_Application.H"
#include "Fl_Android_Graphics_Font.H"
#include <FL/Fl.H>
#include <FL/platform.H>
#include <FL/Fl_Graphics_Driver.H>
#include <FL/Fl_RGB_Image.H>
#include <FL/fl_ask.H>
#include <stdio.h>
#include <errno.h>
#include <math.h>
// convert an FLTK (X) keysym to a MacOS symbol:
// This table is in numeric order by FLTK symbol order for binary search.
static const struct {unsigned short vk, fltk;} vktab[] = {
{ AKEYCODE_SPACE, ' ' }, { AKEYCODE_APOSTROPHE, '\'' }, { AKEYCODE_COMMA, ',' }, { AKEYCODE_MINUS, '-' }, { AKEYCODE_PERIOD, '.' }, { AKEYCODE_SLASH, '/' },
{ AKEYCODE_0, '0' }, { AKEYCODE_1, '1' }, { AKEYCODE_2, '2' }, { AKEYCODE_3, '3' },
{ AKEYCODE_4, '4' }, { AKEYCODE_5, '5' }, { AKEYCODE_6, '6' }, { AKEYCODE_7, '7' },
{ AKEYCODE_8, '8' }, { AKEYCODE_9, '9' }, { AKEYCODE_SEMICOLON, ';' }, { AKEYCODE_EQUALS, '=' },
{ AKEYCODE_A, 'A' }, { AKEYCODE_B, 'B' }, { AKEYCODE_C, 'C' }, { AKEYCODE_D, 'D' },
{ AKEYCODE_E, 'E' }, { AKEYCODE_F, 'F' }, { AKEYCODE_G, 'G' }, { AKEYCODE_H, 'H' },
{ AKEYCODE_I, 'I' }, { AKEYCODE_J, 'J' }, { AKEYCODE_K, 'K' }, { AKEYCODE_L, 'L' },
{ AKEYCODE_M, 'M' }, { AKEYCODE_N, 'N' }, { AKEYCODE_O, 'O' }, { AKEYCODE_P, 'P' },
{ AKEYCODE_Q, 'Q' }, { AKEYCODE_R, 'R' }, { AKEYCODE_S, 'S' }, { AKEYCODE_T, 'T' },
{ AKEYCODE_U, 'U' }, { AKEYCODE_V, 'V' }, { AKEYCODE_W, 'W' }, { AKEYCODE_X, 'X' },
{ AKEYCODE_Y, 'Y' }, { AKEYCODE_Z, 'Z' },
{ AKEYCODE_LEFT_BRACKET, '[' }, { AKEYCODE_BACKSLASH, '\\' }, { AKEYCODE_RIGHT_BRACKET, ']' }, { AKEYCODE_GRAVE, '`' },
{ AKEYCODE_VOLUME_DOWN, FL_Volume_Down}, { AKEYCODE_MUTE, FL_Volume_Mute}, { AKEYCODE_VOLUME_UP, FL_Volume_Up},
#if 0
#define FL_Volume_Down 0xEF11 /* Volume control down */
513 #define FL_Volume_Mute 0xEF12 /* Mute sound from the system */
514 #define FL_Volume_Up 0xEF13 /* Volume control up */
515 #define FL_Media_Play 0xEF14 /* Start playing of audio */
516 #define FL_Media_Stop 0xEF15 /* Stop playing audio */
517 #define FL_Media_Prev 0xEF16 /* Previous track */
518 #define FL_Media_Next 0xEF17 /* Next track */
519 #define FL_Home_Page 0xEF18 /* Display user's home page */
520 #define FL_Mail 0xEF19 /* Invoke user's mail program */
521 #define FL_Search 0xEF1B /* Search */
522 #define FL_Back 0xEF26 /* Like back on a browser */
523 #define FL_Forward 0xEF27 /* Like forward on a browser */
524 #define FL_Stop 0xEF28 /* Stop current operation */
525 #define FL_Refresh 0xEF29 /* Refresh the page */
526 #define FL_Sleep 0xEF2F /* Put system to sleep */
527 #define FL_Favorites 0xEF30 /* Show favorite locations */
528
#endif
{ AKEYCODE_DEL, FL_BackSpace }, { AKEYCODE_TAB, FL_Tab }, { AKEYCODE_POUND, FL_Iso_Key }, { AKEYCODE_ENTER, FL_Enter }, /*{ 0x7F, FL_Pause },
{ 0x7F, FL_Scroll_Lock },*/ { AKEYCODE_ESCAPE, FL_Escape },
{ AKEYCODE_KANA, FL_Kana}, { AKEYCODE_EISU, FL_Eisu}, { AKEYCODE_YEN, FL_Yen}, /*{ AKEYCODE_UND, FL_JIS_Underscore},*/
{ AKEYCODE_MOVE_HOME, FL_Home }, { AKEYCODE_DPAD_LEFT, FL_Left },
{ AKEYCODE_DPAD_UP, FL_Up }, { AKEYCODE_DPAD_RIGHT, FL_Right }, { AKEYCODE_DPAD_DOWN, FL_Down }, { AKEYCODE_PAGE_UP, FL_Page_Up },
{ AKEYCODE_PAGE_DOWN, FL_Page_Down }, { AKEYCODE_MOVE_END, FL_End }, { AKEYCODE_SYSRQ, FL_Print }, { AKEYCODE_INSERT, FL_Insert },
{ AKEYCODE_MENU, FL_Menu }, { AKEYCODE_HELP, FL_Help }, { AKEYCODE_NUM_LOCK, FL_Num_Lock },
{ AKEYCODE_NUMPAD_ENTER, FL_KP_Enter }, { AKEYCODE_NUMPAD_MULTIPLY, FL_KP+'*' }, { AKEYCODE_NUMPAD_ADD, FL_KP+'+'},
{ AKEYCODE_NUMPAD_COMMA, FL_KP+',' },
{ AKEYCODE_NUMPAD_SUBTRACT, FL_KP+'-' }, { AKEYCODE_NUMPAD_DOT, FL_KP+'.' }, { AKEYCODE_NUMPAD_DIVIDE, FL_KP+'/' },
{ AKEYCODE_NUMPAD_0, FL_KP+'0' }, { AKEYCODE_NUMPAD_1, FL_KP+'1' }, { AKEYCODE_NUMPAD_2, FL_KP+'2' }, { AKEYCODE_NUMPAD_3, FL_KP+'3' },
{ AKEYCODE_NUMPAD_4, FL_KP+'4' }, { AKEYCODE_NUMPAD_5, FL_KP+'5' }, { AKEYCODE_NUMPAD_6, FL_KP+'6' }, { AKEYCODE_NUMPAD_7, FL_KP+'7' },
{ AKEYCODE_NUMPAD_8, FL_KP+'8' }, { AKEYCODE_NUMPAD_9, FL_KP+'9' }, { AKEYCODE_NUMPAD_EQUALS, FL_KP+'=' },
{ AKEYCODE_F1, FL_F+1 }, { AKEYCODE_F2, FL_F+2 }, { AKEYCODE_F3, FL_F+3 }, { AKEYCODE_F4, FL_F+4 },
{ AKEYCODE_F5, FL_F+5 }, { AKEYCODE_F6, FL_F+6 }, { AKEYCODE_F7, FL_F+7 }, { AKEYCODE_F8, FL_F+8 },
{ AKEYCODE_F9, FL_F+9 }, { AKEYCODE_F10, FL_F+10 }, { AKEYCODE_F11, FL_F+11 }, { AKEYCODE_F12, FL_F+12 },
//{ AKEYCODE_F13, FL_F+13 }, { AKEYCODE_F14, FL_F+14 }, { AKEYCODE_F15, FL_F+15 }, { AKEYCODE_F16, FL_F+16 },
//{ AKEYCODE_F17, FL_F+17 }, { AKEYCODE_F18, FL_F+18 }, { AKEYCODE_F19, FL_F+19 }, { AKEYCODE_F20, FL_F+20 },
{ AKEYCODE_SHIFT_LEFT, FL_Shift_L }, { AKEYCODE_SHIFT_RIGHT, FL_Shift_R }, { AKEYCODE_CTRL_LEFT, FL_Control_L }, { AKEYCODE_CTRL_RIGHT, FL_Control_R },
{ AKEYCODE_CAPS_LOCK, FL_Caps_Lock }, { AKEYCODE_META_LEFT, FL_Meta_L }, { AKEYCODE_META_RIGHT, FL_Meta_R },
{ AKEYCODE_ALT_LEFT, FL_Alt_L }, { AKEYCODE_ALT_RIGHT, FL_Alt_R }, { AKEYCODE_FORWARD_DEL, FL_Delete }
};
#if 0
// public static final int KEYCODE_ALL_APPS = 284;
// private static final int LAST_KEYCODE = KEYCODE_ALL_APPS;
// Computes the macKeyLookUp table that transforms a Mac OS virtual keycode into an FLTK keysym
unsigned short *fl_compute_macKeyLookUp()
{
static unsigned short macKeyLookUp[128];
memset(macKeyLookUp, 0, sizeof(macKeyLookUp));
for (unsigned i = 0; i < sizeof(vktab)/sizeof(*vktab); i++) {
macKeyLookUp[vktab[i].vk] = vktab[i].fltk;
}
return macKeyLookUp;
}
static int fltk2mac(int fltk) {
int a = 0;
int b = sizeof(vktab)/sizeof(*vktab);
while (a < b) {
int c = (a+b)/2;
if (vktab[c].fltk == fltk) return vktab[c].vk;
if (vktab[c].fltk < fltk) a = c+1; else b = c;
}
return vktab[a].vk;
}
//: returns true, if that key was pressed during the last event
int Fl_Darwin_System_Driver::event_key(int k) {
return get_key(k);
}
//: returns true, if that key is pressed right now
int Fl_Darwin_System_Driver::get_key(int k) {
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4
if (&CGEventSourceKeyState != NULL) {
return (int)CGEventSourceKeyState(kCGEventSourceStateCombinedSessionState, fltk2mac(k) );
}
else
#endif
{
typedef UInt32 fl_KeyMap[4];
fl_KeyMap foo;
// use the GetKeys Carbon function
typedef void (*keymap_f)(fl_KeyMap);
static keymap_f f = NULL;
if (!f) f = ( keymap_f )Fl_Darwin_System_Driver::get_carbon_function("GetKeys");
(*f)(foo);
#ifdef MAC_TEST_FOR_KEYCODES
static int cnt = 0;
if (cnt++>1024) {
cnt = 0;
printf("%08x %08x %08x %08x\n", (ulong*)(foo)[3], (ulong*)(foo)[2], (ulong*)(foo)[1], (ulong*)(foo)[0]);
}
#endif
unsigned char *b = (unsigned char*)foo;
// KP_Enter can be at different locations for Powerbooks vs. desktop Macs
if (k==FL_KP_Enter) {
return (((b[0x34>>3]>>(0x34&7))&1)||((b[0x4c>>3]>>(0x4c&7))&1));
}
int i = fltk2mac(k);
return (b[i>>3]>>(i&7))&1;
}
}
#endif
int Fl_Android_Screen_Driver::compose(int &del)
{
int condition;
unsigned char ascii = (unsigned char)Fl::e_text[0];
condition = (Fl::e_state & (FL_ALT | FL_META | FL_CTRL)) && !(ascii & 128) ;
if (condition) { del = 0; return 0;} // this stuff is to be treated as a function key
del = Fl::compose_state;
Fl::compose_state = 0;
// Only insert non-control characters:
if ( (!Fl::compose_state) && ! (ascii & ~31 && ascii!=127)) { return 0; }
return 1;
}
static unsigned short *key_lookup = nullptr;
// Computes the macKeyLookUp table that transforms a Mac OS virtual keycode into an FLTK keysym
static unsigned short *compute_key_lookup()
{
static unsigned short AndroidKeyLookUp[AKEYCODE_ALL_APPS+1];
memset(AndroidKeyLookUp, 0, sizeof(AndroidKeyLookUp));
for (unsigned i = 0; i < sizeof(vktab)/sizeof(*vktab); i++) {
AndroidKeyLookUp[vktab[i].vk] = vktab[i].fltk;
}
return AndroidKeyLookUp;
}
static int android_to_fltk_modifiers(int a)
{
int fl_mod = 0;
if (a == AMETA_NONE) return 0;
if (a & AMETA_ALT_ON) fl_mod |= FL_ALT;
if (a & AMETA_SHIFT_ON) fl_mod |= FL_SHIFT;
if (a & AMETA_CTRL_ON) fl_mod |= FL_CTRL;
if (a & AMETA_META_ON) fl_mod |= FL_META;
if (a & AMETA_NUM_LOCK_ON) fl_mod |= FL_NUM_LOCK;
if (a & AMETA_CAPS_LOCK_ON) fl_mod |= FL_CAPS_LOCK;
if (a & AMETA_SCROLL_LOCK_ON) fl_mod |= FL_SCROLL_LOCK;
// AMETA_SYM_ON
// AMETA_FUNCTION_ON
// FIXME: we need to add the status of the mouse button(s)
// FL_BUTTON1
// FL_BUTTON2
// FL_BUTTON3
return fl_mod;
}
int Fl_Android_Screen_Driver::handle_keyboard_event(AInputQueue *queue, AInputEvent *event)
{
/*
int32_t AKeyEvent_getAction (const AInputEvent *key_event)
{ AKEY_EVENT_ACTION_DOWN = 0, AKEY_EVENT_ACTION_UP = 1, AKEY_EVENT_ACTION_MULTIPLE = 2 }
> Reading up on ACTION_MULTIPLE also explains how to deal with
> special or sequences of characters:
> "If the key code is not KEYCODE_UNKNOWN then the getRepeatCount()
> method returns the number of times the given key code should be
> executed. Otherwise, if the key code is KEYCODE_UNKNOWN, then this
> is a sequence of characters as returned by getCharacters()."
int32_t AKeyEvent_getFlags (const AInputEvent *key_event)
{
AKEY_EVENT_FLAG_WOKE_HERE = 0x1, AKEY_EVENT_FLAG_SOFT_KEYBOARD = 0x2, AKEY_EVENT_FLAG_KEEP_TOUCH_MODE = 0x4, AKEY_EVENT_FLAG_FROM_SYSTEM = 0x8,
AKEY_EVENT_FLAG_EDITOR_ACTION = 0x10, AKEY_EVENT_FLAG_CANCELED = 0x20, AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY = 0x40, AKEY_EVENT_FLAG_LONG_PRESS = 0x80,
AKEY_EVENT_FLAG_CANCELED_LONG_PRESS = 0x100, AKEY_EVENT_FLAG_TRACKING = 0x200, AKEY_EVENT_FLAG_FALLBACK = 0x400
}
int32_t AKeyEvent_getKeyCode (const AInputEvent *key_event)
{
AKEYCODE_UNKNOWN = 0, AKEYCODE_SOFT_LEFT = 1, AKEYCODE_SOFT_RIGHT = 2, AKEYCODE_HOME = 3,
AKEYCODE_BACK = 4, AKEYCODE_CALL = 5, AKEYCODE_ENDCALL = 6, AKEYCODE_0 = 7,
AKEYCODE_1 = 8, AKEYCODE_2 = 9, AKEYCODE_3 = 10, AKEYCODE_4 = 11,
AKEYCODE_5 = 12, AKEYCODE_6 = 13, AKEYCODE_7 = 14, AKEYCODE_8 = 15,
AKEYCODE_9 = 16, AKEYCODE_STAR = 17, AKEYCODE_POUND = 18, AKEYCODE_DPAD_UP = 19,
AKEYCODE_DPAD_DOWN = 20, AKEYCODE_DPAD_LEFT = 21, AKEYCODE_DPAD_RIGHT = 22, AKEYCODE_DPAD_CENTER = 23,
AKEYCODE_VOLUME_UP = 24, AKEYCODE_VOLUME_DOWN = 25, AKEYCODE_POWER = 26, AKEYCODE_CAMERA = 27,
AKEYCODE_CLEAR = 28, AKEYCODE_A = 29, AKEYCODE_B = 30, AKEYCODE_C = 31,
AKEYCODE_D = 32, AKEYCODE_E = 33, AKEYCODE_F = 34, AKEYCODE_G = 35, ...
int32_t AKeyEvent_getScanCode (const AInputEvent *key_event)
{ AKEY_STATE_UNKNOWN = -1, AKEY_STATE_UP = 0, AKEY_STATE_DOWN = 1, AKEY_STATE_VIRTUAL = 2 }
int32_t AKeyEvent_getMetaState (const AInputEvent *key_event)
{
AMETA_NONE = 0, AMETA_ALT_ON = 0x02, AMETA_ALT_LEFT_ON = 0x10, AMETA_ALT_RIGHT_ON = 0x20,
AMETA_SHIFT_ON = 0x01, AMETA_SHIFT_LEFT_ON = 0x40, AMETA_SHIFT_RIGHT_ON = 0x80, AMETA_SYM_ON = 0x04,
AMETA_FUNCTION_ON = 0x08, AMETA_CTRL_ON = 0x1000, AMETA_CTRL_LEFT_ON = 0x2000, AMETA_CTRL_RIGHT_ON = 0x4000,
AMETA_META_ON = 0x10000, AMETA_META_LEFT_ON = 0x20000, AMETA_META_RIGHT_ON = 0x40000, AMETA_CAPS_LOCK_ON = 0x100000,
AMETA_NUM_LOCK_ON = 0x200000, AMETA_SCROLL_LOCK_ON = 0x400000
}
int32_t AKeyEvent_getRepeatCount (const AInputEvent *key_event)
int64_t AKeyEvent_getDownTime (const AInputEvent *key_event)
int64_t AKeyEvent_getEventTime (const AInputEvent *key_event)
*/
Fl_Android_Application::log_i("Key event: action=%d keyCode=%d metaState=0x%x scanCode=%d",
AKeyEvent_getAction(event),
AKeyEvent_getKeyCode(event),
AKeyEvent_getMetaState(event),
AKeyEvent_getScanCode(event));
auto keyAction = AKeyEvent_getAction(event);
if (keyAction==AKEY_EVENT_ACTION_MULTIPLE) {
if (AKeyEvent_getKeyCode(event)==AKEYCODE_UNKNOWN) {
// characters are in getCharacters()
// String class KeyEvent::getCharacters() [Java]
// is there a way to get the true Java event somehow?
// override dispatchKeyEvent(android.view.KeyEvent event)
// getDeadChar()
//
// This seems to work for hardware keys only:
// public static interface View.OnKeyListener
// boolean onKey (View v,
// int keyCode,
// KeyEvent event)
// public static interface KeyEvent.Callback
// onKeyDown(int keyCode, KeyEvent event)
// public static interface Window.Callback
// abstract boolean dispatchKeyEvent(KeyEvent event)
// view.setOnKeyListener(new OnKeyListener()
//
// NativeApplication.nativeApplication.addEventListener(KeyboardEvent.KEY_DOWN,checkKeypress);
// public function CheckKeypress(event:KeyboardEvent):void
//
// https://android.googlesource.com/platform/frameworks/base/+/master/core/java/android/view/KeyEvent.java
} else {
// send keycode as many times as getRepeatCount() / AKeyEvent_getRepeatCount(event)
}
}
int unicodeKey = 0;
auto aKeyCode = AKeyEvent_getKeyCode(event);
auto aMetaState = AKeyEvent_getMetaState(event);
Fl_Android_Java java;
if (java.is_attached()) {
jclass class_key_event = java.env()->FindClass("android/view/KeyEvent");
jmethodID eventConstructor = java.env()->GetMethodID(
class_key_event, "<init>",
"(JJIIIIIIII)V");
jobject eventObj = java.env()->NewObject(
class_key_event, eventConstructor,
AKeyEvent_getDownTime(event),
AKeyEvent_getEventTime(event),
AKeyEvent_getAction(event),
aKeyCode,
AKeyEvent_getRepeatCount(event),
aMetaState,
AInputEvent_getDeviceId(event),
AKeyEvent_getScanCode(event), // hardware keyboard only
AKeyEvent_getFlags(event),
AInputEvent_getSource(event));
jmethodID method_get_unicode_char = java.env()->GetMethodID(
class_key_event,
"getUnicodeChar",
"(I)I");
unicodeKey = java.env()->CallIntMethod(
eventObj, method_get_unicode_char,
AKeyEvent_getMetaState(event));
java.env()->DeleteLocalRef(class_key_event);
java.env()->DeleteLocalRef(eventObj);
}
// FIXME: do the following thing only on key-down or key-repeat
static char buf[8];
int len = fl_utf8encode(unicodeKey, buf);
if (len >= 0 && len < 8)
buf[len] = 0;
else
buf[0] = 0;
Fl_Android_Application::log_i("Unicode: %d Text: %s", unicodeKey, buf);
if (!key_lookup) key_lookup = compute_key_lookup();
Fl::e_keysym = (aKeyCode>AKEYCODE_ALL_APPS) ? 0 : key_lookup[aKeyCode];
Fl::e_state = android_to_fltk_modifiers(aMetaState);
AInputQueue_finishEvent(queue, event, 0);
Fl_Widget *w = Fl::focus();
if (w) {
Fl_Window *win = w->window();
if (keyAction==AKEY_EVENT_ACTION_DOWN) {
if (unicodeKey>0) {
Fl::e_text = buf;
Fl::e_length = len;
} else {
Fl::e_text = (char*)"";
Fl::e_length = 0;
}
Fl::handle(FL_KEYBOARD, win);
}
}
return 0;
}
// TODO: different inputs may be able to request different keyboards
// TODO: knowing the position of the widget, we may be able to avoid
// obstructing it with the on-screen keyboard
void Fl_Android_Screen_Driver::request_keyboard( /*o->rect(), o->type()*/ )
{
if (pKeyboardCount==0) {
/*
* The following line does not work as of March 2018. The pseudo-Java
* code that follows is needed to make the virtaul keyboard show.
*
ANativeActivity_showSoftInput(Fl_Android_Application::get_activity(),
ANATIVEACTIVITY_SHOW_SOFT_INPUT_IMPLICIT);
*
* This is the actual Java code that we recreate in C++
*
InputMethodManager imm = ( InputMethodManager )getSystemService( Context.INPUT_METHOD_SERVICE );
imm.showSoftInput( this.getWindow().getDecorView(), InputMethodManager.SHOW_FORCED );
*/
Fl_Android_Java java;
if (java.is_attached()) {
jint lFlags = 0;
// Retrieves Context.INPUT_METHOD_SERVICE.
jclass ClassContext = java.env()->FindClass("android/content/Context");
jfieldID FieldINPUT_METHOD_SERVICE = java.env()->GetStaticFieldID(
ClassContext,
"INPUT_METHOD_SERVICE",
"Ljava/lang/String;");
jobject INPUT_METHOD_SERVICE = java.env()->GetStaticObjectField(
ClassContext,
FieldINPUT_METHOD_SERVICE);
// Runs getSystemService(Context.INPUT_METHOD_SERVICE).
jclass ClassInputMethodManager = java.env()->FindClass(
"android/view/inputmethod/InputMethodManager");
jmethodID MethodGetSystemService = java.env()->GetMethodID(
java.native_activity_class(), "getSystemService",
"(Ljava/lang/String;)Ljava/lang/Object;");
jobject lInputMethodManager = java.env()->CallObjectMethod(
java.native_ativity(), MethodGetSystemService,
INPUT_METHOD_SERVICE);
// Runs getWindow().getDecorView().
jmethodID MethodGetWindow = java.env()->GetMethodID(
java.native_activity_class(), "getWindow",
"()Landroid/view/Window;");
jobject lWindow = java.env()->CallObjectMethod(
java.native_ativity(),
MethodGetWindow);
jclass ClassWindow = java.env()->FindClass(
"android/view/Window");
jmethodID MethodGetDecorView = java.env()->GetMethodID(
ClassWindow, "getDecorView", "()Landroid/view/View;");
jobject lDecorView = java.env()->CallObjectMethod(
lWindow,
MethodGetDecorView);
// Runs lInputMethodManager.showSoftInput(...).
jmethodID MethodShowSoftInput = java.env()->GetMethodID(
ClassInputMethodManager, "showSoftInput",
"(Landroid/view/View;I)Z");
jboolean lResult = java.env()->CallBooleanMethod(
lInputMethodManager, MethodShowSoftInput,
lDecorView, lFlags);
java.env()->DeleteLocalRef(ClassContext);
java.env()->DeleteLocalRef(ClassInputMethodManager);
java.env()->DeleteLocalRef(ClassWindow);
java.env()->DeleteLocalRef(INPUT_METHOD_SERVICE);
java.env()->DeleteLocalRef(lInputMethodManager);
java.env()->DeleteLocalRef(lWindow);
java.env()->DeleteLocalRef(lDecorView);
}
}
pKeyboardCount++;
}
void Fl_Android_Screen_Driver::release_keyboard()
{
pKeyboardCount--;
if (pKeyboardCount==0) {
ANativeActivity_hideSoftInput(Fl_Android_Application::get_activity(),
ANATIVEACTIVITY_HIDE_SOFT_INPUT_NOT_ALWAYS);
}
}

132
src/drivers/Android/Fl_Android_System_Driver.H
View File

@@ -1,132 +0,0 @@
//
// Definition of Android system driver for the Fast Light Tool Kit (FLTK).
//
// Copyright 2010-2020 by Bill Spitzak and others.
//
// This library is free software. Distribution and use rights are outlined in
// the file "COPYING" which should have been included with this file. If this
// file is missing or damaged, see the license at:
//
// https://www.fltk.org/COPYING.php
//
// Please see the following page on how to report bugs and issues:
//
// https://www.fltk.org/bugs.php
//
/**
\file Fl_Android_System_Driver.H
\brief Definition of Android system driver.
*/
#ifndef FL_ANDROID_SYSTEM_DRIVER_H
#define FL_ANDROID_SYSTEM_DRIVER_H
#include <string.h>
#include <FL/fl_string_functions.h>
#include "../../Fl_System_Driver.H"
#include <stdarg.h>
/*
Move everything here that manages the system interface.
There is exactly one system driver.
- filename and pathname management
- directory and file access
- system time and system timer
- multithreading
*/
class Fl_Android_System_Driver : public Fl_System_Driver
{
#if 0
public:
static unsigned win_pixmap_bg_color; // the RGB() of the pixmap background color
virtual void warning(const char *format, va_list args);
virtual void error(const char *format, va_list args);
virtual void fatal(const char *format, va_list args);
virtual char *utf2mbcs(const char *s);
virtual char *getenv(const char *var);
virtual int putenv(const char *var) { return ::putenv(fl_strdup(var)); }
virtual int open(const char *fnam, int oflags, int pmode);
virtual int open_ext(const char *fnam, int binary, int oflags, int pmode);
virtual FILE *fopen(const char *fnam, const char *mode);
virtual int system(const char *cmd);
virtual int execvp(const char *file, char *const *argv);
virtual int chmod(const char *fnam, int mode);
virtual int access(const char *fnam, int mode);
virtual int stat(const char *fnam, struct stat *b);
virtual char *getcwd(char *b, int l);
virtual int chdir(const char *path);
virtual int unlink(const char *fnam);
virtual int mkdir(const char *fnam, int mode);
virtual int rmdir(const char *fnam);
virtual int rename(const char *fnam, const char *newnam);
virtual unsigned utf8towc(const char *src, unsigned srclen, wchar_t* dst, unsigned dstlen);
virtual unsigned utf8fromwc(char *dst, unsigned dstlen, const wchar_t* src, unsigned srclen);
virtual int utf8locale();
virtual unsigned utf8to_mb(const char *src, unsigned srclen, char *dst, unsigned dstlen);
virtual unsigned utf8from_mb(char *dst, unsigned dstlen, const char *src, unsigned srclen);
virtual int clocale_printf(FILE *output, const char *format, va_list args);
virtual int clocale_snprintf(char *output, size_t output_size, const char *format, va_list args);
virtual int clocale_sscanf(const char *input, const char *format, va_list args);
// these 2 are in Fl_get_key_win32.cxx
virtual int event_key(int k);
virtual int get_key(int k);
virtual int filename_list(const char *d, dirent ***list,
int (*sort)(struct dirent **, struct dirent **),
char *errmsg, int errmsg_sz);
virtual int filename_expand(char *to,int tolen, const char *from);
virtual int filename_relative(char *to, int tolen, const char *from, const char *base);
virtual int filename_absolute(char *to, int tolen, const char *from);
virtual int filename_isdir(const char *n);
virtual int filename_isdir_quick(const char *n);
virtual const char *filename_ext(const char *buf);
virtual int open_uri(const char *uri, char *msg, int msglen);
virtual int use_recent_tooltip_fix() {return 1;}
virtual int file_browser_load_filesystem(Fl_File_Browser *browser, char *filename, int lname, Fl_File_Icon *icon);
virtual int file_browser_load_directory(const char *directory, char *filename, size_t name_size,
dirent ***pfiles, Fl_File_Sort_F *sort,
char *errmsg=NULL, int errmsg_sz=0);
virtual void newUUID(char *uuidBuffer);
virtual char *preference_rootnode(Fl_Preferences *prefs, Fl_Preferences::Root root, const char *vendor,
const char *application);
virtual void *dlopen(const char *filename);
virtual void png_extra_rgba_processing(unsigned char *array, int w, int h);
virtual const char *next_dir_sep(const char *start);
// these 3 are implemented in Fl_lock.cxx
virtual void awake(void*);
virtual int lock();
virtual void unlock();
// this one is implemented in Fl_win32.cxx
virtual void* thread_message();
virtual int file_type(const char *filename);
virtual int pixmap_extra_transparent_processing() {return 1;}
// this one is implemented in fl_draw_pixmap.cxx
virtual void make_unused_color(unsigned char &r, unsigned char &g, unsigned char &b);
virtual const char *home_directory_name();
virtual const char *filesystems_label() { return "My Computer"; }
virtual int backslash_as_slash() {return 1;}
virtual int colon_is_drive() {return 1;}
virtual int case_insensitive_filenames() {return 1;}
// this one is implemented in Fl_win32.cxx
virtual const char *filename_name(const char *buf);
// this one is implemented in Fl_win32.cxx
virtual void copy(const char *stuff, int len, int clipboard, const char *type);
// this one is implemented in Fl_win32.cxx
virtual void paste(Fl_Widget &receiver, int clipboard, const char *type);
// this one is implemented in Fl_win32.cxx
virtual int clipboard_contains(const char *type);
// this one is implemented in Fl_win32.cxx
virtual void clipboard_notify_change();
virtual void add_fd(int fd, int when, Fl_FD_Handler cb, void* = 0);
virtual void add_fd(int fd, Fl_FD_Handler cb, void* = 0);
virtual void remove_fd(int, int when);
virtual void remove_fd(int);
virtual void gettime(time_t *sec, int *usec);
#endif
virtual char *strdup(const char *s) {return ::strdup(s);}
};
#endif // FL_ANDROID_SYSTEM_DRIVER_H

957
src/drivers/Android/Fl_Android_System_Driver.cxx
View File

File diff suppressed because it is too large Load Diff

143
src/drivers/Android/Fl_Android_Window_Driver.H
View File

@@ -1,143 +0,0 @@
//
// Definition of Android window driver
// for the Fast Light Tool Kit (FLTK).
//
// Copyright 2018 by Bill Spitzak and others.
//
// This library is free software. Distribution and use rights are outlined in
// the file "COPYING" which should have been included with this file. If this
// file is missing or damaged, see the license at:
//
// https://www.fltk.org/COPYING.php
//
// Please see the following page on how to report bugs and issues:
//
// https://www.fltk.org/bugs.php
//
/**
\file Fl_Android_Window_Driver.H
\brief Definition of Android window driver.
*/
#ifndef FL_ANDROID_WINDOW_DRIVER_H
#define FL_ANDROID_WINDOW_DRIVER_H
#include "../../Fl_Window_Driver.H"
//#include <windows.h>
/*
Move everything here that manages the native window interface.
There is one window driver for each Fl_Window. Window drivers manage window
actions such as resizing, events, decoration, fullscreen modes, etc. . All
drawing and rendering is managed by the Surface device and the associated
graphics driver.
- window specific event handling
- window types and styles, depth, etc.
- decorations
? where do we handle the interface between OpenGL/DirectX and Cocoa/Windows/Glx?
*/
struct Fl_Window_Driver::shape_data_type {
int lw_; ///< width of shape image
int lh_; ///< height of shape image
Fl_Image* shape_; ///< shape image
Fl_Bitmap *effective_bitmap_; ///< auxiliary bitmap image
};
class FL_EXPORT Fl_Android_Window_Driver : public Fl_Window_Driver
{
#if 0
friend class Fl_Window;
struct icon_data {
const void *legacy_icon;
Fl_RGB_Image **icons;
int count;
HICON big_icon;
HICON small_icon;
};
int screen_num_;
private:
void shape_bitmap_(Fl_Image* b);
void shape_alpha_(Fl_Image* img, int offset);
#endif
public:
static inline Fl_Android_Window_Driver* driver(const Fl_Window *w) {
return (Fl_Android_Window_Driver*)Fl_Window_Driver::driver(w);
}
Fl_Android_Window_Driver(Fl_Window *w) : Fl_Window_Driver(w) {}
virtual ~Fl_Android_Window_Driver() override {}
virtual void make_current() override;
virtual void show() override;
virtual void hide() override;
#if 0
HDC private_dc; // used for OpenGL
RECT border_width_title_bar_height(int &bx, int &by, int &bt);
virtual void screen_num(int n);
virtual int screen_num();
struct icon_data *icon_;
HCURSOR cursor;
int custom_cursor;
struct type_for_resize_window_between_screens {
int screen;
bool busy;
};
static type_for_resize_window_between_screens data_for_resize_window_between_screens_;
void set_minmax(LPMINMAXINFO minmax);
int fake_X_wm(int &X, int &Y, int &bt,int &bx,int &by);
void make_fullscreen(int X, int Y, int W, int H);
// --- window data
virtual int decorated_w();
virtual int decorated_h();
// --- window management
virtual Fl_X *makeWindow();
virtual void flush_double();
virtual void flush_overlay();
virtual void draw_begin();
virtual void label(const char *name,const char *iname);
#endif
virtual void resize(int X,int Y,int W,int H) override;
#if 0
virtual void map();
virtual void unmap();
virtual void fullscreen_on();
virtual void fullscreen_off(int X, int Y, int W, int H);
virtual void iconize();
virtual void decoration_sizes(int *top, int *left, int *right, int *bottom);
// --- window cursor stuff
virtual int set_cursor(Fl_Cursor);
virtual int set_cursor(const Fl_RGB_Image*, int, int);
virtual void shape(const Fl_Image* img);
virtual void icons(const Fl_RGB_Image *icons[], int count);
virtual const void *icon() const;
virtual void icon(const void * ic);
virtual void free_icons();
void set_icons(); // driver-internal support function
// this one is implemented in Fl_win32.cxx
virtual void capture_titlebar_and_borders(Fl_Shared_Image*& top, Fl_Shared_Image*& left, Fl_Shared_Image*& bottom, Fl_Shared_Image*& right);
#endif
virtual int scroll(int src_x, int src_y, int src_w, int src_h, int dest_x, int dest_y,
void (*draw_area)(void*, int,int,int,int), void* data) override;
#if 0
static void resize_after_screen_change(void *data);
#endif
virtual void wait_for_expose() override { wait_for_expose_value = 1; }
static void expose_all();
};
#endif // FL_ANDROID_WINDOW_DRIVER_H

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