Showing preview only (3,768K chars total). Download the full file or copy to clipboard to get everything.
Repository: dyang886/Game-Cheats-Manager
Branch: main
Commit: f6c50d09f513
Files: 358
Total size: 3.5 MB
Directory structure:
gitextract_g3w1hlj3/
├── .github/
│ └── workflows/
│ └── Release to server.yml
├── .gitignore
├── Game Trainers/
│ ├── .gitignore
│ ├── CMakeLists.txt
│ ├── common/
│ │ ├── CMakeLists.txt
│ │ ├── assets/
│ │ │ ├── elevate.xml
│ │ │ └── logo.psd
│ │ ├── include/
│ │ │ ├── CDPBase.h
│ │ │ ├── FL/
│ │ │ │ ├── Enumerations.H
│ │ │ │ ├── Fl.H
│ │ │ │ ├── Fl_Adjuster.H
│ │ │ │ ├── Fl_Anim_GIF_Image.H
│ │ │ │ ├── Fl_BMP_Image.H
│ │ │ │ ├── Fl_Bitmap.H
│ │ │ │ ├── Fl_Box.H
│ │ │ │ ├── Fl_Browser.H
│ │ │ │ ├── Fl_Browser_.H
│ │ │ │ ├── Fl_Button.H
│ │ │ │ ├── Fl_Cairo.H
│ │ │ │ ├── Fl_Cairo_Window.H
│ │ │ │ ├── Fl_Chart.H
│ │ │ │ ├── Fl_Check_Browser.H
│ │ │ │ ├── Fl_Check_Button.H
│ │ │ │ ├── Fl_Choice.H
│ │ │ │ ├── Fl_Clock.H
│ │ │ │ ├── Fl_Color_Chooser.H
│ │ │ │ ├── Fl_Copy_Surface.H
│ │ │ │ ├── Fl_Counter.H
│ │ │ │ ├── Fl_Device.H
│ │ │ │ ├── Fl_Dial.H
│ │ │ │ ├── Fl_Double_Window.H
│ │ │ │ ├── Fl_Export.H
│ │ │ │ ├── Fl_File_Browser.H
│ │ │ │ ├── Fl_File_Chooser.H
│ │ │ │ ├── Fl_File_Icon.H
│ │ │ │ ├── Fl_File_Input.H
│ │ │ │ ├── Fl_Fill_Dial.H
│ │ │ │ ├── Fl_Fill_Slider.H
│ │ │ │ ├── Fl_Flex.H
│ │ │ │ ├── Fl_Float_Input.H
│ │ │ │ ├── Fl_FormsBitmap.H
│ │ │ │ ├── Fl_FormsPixmap.H
│ │ │ │ ├── Fl_Free.H
│ │ │ │ ├── Fl_GIF_Image.H
│ │ │ │ ├── Fl_Gl_Window.H
│ │ │ │ ├── Fl_Graphics_Driver.H
│ │ │ │ ├── Fl_Grid.H
│ │ │ │ ├── Fl_Group.H
│ │ │ │ ├── Fl_Help_Dialog.H
│ │ │ │ ├── Fl_Help_View.H
│ │ │ │ ├── Fl_Hold_Browser.H
│ │ │ │ ├── Fl_Hor_Fill_Slider.H
│ │ │ │ ├── Fl_Hor_Nice_Slider.H
│ │ │ │ ├── Fl_Hor_Slider.H
│ │ │ │ ├── Fl_Hor_Value_Slider.H
│ │ │ │ ├── Fl_ICO_Image.H
│ │ │ │ ├── Fl_Image.H
│ │ │ │ ├── Fl_Image_Surface.H
│ │ │ │ ├── Fl_Input.H
│ │ │ │ ├── Fl_Input_.H
│ │ │ │ ├── Fl_Input_Choice.H
│ │ │ │ ├── Fl_Int_Input.H
│ │ │ │ ├── Fl_JPEG_Image.H
│ │ │ │ ├── Fl_Light_Button.H
│ │ │ │ ├── Fl_Line_Dial.H
│ │ │ │ ├── Fl_Menu.H
│ │ │ │ ├── Fl_Menu_.H
│ │ │ │ ├── Fl_Menu_Bar.H
│ │ │ │ ├── Fl_Menu_Button.H
│ │ │ │ ├── Fl_Menu_Item.H
│ │ │ │ ├── Fl_Menu_Window.H
│ │ │ │ ├── Fl_Multi_Browser.H
│ │ │ │ ├── Fl_Multi_Label.H
│ │ │ │ ├── Fl_Multiline_Input.H
│ │ │ │ ├── Fl_Multiline_Output.H
│ │ │ │ ├── Fl_Native_File_Chooser.H
│ │ │ │ ├── Fl_Nice_Slider.H
│ │ │ │ ├── Fl_Object.H
│ │ │ │ ├── Fl_Output.H
│ │ │ │ ├── Fl_Overlay_Window.H
│ │ │ │ ├── Fl_PDF_File_Surface.H
│ │ │ │ ├── Fl_PNG_Image.H
│ │ │ │ ├── Fl_PNM_Image.H
│ │ │ │ ├── Fl_Pack.H
│ │ │ │ ├── Fl_Paged_Device.H
│ │ │ │ ├── Fl_Pixmap.H
│ │ │ │ ├── Fl_Plugin.H
│ │ │ │ ├── Fl_Positioner.H
│ │ │ │ ├── Fl_PostScript.H
│ │ │ │ ├── Fl_Preferences.H
│ │ │ │ ├── Fl_Printer.H
│ │ │ │ ├── Fl_Progress.H
│ │ │ │ ├── Fl_RGB_Image.H
│ │ │ │ ├── Fl_Radio_Button.H
│ │ │ │ ├── Fl_Radio_Light_Button.H
│ │ │ │ ├── Fl_Radio_Round_Button.H
│ │ │ │ ├── Fl_Rect.H
│ │ │ │ ├── Fl_Repeat_Button.H
│ │ │ │ ├── Fl_Return_Button.H
│ │ │ │ ├── Fl_Roller.H
│ │ │ │ ├── Fl_Round_Button.H
│ │ │ │ ├── Fl_Round_Clock.H
│ │ │ │ ├── Fl_SVG_File_Surface.H
│ │ │ │ ├── Fl_SVG_Image.H
│ │ │ │ ├── Fl_Scheme.H
│ │ │ │ ├── Fl_Scheme_Choice.H
│ │ │ │ ├── Fl_Scroll.H
│ │ │ │ ├── Fl_Scrollbar.H
│ │ │ │ ├── Fl_Secret_Input.H
│ │ │ │ ├── Fl_Select_Browser.H
│ │ │ │ ├── Fl_Shared_Image.H
│ │ │ │ ├── Fl_Shortcut_Button.H
│ │ │ │ ├── Fl_Simple_Counter.H
│ │ │ │ ├── Fl_Single_Window.H
│ │ │ │ ├── Fl_Slider.H
│ │ │ │ ├── Fl_Spinner.H
│ │ │ │ ├── Fl_Sys_Menu_Bar.H
│ │ │ │ ├── Fl_Table.H
│ │ │ │ ├── Fl_Table_Row.H
│ │ │ │ ├── Fl_Tabs.H
│ │ │ │ ├── Fl_Terminal.H
│ │ │ │ ├── Fl_Text_Buffer.H
│ │ │ │ ├── Fl_Text_Display.H
│ │ │ │ ├── Fl_Text_Editor.H
│ │ │ │ ├── Fl_Tile.H
│ │ │ │ ├── Fl_Tiled_Image.H
│ │ │ │ ├── Fl_Timer.H
│ │ │ │ ├── Fl_Toggle_Button.H
│ │ │ │ ├── Fl_Toggle_Light_Button.H
│ │ │ │ ├── Fl_Toggle_Round_Button.H
│ │ │ │ ├── Fl_Tooltip.H
│ │ │ │ ├── Fl_Tree.H
│ │ │ │ ├── Fl_Tree_Item.H
│ │ │ │ ├── Fl_Tree_Item_Array.H
│ │ │ │ ├── Fl_Tree_Prefs.H
│ │ │ │ ├── Fl_Valuator.H
│ │ │ │ ├── Fl_Value_Input.H
│ │ │ │ ├── Fl_Value_Output.H
│ │ │ │ ├── Fl_Value_Slider.H
│ │ │ │ ├── Fl_Widget.H
│ │ │ │ ├── Fl_Widget_Surface.H
│ │ │ │ ├── Fl_Window.H
│ │ │ │ ├── Fl_Wizard.H
│ │ │ │ ├── Fl_XBM_Image.H
│ │ │ │ ├── Fl_XPM_Image.H
│ │ │ │ ├── Makefile.in
│ │ │ │ ├── README.Xcode
│ │ │ │ ├── filename.H
│ │ │ │ ├── fl_ask.H
│ │ │ │ ├── fl_attr.h
│ │ │ │ ├── fl_callback_macros.H
│ │ │ │ ├── fl_casts.H
│ │ │ │ ├── fl_config.h
│ │ │ │ ├── fl_draw.H
│ │ │ │ ├── fl_message.H
│ │ │ │ ├── fl_show_colormap.H
│ │ │ │ ├── fl_show_input.H
│ │ │ │ ├── fl_string_functions.h
│ │ │ │ ├── fl_types.h
│ │ │ │ ├── fl_utf8.h
│ │ │ │ ├── forms.H
│ │ │ │ ├── gl.h
│ │ │ │ ├── gl2opengl.h
│ │ │ │ ├── gl_draw.H
│ │ │ │ ├── glu.h
│ │ │ │ ├── glut.H
│ │ │ │ ├── mac.H
│ │ │ │ ├── math.h
│ │ │ │ ├── names.h
│ │ │ │ ├── platform.H
│ │ │ │ ├── platform_types.h
│ │ │ │ ├── wayland.H
│ │ │ │ ├── win32.H
│ │ │ │ ├── x.H
│ │ │ │ └── x11.H
│ │ │ ├── FLTKUtils.h
│ │ │ ├── Il2CppBase.h
│ │ │ ├── MinHook.h
│ │ │ ├── MonoBase.h
│ │ │ ├── MonoBridge.cpp
│ │ │ ├── MonoBridge.def
│ │ │ ├── TrainerBase.h
│ │ │ ├── il2cpp/
│ │ │ │ ├── hook.h
│ │ │ │ ├── il2cpp.cpp
│ │ │ │ ├── il2cpp.h
│ │ │ │ ├── il2cpp_api.h
│ │ │ │ ├── il2cpp_types.h
│ │ │ │ ├── memory.h
│ │ │ │ ├── unity.cpp
│ │ │ │ ├── unity.h
│ │ │ │ └── vec.h
│ │ │ └── nlohmann/
│ │ │ ├── adl_serializer.hpp
│ │ │ ├── byte_container_with_subtype.hpp
│ │ │ ├── detail/
│ │ │ │ ├── abi_macros.hpp
│ │ │ │ ├── conversions/
│ │ │ │ │ ├── from_json.hpp
│ │ │ │ │ ├── to_chars.hpp
│ │ │ │ │ └── to_json.hpp
│ │ │ │ ├── exceptions.hpp
│ │ │ │ ├── hash.hpp
│ │ │ │ ├── input/
│ │ │ │ │ ├── binary_reader.hpp
│ │ │ │ │ ├── input_adapters.hpp
│ │ │ │ │ ├── json_sax.hpp
│ │ │ │ │ ├── lexer.hpp
│ │ │ │ │ ├── parser.hpp
│ │ │ │ │ └── position_t.hpp
│ │ │ │ ├── iterators/
│ │ │ │ │ ├── internal_iterator.hpp
│ │ │ │ │ ├── iter_impl.hpp
│ │ │ │ │ ├── iteration_proxy.hpp
│ │ │ │ │ ├── iterator_traits.hpp
│ │ │ │ │ ├── json_reverse_iterator.hpp
│ │ │ │ │ └── primitive_iterator.hpp
│ │ │ │ ├── json_custom_base_class.hpp
│ │ │ │ ├── json_pointer.hpp
│ │ │ │ ├── json_ref.hpp
│ │ │ │ ├── macro_scope.hpp
│ │ │ │ ├── macro_unscope.hpp
│ │ │ │ ├── meta/
│ │ │ │ │ ├── call_std/
│ │ │ │ │ │ ├── begin.hpp
│ │ │ │ │ │ └── end.hpp
│ │ │ │ │ ├── cpp_future.hpp
│ │ │ │ │ ├── detected.hpp
│ │ │ │ │ ├── identity_tag.hpp
│ │ │ │ │ ├── is_sax.hpp
│ │ │ │ │ ├── std_fs.hpp
│ │ │ │ │ ├── type_traits.hpp
│ │ │ │ │ └── void_t.hpp
│ │ │ │ ├── output/
│ │ │ │ │ ├── binary_writer.hpp
│ │ │ │ │ ├── output_adapters.hpp
│ │ │ │ │ └── serializer.hpp
│ │ │ │ ├── string_concat.hpp
│ │ │ │ ├── string_escape.hpp
│ │ │ │ ├── string_utils.hpp
│ │ │ │ └── value_t.hpp
│ │ │ ├── json.hpp
│ │ │ ├── json_fwd.hpp
│ │ │ ├── ordered_map.hpp
│ │ │ └── thirdparty/
│ │ │ └── hedley/
│ │ │ ├── hedley.hpp
│ │ │ └── hedley_undef.hpp
│ │ └── libs/
│ │ ├── x64/
│ │ │ ├── fltk.lib
│ │ │ ├── fltk_forms.lib
│ │ │ ├── fltk_gl.lib
│ │ │ ├── fltk_images.lib
│ │ │ ├── fltk_jpeg.lib
│ │ │ ├── fltk_png.lib
│ │ │ ├── fltk_z.lib
│ │ │ └── libMinHook.x64.lib
│ │ └── x86/
│ │ ├── fltk.lib
│ │ ├── fltk_forms.lib
│ │ ├── fltk_gl.lib
│ │ ├── fltk_images.lib
│ │ ├── fltk_jpeg.lib
│ │ ├── fltk_png.lib
│ │ ├── fltk_z.lib
│ │ └── libMinHook.x86.lib
│ ├── documents/
│ │ └── trainer_template.h
│ ├── scripts/
│ │ ├── font_processor.py
│ │ ├── gcm_trainers.json
│ │ └── requirements.txt
│ └── trainers/
│ ├── Arrow a Row Trainer/
│ │ ├── CMakeLists.txt
│ │ ├── main.cpp
│ │ ├── resources.rc
│ │ ├── trainer.h
│ │ └── translations.json
│ ├── DREDGE Trainer/
│ │ ├── CMakeLists.txt
│ │ ├── GCMInjection.cs
│ │ ├── GCMInjection.csproj
│ │ ├── main.cpp
│ │ ├── resources.rc
│ │ ├── trainer.h
│ │ ├── translation_extra.txt
│ │ └── translations.json
│ ├── Feeding Frenzy 2_Shipwreck Showdown Trainer/
│ │ ├── CMakeLists.txt
│ │ ├── main.cpp
│ │ ├── resources.rc
│ │ ├── trainer.h
│ │ └── translations.json
│ ├── Headbangers_Rhythm Royale Trainer/
│ │ ├── CMakeLists.txt
│ │ ├── main.cpp
│ │ ├── resources.rc
│ │ ├── trainer.h
│ │ └── translations.json
│ ├── Heavy Weapon Trainer/
│ │ ├── CMakeLists.txt
│ │ ├── main.cpp
│ │ ├── resources.rc
│ │ ├── trainer.h
│ │ └── translations.json
│ ├── Inotia 4 Trainer/
│ │ ├── CMakeLists.txt
│ │ ├── main.cpp
│ │ ├── resources.rc
│ │ ├── trainer.h
│ │ └── translations.json
│ ├── Just Shapes & Beats Trainer/
│ │ ├── CMakeLists.txt
│ │ ├── IL2CPP.cpp
│ │ ├── main.cpp
│ │ ├── resources.rc
│ │ ├── trainer.h
│ │ └── translations.json
│ ├── Oil Rush Trainer/
│ │ ├── CMakeLists.txt
│ │ ├── main.cpp
│ │ ├── resources.rc
│ │ ├── trainer.h
│ │ └── translations.json
│ ├── Outland Trainer/
│ │ ├── CMakeLists.txt
│ │ ├── main.cpp
│ │ ├── resources.rc
│ │ ├── trainer.h
│ │ └── translations.json
│ ├── Plants vs. Zombies_GOTY Edition Trainer/
│ │ ├── CMakeLists.txt
│ │ ├── main.cpp
│ │ ├── resources.rc
│ │ ├── trainer.h
│ │ └── translations.json
│ ├── Plants vs. Zombies_Replanted Trainer/
│ │ ├── CMakeLists.txt
│ │ ├── IL2CPP.cpp
│ │ ├── main.cpp
│ │ ├── resources.rc
│ │ ├── trainer.h
│ │ ├── translation_extra.txt
│ │ └── translations.json
│ ├── PvZ2 Gardendless Trainer/
│ │ ├── CMakeLists.txt
│ │ ├── main.cpp
│ │ ├── resources.rc
│ │ ├── trainer.h
│ │ └── translations.json
│ └── Wizard of Legend 2 Trainer/
│ ├── CMakeLists.txt
│ ├── main.cpp
│ ├── resources.rc
│ ├── trainer.h
│ └── translations.json
├── LICENSE.txt
├── README.md
├── README_CN.md
├── README_TW.md
├── requirements.txt
└── src/
├── dependency/
│ ├── CE Translations/
│ │ └── zh_CN/
│ │ ├── Java.po
│ │ ├── SaveSessions.po
│ │ ├── Tutorial-x86_64.po
│ │ ├── VersionCheck.po
│ │ ├── cheatengine-x86_64.po
│ │ ├── lclstrconsts.po
│ │ ├── monoscript.po
│ │ ├── patchscan.po
│ │ └── pseudocodediagram.po
│ └── TrainerBGM.mid
├── locale/
│ ├── de_DE/
│ │ └── LC_MESSAGES/
│ │ └── Game Cheats Manager.po
│ ├── en_US/
│ │ └── LC_MESSAGES/
│ │ └── Game Cheats Manager.po
│ ├── zh_CN/
│ │ └── LC_MESSAGES/
│ │ └── Game Cheats Manager.po
│ └── zh_TW/
│ └── LC_MESSAGES/
│ └── Game Cheats Manager.po
└── scripts/
├── config.py
├── main.py
├── style_sheet.py
├── threads/
│ ├── download_base_thread.py
│ ├── download_display_thread.py
│ ├── download_trainers_thread.py
│ ├── other_threads.py
│ └── update_trainers_thread.py
└── widgets/
├── custom_dialogs.py
├── custom_widgets.py
└── trainer_management.py
================================================
FILE CONTENTS
================================================
================================================
FILE: .github/workflows/Release to server.yml
================================================
name: Release to Server
on:
release:
types: [published]
jobs:
deploy-installer:
runs-on: ubuntu-latest
permissions:
id-token: write
contents: read
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Configure AWS Credentials
uses: aws-actions/configure-aws-credentials@v4
with:
role-to-assume: ${{ secrets.AWS_IAM_ROLE_TO_ASSUME }}
aws-region: ${{ secrets.AWS_REGION }}
- name: Get release version and installer name
id: get_version
run: |
VERSION=$(echo "${{ github.event.release.tag_name }}" | sed 's/^v//')
echo "version=$VERSION" >> $GITHUB_OUTPUT
echo "local_installer_name=Game.Cheats.Manager.Setup.$VERSION.exe" >> $GITHUB_OUTPUT
echo "server_installer_name=Game Cheats Manager Setup $VERSION.exe" >> $GITHUB_OUTPUT
- name: Download release asset
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
gh release download ${{ github.event.release.tag_name }} --pattern "${{ steps.get_version.outputs.local_installer_name }}"
- name: Delete previous stable installers from S3
env:
S3_BUCKET_NAME: ${{ secrets.S3_BUCKET_NAME }}
S3_GCM_PREFIX: "GCM"
run: |
aws s3 rm "s3://${S3_BUCKET_NAME}/${S3_GCM_PREFIX}/" \
--recursive \
--exclude "*" \
--include "Game Cheats Manager Setup*.exe" \
--exclude "*beta*"
echo "Previous stable installers deleted from s3://${S3_BUCKET_NAME}/${S3_GCM_PREFIX}/"
- name: Upload new installer to AWS S3
env:
S3_BUCKET_NAME: ${{ secrets.S3_BUCKET_NAME }}
S3_GCM_PREFIX: "GCM"
run: |
LOCAL_INSTALLER_NAME="${{ steps.get_version.outputs.local_installer_name }}"
SERVER_INSTALLER_NAME="${{ steps.get_version.outputs.server_installer_name }}"
aws s3 cp "./${LOCAL_INSTALLER_NAME}" "s3://${S3_BUCKET_NAME}/${S3_GCM_PREFIX}/${SERVER_INSTALLER_NAME}"
echo "'${LOCAL_INSTALLER_NAME}' uploaded to s3://${S3_BUCKET_NAME}/${S3_GCM_PREFIX}/"
- name: Create CloudFront Invalidation
env:
CLOUDFRONT_DISTRIBUTION_ID: ${{ secrets.CLOUDFRONT_DISTRIBUTION_ID }}
S3_PREFIX_FOR_INVALIDATION: "GCM"
run: |
echo "Creating invalidation for path /${S3_PREFIX_FOR_INVALIDATION}/*"
aws cloudfront create-invalidation \
--distribution-id $CLOUDFRONT_DISTRIBUTION_ID \
--paths "/${S3_PREFIX_FOR_INVALIDATION}/*"
================================================
FILE: .gitignore
================================================
__pycache__
secret_config.py
.venv
.vscode
.DS_Store
*.mo
dist/
compile.ps1
utility.py
ResourceHacker.ini
elevate.manifest
cpp/
================================================
FILE: Game Trainers/.gitignore
================================================
build/
.vscode/
bin/
obj/
.venv/
*.sln
*.ps1
MonoBridge.dll
GCMInjection.dll
IL2CPP.dll
trainers/**/*.ttf
process_user_trainers.py
user_trainers.json
user_trainers.xlsx
completed_trainers.txt
User Trainers/
documents/*.txt
documents/*.md
================================================
FILE: Game Trainers/CMakeLists.txt
================================================
cmake_minimum_required(VERSION 3.15)
project(GameTrainers LANGUAGES CXX)
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
# Trainer architecture requirements (format: "TrainerName:architecture")
# Used by both CMakeLists.txt and build_all.ps1 (which parses this file)
set(TRAINER_ARCHITECTURES
"Arrow a Row Trainer:x64"
"DREDGE Trainer:x86"
"Feeding Frenzy 2_Shipwreck Showdown Trainer:x86"
"Headbangers_Rhythm Royale Trainer:x64"
"Heavy Weapon Trainer:x86"
"Inotia 4 Trainer:x64"
"Just Shapes & Beats Trainer:x64"
"Oil Rush Trainer:x86"
"Outland Trainer:x86"
"Plants vs. Zombies_GOTY Edition Trainer:x86"
"Plants vs. Zombies_Replanted Trainer:x64"
"PvZ2 Gardendless Trainer:x64"
"Wizard of Legend 2 Trainer:x64"
)
add_subdirectory(common)
# Determine current platform
if(CMAKE_GENERATOR_PLATFORM STREQUAL "x64" OR CMAKE_SIZEOF_VOID_P EQUAL 8)
set(CURRENT_PLATFORM "x64")
else()
set(CURRENT_PLATFORM "x86")
endif()
message(STATUS "Building for platform: ${CURRENT_PLATFORM}")
# Add each game-specific trainer with architecture information
foreach(TRAINER_SPEC ${TRAINER_ARCHITECTURES})
string(REPLACE ":" ";" TRAINER_PARTS ${TRAINER_SPEC})
list(GET TRAINER_PARTS 0 TRAINER_NAME)
list(GET TRAINER_PARTS 1 TRAINER_ARCH)
set(TRAINER_DIR "trainers/${TRAINER_NAME}")
set(TRAINER_REQUIRED_ARCH ${TRAINER_ARCH})
# Only add trainers matching the current platform
if(TRAINER_ARCH STREQUAL CURRENT_PLATFORM)
message(STATUS "Adding: ${TRAINER_NAME} (${TRAINER_ARCH})")
add_subdirectory(${TRAINER_DIR})
else()
message(STATUS "Skipping: ${TRAINER_NAME} (requires ${TRAINER_ARCH}, building for ${CURRENT_PLATFORM})")
endif()
endforeach()
================================================
FILE: Game Trainers/common/CMakeLists.txt
================================================
add_library(Common INTERFACE)
# Set include directories for Common
target_include_directories(Common INTERFACE
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>
)
# Define FLTK library directory based on architecture
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
# 64-bit architecture
set(FLTK_LIB_DIR "${CMAKE_CURRENT_SOURCE_DIR}/libs/x64")
set(FLTK_LIBS
"${FLTK_LIB_DIR}/fltk.lib"
"${FLTK_LIB_DIR}/fltk_forms.lib"
"${FLTK_LIB_DIR}/fltk_images.lib"
"${FLTK_LIB_DIR}/fltk_png.lib"
"${FLTK_LIB_DIR}/fltk_z.lib"
)
set(MONO_BRIDGE_DEST_DIR "${CMAKE_CURRENT_SOURCE_DIR}/libs/x64")
set(MINHOOK_LIB "${CMAKE_CURRENT_SOURCE_DIR}/libs/x64/libMinHook.x64.lib")
else()
# 32-bit architecture
set(FLTK_LIB_DIR "${CMAKE_CURRENT_SOURCE_DIR}/libs/x86")
set(FLTK_LIBS
"${FLTK_LIB_DIR}/fltk.lib"
"${FLTK_LIB_DIR}/fltk_forms.lib"
"${FLTK_LIB_DIR}/fltk_images.lib"
"${FLTK_LIB_DIR}/fltk_png.lib"
"${FLTK_LIB_DIR}/fltk_z.lib"
)
set(MONO_BRIDGE_DEST_DIR "${CMAKE_CURRENT_SOURCE_DIR}/libs/x86")
set(MINHOOK_LIB "${CMAKE_CURRENT_SOURCE_DIR}/libs/x86/libMinHook.x86.lib")
endif()
# Link FLTK and Windows libraries to Common
target_link_libraries(Common INTERFACE
${FLTK_LIBS}
comctl32
gdiplus
ws2_32
shlwapi
)
# Define MonoBridge as a shared library
add_library(MonoBridge SHARED
"${CMAKE_CURRENT_SOURCE_DIR}/include/MonoBridge.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/include/MonoBridge.def"
)
# Link MonoBridge to Common
target_link_libraries(MonoBridge PRIVATE Common)
# Post-build command to move only MonoBridge.dll to the destination
add_custom_command(TARGET MonoBridge POST_BUILD
COMMAND ${CMAKE_COMMAND} -E copy_if_different
"$<TARGET_FILE:MonoBridge>"
"${MONO_BRIDGE_DEST_DIR}/MonoBridge.dll"
COMMENT "Moving MonoBridge.dll to ${MONO_BRIDGE_DEST_DIR}"
)
================================================
FILE: Game Trainers/common/assets/elevate.xml
================================================
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
<trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
<security>
<requestedPrivileges>
<requestedExecutionLevel level="requireAdministrator" uiAccess="false"/>
</requestedPrivileges>
</security>
</trustInfo>
</assembly>
================================================
FILE: Game Trainers/common/include/CDPBase.h
================================================
// CDPBase.h
// Base class for trainers targeting web-based desktop games (Tauri/WebView2, Electron, CEF, NW.js).
// Communicates via Chrome DevTools Protocol (CDP) over a persistent WebSocket connection.
// Derived classes implement game-specific cheat functions using executeJS().
#pragma once
#include <winsock2.h>
#include <Windows.h>
#include <winhttp.h>
#include <string>
#include <vector>
#include <chrono>
#include <iostream>
#include <shlobj.h>
#include <filesystem>
#include <fstream>
#include <nlohmann/json.hpp>
#pragma comment(lib, "winhttp.lib")
using json = nlohmann::json;
/// How the game process receives the remote debugging port argument.
enum class CDPLaunchMethod
{
/// WebView2 / Tauri: set env var WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS
WebView2EnvVar,
/// Electron / CEF / NW.js: append --remote-debugging-port=PORT to command line
CommandLineArg
};
class CDPBase
{
public:
std::string gamePath;
CDPBase(const std::string &settingsKey, CDPLaunchMethod method = CDPLaunchMethod::WebView2EnvVar)
: settingsKey_(settingsKey), launchMethod_(method)
{
loadSettings();
}
virtual ~CDPBase()
{
wsDisconnect();
}
// ============================================================
// FLTKUtils compatibility interface
// ============================================================
std::wstring getProcessName() const
{
return L"localhost:" + std::to_wstring(cdpPort_);
}
DWORD getProcessId() const
{
return lastCheckResult_ ? (DWORD)cdpPort_ : 0;
}
void cleanUp()
{
lastCheckResult_ = false;
}
/// Called periodically by FLTKUtils timer (~1s).
bool isProcessRunning()
{
if (!gameLaunched_)
return false;
auto now = std::chrono::steady_clock::now();
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(now - lastCheckTime_).count();
if (elapsed < 3000)
return lastCheckResult_;
lastCheckTime_ = now;
if (wsHandle_)
{
std::string pingResult;
lastCheckResult_ = wsEvaluate(cachedWsPath_, "1", &pingResult);
}
else
{
// WebSocket is down — quick HTTP check first (fast fail if game is gone)
if (!checkCDP())
{
lastCheckResult_ = false;
}
else
{
// Game is still alive — try to reconnect WebSocket
if (cachedWsPath_.empty())
discoverPageWsPath(cachedWsPath_);
if (!cachedWsPath_.empty())
lastCheckResult_ = wsReconnect(cachedWsPath_);
else
lastCheckResult_ = true; // CDP alive, just can't get WS yet
}
}
if (!lastCheckResult_)
{
cdpFailCount_++;
if (cdpFailCount_ >= 3)
{
wsDisconnect();
cachedWsPath_.clear();
gameLaunched_ = false;
cdpFailCount_ = 0;
}
}
else
{
cdpFailCount_ = 0;
}
return lastCheckResult_;
}
// ============================================================
// Game Launching
// ============================================================
bool launchGame()
{
if (gamePath.empty())
return false;
cdpPort_ = findFreePort(9222);
std::string workDir = gamePath;
size_t lastSlash = workDir.find_last_of("\\/");
if (lastSlash != std::string::npos)
workDir = workDir.substr(0, lastSlash);
STARTUPINFOA si = {};
PROCESS_INFORMATION pi = {};
si.cb = sizeof(si);
bool ok = false;
if (launchMethod_ == CDPLaunchMethod::WebView2EnvVar)
{
std::string envVal = "--remote-debugging-port=" + std::to_string(cdpPort_);
SetEnvironmentVariableA("WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS", envVal.c_str());
ok = CreateProcessA(
gamePath.c_str(), nullptr, nullptr, nullptr, FALSE,
CREATE_NEW_PROCESS_GROUP, nullptr, workDir.c_str(), &si, &pi);
}
else // CDPLaunchMethod::CommandLineArg
{
std::string cmdLine = "\"" + gamePath + "\" --remote-debugging-port=" + std::to_string(cdpPort_);
ok = CreateProcessA(
nullptr, cmdLine.data(), nullptr, nullptr, FALSE,
CREATE_NEW_PROCESS_GROUP, nullptr, workDir.c_str(), &si, &pi);
}
if (ok)
{
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
gameLaunched_ = true;
saveSettings();
}
return ok;
}
// ============================================================
// Core JS Execution via CDP
// ============================================================
/// Execute JavaScript in the game's web context via CDP.
/// @param expression JS code to evaluate (should return 'ok' on success)
/// @param result Optional: receives the return value as string
/// @return true if JS executed and did NOT return a 'fail' string
bool executeJS(const std::string &expression, std::string *result = nullptr)
{
std::string safeExpr = "try{" + expression + "}catch(_e){'fail: '+_e.message}";
if (cachedWsPath_.empty())
{
if (!discoverPageWsPath(cachedWsPath_))
{
std::cerr << "[!] Failed to discover CDP page target.\n";
return false;
}
}
std::string jsResult;
bool connected = wsEvaluate(cachedWsPath_, safeExpr, &jsResult);
if (!connected)
{
wsDisconnect();
cachedWsPath_.clear();
if (discoverPageWsPath(cachedWsPath_))
connected = wsEvaluate(cachedWsPath_, safeExpr, &jsResult);
if (!connected)
return false;
}
if (result)
*result = jsResult;
if (jsResult.size() >= 4 && jsResult.compare(0, 4, "fail") == 0)
return false;
return true;
}
// ============================================================
// Settings Persistence
// ============================================================
void saveSettings()
{
std::string path = getSettingsFilePath();
json settings;
std::ifstream ifile(path);
if (ifile.is_open())
{
try
{
ifile >> settings;
}
catch (...)
{
}
ifile.close();
}
else
{
std::filesystem::create_directories(std::filesystem::path(path).parent_path());
}
settings["game_path"] = gamePath;
std::ofstream ofile(path);
ofile << settings.dump(4);
}
void loadSettings()
{
std::string path = getSettingsFilePath();
std::ifstream file(path);
if (!file.is_open())
return;
try
{
json settings;
file >> settings;
if (settings.contains("game_path"))
gamePath = settings["game_path"].get<std::string>();
}
catch (...)
{
}
}
private:
std::string settingsKey_;
CDPLaunchMethod launchMethod_;
int cdpPort_ = 9222;
bool gameLaunched_ = false;
bool lastCheckResult_ = false;
int cdpFailCount_ = 0;
std::string cachedWsPath_;
std::chrono::steady_clock::time_point lastCheckTime_;
// Persistent WebSocket connection handles
HINTERNET wsSession_ = nullptr;
HINTERNET wsConnect_ = nullptr;
HINTERNET wsHandle_ = nullptr;
int nextMsgId_ = 1;
std::string getSettingsFilePath()
{
PWSTR appdata = nullptr;
SHGetKnownFolderPath(FOLDERID_RoamingAppData, 0, nullptr, &appdata);
std::filesystem::path dir(appdata);
CoTaskMemFree(appdata);
return (dir / "GCM Settings" / (settingsKey_ + ".json")).string();
}
int findFreePort(int startPort)
{
for (int port = startPort; port < startPort + 100; ++port)
{
SOCKET sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (sock == INVALID_SOCKET)
continue;
sockaddr_in addr = {};
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
addr.sin_port = htons((u_short)port);
int result = bind(sock, (sockaddr *)&addr, sizeof(addr));
closesocket(sock);
if (result == 0)
return port;
}
return startPort;
}
// ============================================================
// CDP HTTP / WebSocket Implementation
// ============================================================
bool checkCDP()
{
HINTERNET hSession = WinHttpOpen(L"CDPTrainer", WINHTTP_ACCESS_TYPE_NO_PROXY, NULL, NULL, 0);
if (!hSession)
return false;
DWORD connectTimeout = 200;
DWORD ioTimeout = 300;
WinHttpSetOption(hSession, WINHTTP_OPTION_CONNECT_TIMEOUT, &connectTimeout, sizeof(connectTimeout));
WinHttpSetOption(hSession, WINHTTP_OPTION_RECEIVE_TIMEOUT, &ioTimeout, sizeof(ioTimeout));
WinHttpSetOption(hSession, WINHTTP_OPTION_SEND_TIMEOUT, &ioTimeout, sizeof(ioTimeout));
HINTERNET hConnect = WinHttpConnect(hSession, L"localhost", (INTERNET_PORT)cdpPort_, 0);
if (!hConnect)
{
WinHttpCloseHandle(hSession);
return false;
}
HINTERNET hRequest = WinHttpOpenRequest(hConnect, L"GET", L"/json/version",
NULL, WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, 0);
if (!hRequest)
{
WinHttpCloseHandle(hConnect);
WinHttpCloseHandle(hSession);
return false;
}
bool ok = false;
if (WinHttpSendRequest(hRequest, NULL, 0, NULL, 0, 0, 0) &&
WinHttpReceiveResponse(hRequest, NULL))
{
DWORD statusCode = 0;
DWORD sz = sizeof(statusCode);
WinHttpQueryHeaders(hRequest, WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER,
NULL, &statusCode, &sz, NULL);
ok = (statusCode == 200);
}
WinHttpCloseHandle(hRequest);
WinHttpCloseHandle(hConnect);
WinHttpCloseHandle(hSession);
return ok;
}
std::string httpGet(const wchar_t *path)
{
HINTERNET hSession = WinHttpOpen(L"CDPTrainer", WINHTTP_ACCESS_TYPE_NO_PROXY, NULL, NULL, 0);
if (!hSession)
return "";
DWORD timeout = 500;
WinHttpSetOption(hSession, WINHTTP_OPTION_CONNECT_TIMEOUT, &timeout, sizeof(timeout));
WinHttpSetOption(hSession, WINHTTP_OPTION_RECEIVE_TIMEOUT, &timeout, sizeof(timeout));
WinHttpSetOption(hSession, WINHTTP_OPTION_SEND_TIMEOUT, &timeout, sizeof(timeout));
HINTERNET hConnect = WinHttpConnect(hSession, L"localhost", (INTERNET_PORT)cdpPort_, 0);
if (!hConnect)
{
WinHttpCloseHandle(hSession);
return "";
}
HINTERNET hRequest = WinHttpOpenRequest(hConnect, L"GET", path,
NULL, WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, 0);
if (!hRequest)
{
WinHttpCloseHandle(hConnect);
WinHttpCloseHandle(hSession);
return "";
}
std::string body;
if (WinHttpSendRequest(hRequest, NULL, 0, NULL, 0, 0, 0) &&
WinHttpReceiveResponse(hRequest, NULL))
{
DWORD avail = 0;
while (WinHttpQueryDataAvailable(hRequest, &avail) && avail > 0)
{
std::vector<char> buf(avail);
DWORD bytesRead = 0;
WinHttpReadData(hRequest, buf.data(), avail, &bytesRead);
body.append(buf.data(), bytesRead);
}
}
WinHttpCloseHandle(hRequest);
WinHttpCloseHandle(hConnect);
WinHttpCloseHandle(hSession);
return body;
}
bool discoverPageWsPath(std::string &outPath)
{
std::string body = httpGet(L"/json");
if (body.empty())
return false;
json targets = json::parse(body, nullptr, false);
if (targets.is_discarded() || !targets.is_array())
return false;
for (auto &target : targets)
{
if (target.value("type", "") == "page")
{
std::string wsUrl = target.value("webSocketDebuggerUrl", "");
if (wsUrl.empty())
continue;
size_t pathStart = wsUrl.find('/', wsUrl.find("//") + 2);
if (pathStart != std::string::npos)
{
outPath = wsUrl.substr(pathStart);
return true;
}
}
}
return false;
}
bool wsEvaluate(const std::string &wsPath, const std::string &expression, std::string *result)
{
if (!wsHandle_ && !wsReconnect(wsPath))
return false;
int msgId = nextMsgId_++;
json msg = {
{"id", msgId},
{"method", "Runtime.evaluate"},
{"params", {{"expression", expression}, {"returnByValue", true}, {"awaitPromise", false}}}};
std::string msgStr = msg.dump();
DWORD err = WinHttpWebSocketSend(wsHandle_,
WINHTTP_WEB_SOCKET_UTF8_MESSAGE_BUFFER_TYPE,
(PVOID)msgStr.c_str(), (DWORD)msgStr.size());
if (err != ERROR_SUCCESS)
{
wsDisconnect();
return false;
}
for (int attempts = 0; attempts < 50; attempts++)
{
std::string response = wsReadMessage(wsHandle_);
if (response.empty())
{
wsDisconnect();
return false;
}
json resp = json::parse(response, nullptr, false);
if (resp.is_discarded())
continue;
if (resp.contains("id") && resp["id"].get<int>() == msgId)
{
if (result && resp.contains("result") && resp["result"].contains("result"))
{
auto &val = resp["result"]["result"];
if (val.contains("value"))
{
if (val["value"].is_string())
*result = val["value"].get<std::string>();
else
*result = val["value"].dump();
}
}
return true;
}
}
wsDisconnect();
return false;
}
bool wsReconnect(const std::string &wsPath)
{
wsDisconnect();
wsSession_ = WinHttpOpen(L"CDPTrainer", WINHTTP_ACCESS_TYPE_NO_PROXY, NULL, NULL, 0);
if (!wsSession_)
return false;
DWORD connectTimeout = 500;
DWORD sendRecvTimeout = 3000;
WinHttpSetOption(wsSession_, WINHTTP_OPTION_CONNECT_TIMEOUT, &connectTimeout, sizeof(connectTimeout));
WinHttpSetOption(wsSession_, WINHTTP_OPTION_RECEIVE_TIMEOUT, &sendRecvTimeout, sizeof(sendRecvTimeout));
WinHttpSetOption(wsSession_, WINHTTP_OPTION_SEND_TIMEOUT, &sendRecvTimeout, sizeof(sendRecvTimeout));
wsConnect_ = WinHttpConnect(wsSession_, L"localhost", (INTERNET_PORT)cdpPort_, 0);
if (!wsConnect_)
{
wsDisconnect();
return false;
}
std::wstring wPath(wsPath.begin(), wsPath.end());
HINTERNET hRequest = WinHttpOpenRequest(wsConnect_, L"GET", wPath.c_str(),
NULL, WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, 0);
if (!hRequest)
{
wsDisconnect();
return false;
}
WinHttpSetOption(hRequest, WINHTTP_OPTION_UPGRADE_TO_WEB_SOCKET, NULL, 0);
if (!WinHttpSendRequest(hRequest, WINHTTP_NO_ADDITIONAL_HEADERS, 0, NULL, 0, 0, 0) ||
!WinHttpReceiveResponse(hRequest, NULL))
{
WinHttpCloseHandle(hRequest);
wsDisconnect();
return false;
}
wsHandle_ = WinHttpWebSocketCompleteUpgrade(hRequest, 0);
WinHttpCloseHandle(hRequest);
if (!wsHandle_)
{
wsDisconnect();
return false;
}
return true;
}
void wsDisconnect()
{
if (wsHandle_)
{
WinHttpCloseHandle(wsHandle_);
wsHandle_ = nullptr;
}
if (wsConnect_)
{
WinHttpCloseHandle(wsConnect_);
wsConnect_ = nullptr;
}
if (wsSession_)
{
WinHttpCloseHandle(wsSession_);
wsSession_ = nullptr;
}
}
std::string wsReadMessage(HINTERNET hWs)
{
std::string message;
char buffer[8192];
DWORD bytesRead = 0;
WINHTTP_WEB_SOCKET_BUFFER_TYPE bufferType;
do
{
DWORD err = WinHttpWebSocketReceive(hWs, buffer, sizeof(buffer), &bytesRead, &bufferType);
if (err != ERROR_SUCCESS)
return "";
if (bufferType == WINHTTP_WEB_SOCKET_CLOSE_BUFFER_TYPE)
return "";
message.append(buffer, bytesRead);
} while (bufferType == WINHTTP_WEB_SOCKET_UTF8_FRAGMENT_BUFFER_TYPE ||
bufferType == WINHTTP_WEB_SOCKET_BINARY_FRAGMENT_BUFFER_TYPE);
return message;
}
};
================================================
FILE: Game Trainers/common/include/FL/Enumerations.H
================================================
//
// Enumerations for the Fast Light Tool Kit (FLTK).
//
// Copyright 1998-2025 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
This file contains type definitions and general enumerations.
*/
#ifndef Fl_Enumerations_H
#define Fl_Enumerations_H
/*
******************************************************************************
* FL_ABI_VERSION is defined by configure or CMake since FLTK 1.3.4.
* It is written to FL/fl_config.h and #included here.
******************************************************************************
* For more informations on FL_ABI_VERSION see README.abi-version.txt.
******************************************************************************
*/
#include <FL/fl_config.h>
# include "Fl_Export.H"
# include "fl_types.h"
# include <FL/platform_types.h> // for FL_COMMAND and FL_CONTROL
// Current FLTK version: 1.4.2
/** \name Version Numbers
FLTK defines some constants to help the programmer to
find out, for which FLTK version a program is compiled.
The following constants are defined:
*/
/**@{*/
/**
The major release version of this FLTK library.
\see FL_VERSION
*/
#define FL_MAJOR_VERSION 1
/**
The minor release version for this library.
FLTK remains mostly source-code compatible between minor version changes.
*/
#define FL_MINOR_VERSION 4
/**
The patch version for this library.
FLTK remains binary compatible between patches.
*/
#define FL_PATCH_VERSION 2
/**
The FLTK version number as a \em double.
FL_VERSION is a \em double that describes the major, minor, and patch
version numbers.
Version 1.2.3 is actually stored as 1.0203 to allow for more than 9
minor and patch releases.
\deprecated This \p double version number is retained for compatibility
with existing program code. New code should use \em int FL_API_VERSION
instead. FL_VERSION is deprecated because comparisons of floating point
values may fail due to rounding errors. However, there are currently no
plans to remove this deprecated constant.
FL_VERSION is equivalent to <em>(double)FL_API_VERSION / 10000</em>.
\see Fl::version() (deprecated as well)
\see FL_API_VERSION
\see Fl::api_version()
*/
#define FL_VERSION ( (double)FL_MAJOR_VERSION + \
(double)FL_MINOR_VERSION * 0.01 + \
(double)FL_PATCH_VERSION * 0.0001 )
/**
The FLTK API version number as an \em int.
FL_API_VERSION is an \em int that describes the major, minor, and patch
version numbers.
Version 1.2.3 is actually stored as 10203 to allow for more than 9
minor and patch releases.
The FL_MAJOR_VERSION, FL_MINOR_VERSION, and FL_PATCH_VERSION constants
give the integral values for the major, minor, and patch releases
respectively.
\note FL_API_VERSION is intended to replace the deprecated
\em double FL_VERSION.
\see Fl::api_version()
*/
#define FL_API_VERSION (FL_MAJOR_VERSION*10000 + FL_MINOR_VERSION*100 + FL_PATCH_VERSION)
/**
The FLTK ABI (Application Binary Interface) version number as an \em int.
FL_ABI_VERSION is an \em int that describes the major, minor, and patch
ABI version numbers in the same format as FL_API_VERSION.
The ABI version number \p FL_ABI_VERSION is usually the same as the
API version \p FL_API_VERSION with the last two digits set to '00'.
FLTK retains the ABI (Application Binary Interface) during patch
releases of the same major and minor versions. Examples:
\verbatim
FLTK Version FL_API_VERSION FL_ABI_VERSION FL_VERSION (deprecated)
1.3.0 10300 10300 1.0300
1.3.4 10304 10300 1.0304
\endverbatim
Version 1.2.3 is actually stored as 10203 to allow for more than 9
minor and patch releases.
The FL_MAJOR_VERSION, FL_MINOR_VERSION, and FL_PATCH_VERSION constants
give the integral values for the major, minor, and patch releases
respectively.
To enable new ABI-breaking features in patch releases you can configure
FLTK to use a higher FL_ABI_VERSION.
\see README.abi-version.txt
*/
#ifndef FL_ABI_VERSION
#define FL_ABI_VERSION (FL_MAJOR_VERSION*10000 + FL_MINOR_VERSION*100)
#endif
/*
Check if FL_ABI_VERSION is out of allowed range; redefine if necessary.
This is done to prevent users from defining an illegal ABI version.
Rule: FL_MAJOR_VERSION * 10000 + FL_MINOR_VERSION * 100
<= FL_ABI_VERSION <= FL_API_VERSION.
Example (FLTK 1.3.4):
10300 <= FL_ABI_VERSION <= 10304
Note: configure + CMake can be used to define FL_ABI_VERSION, but they
do not check validity. This is done here.
*/
#if FL_ABI_VERSION < FL_MAJOR_VERSION*10000 + FL_MINOR_VERSION*100
# undef FL_ABI_VERSION
# define FL_ABI_VERSION (FL_MAJOR_VERSION*10000 + FL_MINOR_VERSION*100)
#elif FL_ABI_VERSION > FL_API_VERSION
# undef FL_ABI_VERSION
# define FL_ABI_VERSION FL_API_VERSION
#endif
/**@}*/ // group: Version Numbers
/**
Every time a user moves the mouse pointer, clicks a button,
or presses a key, an event is generated and sent to your
application. Events can also come from other programs like the
window manager.
Events are identified by the integer argument passed to the
Fl_Widget::handle() virtual method. Other information about the
most recent event is stored in static locations and acquired by
calling the Fl::event_*() methods. This static information remains
valid until the next event is read from the window system, so it
is ok to look at it outside of the handle() method.
Event numbers can be converted to their actual names using the
\ref fl_eventnames[] array defined in \#include <FL/names.h>
\see Fl::event_text(), Fl::event_key(), class Fl::
*/
// DEV NOTE: Keep this list in sync with FL/names.h
enum Fl_Event { // events
/** No event. */
FL_NO_EVENT = 0,
/** A mouse button has gone down with the mouse pointing at this
widget. You can find out what button by calling Fl::event_button().
You find out the mouse position by calling Fl::event_x() and
Fl::event_y().
A widget indicates that it "wants" the mouse click by returning non-zero
from its Fl_Widget::handle() method. It will then become the
Fl::pushed() widget and will get FL_DRAG and the matching FL_RELEASE events.
If Fl_Widget::handle() returns zero then FLTK will try sending the FL_PUSH
to another widget.
*/
FL_PUSH = 1,
/** A mouse button has been released. You can find out what button by
calling Fl::event_button().
In order to receive the FL_RELEASE event, the widget must return
non-zero when handling FL_PUSH.
*/
FL_RELEASE = 2,
/** The mouse has been moved to point at this widget. This can
be used for highlighting feedback. If a widget wants to
highlight or otherwise track the mouse, it indicates this by
returning non-zero from its handle() method. It then
becomes the Fl::belowmouse() widget and will receive
FL_MOVE and FL_LEAVE events.
*/
FL_ENTER = 3,
/** The mouse has moved out of the widget.
In order to receive the FL_LEAVE event, the widget must
return non-zero when handling FL_ENTER.
*/
FL_LEAVE = 4,
/** The mouse has moved with a button held down. The current button state
is in Fl::event_state(). The mouse position is in Fl::event_x() and
Fl::event_y().
In order to receive FL_DRAG events, the widget must return non-zero
when handling FL_PUSH.
*/
FL_DRAG = 5,
/** This indicates an <I>attempt</I> to give a widget the keyboard focus.
If a widget wants the focus, it should change itself to display the
fact that it has the focus, and return non-zero from its handle() method.
It then becomes the Fl::focus() widget and gets FL_KEYDOWN, FL_KEYUP,
and FL_UNFOCUS events.
The focus will change either because the window manager changed which
window gets the focus, or because the user tried to navigate using tab,
arrows, or other keys. You can check Fl::event_key() to figure out why
it moved. For navigation it will be the key pressed and for interaction
with the window manager it will be zero.
*/
FL_FOCUS = 6,
/** This event is sent to the previous Fl::focus() widget when another
widget gets the focus or the window loses focus.
*/
FL_UNFOCUS = 7,
/** A key was pressed (FL_KEYDOWN) or released (FL_KEYUP).
Fl_KEYBOARD is a synonym for FL_KEYDOWN.
The key can be found in Fl::event_key().
The text that the key should insert can be found with Fl::event_text()
and its length is in Fl::event_length(). If you use the key handle()
should return 1. If you return zero then FLTK assumes you ignored the
key and will then attempt to send it to a parent widget. If none of
them want it, it will change the event into a FL_SHORTCUT event.
To receive FL_KEYBOARD events you must also respond to the FL_FOCUS
and FL_UNFOCUS events.
If you are writing a text-editing widget you may also want to call
the Fl::compose() function to translate individual keystrokes into
non-ASCII characters.
FL_KEYUP events are sent to the widget that currently has focus. This
is not necessarily the same widget that received the corresponding
FL_KEYDOWN event because focus may have changed between events.
*/
FL_KEYDOWN = 8,
/** Equivalent to FL_KEYDOWN.
\see FL_KEYDOWN
*/
FL_KEYBOARD = 8,
/** Key release event.
\see FL_KEYDOWN
*/
FL_KEYUP = 9,
/** The user clicked the close button of a window.
This event is used internally only to trigger the callback of
Fl_Window derived classed. The default callback closes the
window calling Fl_Window::hide().
*/
FL_CLOSE = 10,
/** The mouse has moved without any mouse buttons held down.
This event is sent to the Fl::belowmouse() widget.
In order to receive FL_MOVE events, the widget must return
non-zero when handling FL_ENTER.
*/
FL_MOVE = 11,
/** If the Fl::focus() widget is zero or ignores an FL_KEYBOARD
event then FLTK tries sending this event to every widget it
can, until one of them returns non-zero. FL_SHORTCUT is first
sent to the Fl::belowmouse() widget, then its parents and siblings,
and eventually to every widget in the window, trying to find an
object that returns non-zero. FLTK tries really hard to not to ignore
any keystrokes!
You can also make "global" shortcuts by using Fl::add_handler(). A
global shortcut will work no matter what windows are displayed or
which one has the focus.
*/
FL_SHORTCUT = 12,
/** This widget is no longer active, due to Fl_Widget::deactivate()
being called on it or one of its parents. Fl_Widget::active() may
still be true after this, the widget is only active if Fl_Widget::active()
is true on it and all its parents (use Fl_Widget::active_r() to check this).
*/
FL_DEACTIVATE = 13,
/** This widget is now active, due to Fl_Widget::activate() being
called on it or one of its parents.
*/
FL_ACTIVATE = 14,
/** This widget is no longer visible, due to Fl_Widget::hide() being
called on it or one of its parents, or due to a parent window being
minimized. Fl_Widget::visible() may still be true after this, but the
widget is visible only if visible() is true for it and all its
parents (use Fl_Widget::visible_r() to check this).
*/
FL_HIDE = 15,
/** This widget is visible again, due to Fl_Widget::show() being called on
it or one of its parents, or due to a parent window being restored.
Child Fl_Windows respond to this by actually creating the window if not
done already, so if you subclass a window, be sure to pass FL_SHOW
to the base class Fl_Widget::handle() method!
*/
FL_SHOW = 16,
/** You should get this event some time after you call Fl::paste().
The contents of Fl::event_text() is the text to insert and the number
of characters is in Fl::event_length().
*/
FL_PASTE = 17,
/** The Fl::selection_owner() will get this event before the selection is
moved to another widget. This indicates that some other widget or program
has claimed the selection. Motif programs used this to clear the selection
indication. Most modern programs ignore this.
*/
FL_SELECTIONCLEAR = 18,
/** The user has moved the mouse wheel. The Fl::event_dx() and Fl::event_dy()
methods can be used to find the amount to scroll horizontally and vertically.
*/
FL_MOUSEWHEEL = 19,
/** The mouse has been moved to point at this widget. A widget that is
interested in receiving drag'n'drop data must return 1 to receive
FL_DND_DRAG, FL_DND_LEAVE and FL_DND_RELEASE events.
*/
FL_DND_ENTER = 20,
/** The mouse has been moved inside a widget while dragging data. A
widget that is interested in receiving drag'n'drop data should
indicate the possible drop position.
*/
FL_DND_DRAG = 21,
/** The mouse has moved out of the widget.
*/
FL_DND_LEAVE = 22,
/** The user has released the mouse button dropping data into the widget.
If the widget returns 1, it will receive the data in the immediately
following FL_PASTE event.
*/
FL_DND_RELEASE = 23,
/** The screen configuration (number, positions) was changed.
Use Fl::add_handler() to be notified of this event.
*/
FL_SCREEN_CONFIGURATION_CHANGED = 24,
/** The fullscreen state of the window has changed.
This event is sent to the window's handle method.
*/
FL_FULLSCREEN = 25,
/** The user has made a zoom/pinch/magnification gesture (Mac OS platform only).
The Fl::event_dy() method can be used to find magnification amount,
Fl::event_x() and Fl::event_y() are set as well.
This event is sent to the window's handle method.
*/
FL_ZOOM_GESTURE = 26,
/** A zoom event (ctrl/+/-/0/ or cmd/+/-/0/) was processed.
Use Fl::add_handler() to be notified of this event.
*/
FL_ZOOM_EVENT = 27
// DEV NOTE: Keep this list in sync with FL/names.h
};
/** \name When Conditions */
/**@{*/
/** These constants determine when a callback is performed.
Fl_When is a bit field. Some values are merely shortcuts for common bit
combinations. New flags may be added in the future, so it's important to
mask the required bit when reading via \p when().
\note Some widgets may not fully support \p FL_WHEN_... flags.
\see Fl_Widget::when(), Fl::callback_reason(), Fl_Callback_Reason, Fl_Widget::do_callback()
*/
enum Fl_When { // Fl_Widget::when():
FL_WHEN_NEVER = 0, ///< Never call the callback
FL_WHEN_CHANGED = 1, ///< Do the callback only when the widget value changes
FL_WHEN_NOT_CHANGED = 2, ///< Do the callback whenever the user interacts with the widget
FL_WHEN_RELEASE = 4, ///< Do the callback when the button or key is released and the value changes
FL_WHEN_RELEASE_ALWAYS = 6, ///< Do the callback when the button or key is released, even if the value doesn't change
FL_WHEN_ENTER_KEY = 8, ///< Do the callback when the user presses the ENTER key and the value changes
FL_WHEN_ENTER_KEY_ALWAYS = 10, ///< Do the callback when the user presses the ENTER key, even if the value doesn't change
FL_WHEN_ENTER_KEY_CHANGED = 11, ///< Do callbacks whether the value changed or not, and when the ENTER key is pressed
FL_WHEN_CLOSED = 16 ///< Do the callback when a child of Fl_Tabs is closed
};
/**@}*/ // group: When Conditions
/** \name Callback Reasons */
/**@{*/
/** These constants describe why a callback is performed.
\see Fl::callback_reason(), Fl_Widget::when(), Fl_When
*/
enum Fl_Callback_Reason {
FL_REASON_UNKNOWN=0, ///< unknown or unset reason
FL_REASON_SELECTED, ///< an item was selected
FL_REASON_DESELECTED, ///< an item was de-selected
FL_REASON_RESELECTED, ///< an item was re-selected (double-clicked).
FL_REASON_OPENED, ///< an item was opened
FL_REASON_CLOSED, ///< an item was closed
FL_REASON_DRAGGED, ///< an item was dragged into a new place
FL_REASON_CANCELLED, ///< a dialog was cancelled
FL_REASON_CHANGED, ///< the value of the widget was modified
FL_REASON_GOT_FOCUS, ///< a widget received focus
FL_REASON_LOST_FOCUS, ///< a widget lost focus
FL_REASON_RELEASED, ///< the mouse button was released
FL_REASON_ENTER_KEY, ///< user finished input pressing Enter
FL_REASON_USER = 32 ///< user defined callback reasons
};
/**@}*/ // group: Callback Reasons
/** \name Names of Non-ASCII keys and mouse buttons
The following constants define the names of non-ASCII keys on the
keyboard and of mouse buttons for FL_KEYBOARD and FL_SHORTCUT events.
\see Fl::event_key() and Fl::get_key(int) (use ASCII letters for all other keys):
*/
/**@{*/
// FIXME: These codes collide with valid Unicode keys
#define FL_Button 0xfee8 ///< A mouse button; use <tt>FL_Button + n</tt> for mouse button \c n.
#define FL_BackSpace 0xff08 ///< The backspace key.
#define FL_Tab 0xff09 ///< The tab key.
#define FL_Iso_Key 0xff0c ///< The additional key of ISO keyboards.
#define FL_Enter 0xff0d ///< The enter key.
#define FL_Pause 0xff13 ///< The pause key.
#define FL_Scroll_Lock 0xff14 ///< The scroll lock key.
#define FL_Escape 0xff1b ///< The escape key.
#define FL_Kana 0xff2e ///< The Kana key of JIS keyboards.
#define FL_Eisu 0xff2f ///< The Eisu key of JIS keyboards.
#define FL_Yen 0xff30 ///< The Yen key of JIS keyboards.
#define FL_JIS_Underscore 0xff31 ///< The underscore key of JIS keyboards.
#define FL_Home 0xff50 ///< The home key.
#define FL_Left 0xff51 ///< The left arrow key.
#define FL_Up 0xff52 ///< The up arrow key.
#define FL_Right 0xff53 ///< The right arrow key.
#define FL_Down 0xff54 ///< The down arrow key.
#define FL_Page_Up 0xff55 ///< The page-up key.
#define FL_Page_Down 0xff56 ///< The page-down key.
#define FL_End 0xff57 ///< The end key.
#define FL_Print 0xff61 ///< The print (or print-screen) key.
#define FL_Insert 0xff63 ///< The insert key.
#define FL_Menu 0xff67 ///< The menu key.
#define FL_Help 0xff68 ///< The 'help' key on Mac keyboards
#define FL_Num_Lock 0xff7f ///< The num lock key.
#define FL_KP 0xff80 ///< One of the keypad numbers; use FL_KP + 'n' for digit n.
#define FL_KP_Enter 0xff8d ///< The enter key on the keypad, same as Fl_KP+'\\r'.
#define FL_KP_Last 0xffbd ///< The last keypad key; use to range-check keypad.
#define FL_F 0xffbd ///< One of the function keys; use FL_F + n for function key n.
#define FL_F_Last 0xffe0 ///< The last function key; use to range-check function keys.
#define FL_Shift_L 0xffe1 ///< The lefthand shift key.
#define FL_Shift_R 0xffe2 ///< The righthand shift key.
#define FL_Control_L 0xffe3 ///< The lefthand control key.
#define FL_Control_R 0xffe4 ///< The righthand control key.
#define FL_Caps_Lock 0xffe5 ///< The caps lock key.
#define FL_Meta_L 0xffe7 ///< The left meta/Windows key.
#define FL_Meta_R 0xffe8 ///< The right meta/Windows key.
#define FL_Alt_L 0xffe9 ///< The left alt key.
#define FL_Alt_R 0xffea ///< The right alt key.
#define FL_Delete 0xffff ///< The delete key.
#define FL_Alt_Gr 0xfe03 ///< The AltGr key on some international keyboards.
// These use the Private Use Area (PUA) of the Basic Multilingual Plane
// of Unicode. Guaranteed not to conflict with a proper Unicode character.
// These primarily map to the XFree86 keysym range
#define FL_Volume_Down 0xEF11 ///< Volume control down
#define FL_Volume_Mute 0xEF12 ///< Mute sound from the system
#define FL_Volume_Up 0xEF13 ///< Volume control up
#define FL_Media_Play 0xEF14 ///< Start playing of audio
#define FL_Media_Stop 0xEF15 ///< Stop playing audio
#define FL_Media_Prev 0xEF16 ///< Previous track
#define FL_Media_Next 0xEF17 ///< Next track
#define FL_Home_Page 0xEF18 ///< Display user's home page
#define FL_Mail 0xEF19 ///< Invoke user's mail program
#define FL_Search 0xEF1B ///< Search
#define FL_Back 0xEF26 ///< Like back on a browser
#define FL_Forward 0xEF27 ///< Like forward on a browser
#define FL_Stop 0xEF28 ///< Stop current operation
#define FL_Refresh 0xEF29 ///< Refresh the page
#define FL_Sleep 0xEF2F ///< Put system to sleep
#define FL_Favorites 0xEF30 ///< Show favorite locations
/**@}*/ // group: Non-ASCII key names
/** \name Mouse Buttons
These constants define the button numbers for FL_PUSH and FL_RELEASE events.
\see Fl::event_button()
*/
/**@{*/
#define FL_LEFT_MOUSE 1 ///< The left mouse button
#define FL_MIDDLE_MOUSE 2 ///< The middle mouse button
#define FL_RIGHT_MOUSE 3 ///< The right mouse button
#define FL_BACK_MOUSE 4 ///< The back mouse button (side button 1)
#define FL_FORWARD_MOUSE 5 ///< The forward mouse button (side button 2)
/**@}*/ // group: Mouse Buttons
/** \name Event States
The following constants define bits in the Fl::event_state() value.
*/
/**@{*/ // group: Event States
// FIXME: it would be nice to have the modifiers in the upper 8 bits so that
// a unicode key (21 bits) can be sent as an unsigned with the modifiers.
#define FL_SHIFT 0x00010000 ///< One of the shift keys is down
#define FL_CAPS_LOCK 0x00020000 ///< The caps lock is on
#define FL_CTRL 0x00040000 ///< One of the ctrl keys is down
#define FL_ALT 0x00080000 ///< One of the alt keys is down
#define FL_NUM_LOCK 0x00100000 ///< The num lock is on
// most X servers do this?
#define FL_META 0x00400000 ///< One of the meta/Windows keys is down
// correct for XFree86
#define FL_SCROLL_LOCK 0x00800000 ///< The scroll lock is on
// correct for XFree86
// Mouse buttons
#define FL_BUTTON1 0x01000000 ///< Mouse button 1 is pushed (L)
#define FL_BUTTON2 0x02000000 ///< Mouse button 2 is pushed (M)
#define FL_BUTTON3 0x04000000 ///< Mouse button 3 is pushed (R)
#define FL_BUTTON4 0x08000000 ///< Mouse button 4 is pushed (BACK)
#define FL_BUTTON5 0x10000000 ///< Mouse button 5 is pushed (FORWARD)
#define FL_BUTTONS 0x1f000000 ///< Bitmask: any mouse button (1-5) is pushed
#define FL_BUTTON(n) (0x00800000<<(n)) ///< Mouse button n (n = 1..5) is pushed,
///< *undefined* if n outside 1..5
#define FL_KEY_MASK 0x0000ffff ///< All keys are 16 bit for now
// FIXME: Unicode needs 21 bits!
/**@}*/ // group: Event States
/** \name Box Types
\brief FLTK standard box types
This enum defines the standard box types included with FLTK.
\note The documented \p enum \p Fl_Boxtype contains some values (names)
with leading underscores, e.g. \p \b _FL_SHADOW_BOX. This is due to
technical reasons - please use the same values (names) without the
leading underscore in your code! Enum values with leading underscores
are reserved for internal use and subject to change without notice!
FL_NO_BOX means nothing is drawn at all, so whatever is already
on the screen remains. The FL_..._FRAME types only draw their edges,
leaving the interior unchanged. The blue color in the image below
is the area that is not drawn by the frame types.
\anchor boxTypesImage
\image html boxtypes.png "FLTK Standard Box Types"
\image latex boxtypes.png "FLTK Standard Box Types" width=12cm
\note Not all box types are depicted in the figure above.
See enum \ref Fl_Boxtype below for the complete list of box types.
\see Fl::get_system_colors()
*/
/**@{*/ // group: Box Types
/**
\brief FLTK standard box types
This enum defines the standard box types included with FLTK.
\note The documented \p enum \p Fl_Boxtype contains some values (names)
with leading underscores, e.g. \p \b _FL_SHADOW_BOX. This is due to
technical reasons - please use the same values (names) without the
leading underscore in your code! Enum values with leading underscores
are reserved for internal use and subject to change without notice!
*/
enum Fl_Boxtype { // boxtypes (if you change these you must also change fl_boxtype.cxx):
FL_NO_BOX = 0, ///< nothing is drawn at all, this box is invisible
FL_FLAT_BOX, ///< a flat box
FL_UP_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage)
FL_DOWN_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage)
FL_UP_FRAME, ///< see figure [Standard Box Types](@ref boxTypesImage)
FL_DOWN_FRAME, ///< see figure [Standard Box Types](@ref boxTypesImage)
FL_THIN_UP_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage)
FL_THIN_DOWN_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage)
FL_THIN_UP_FRAME, ///< see figure [Standard Box Types](@ref boxTypesImage)
FL_THIN_DOWN_FRAME, ///< see figure [Standard Box Types](@ref boxTypesImage)
FL_ENGRAVED_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage)
FL_EMBOSSED_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage)
FL_ENGRAVED_FRAME, ///< see figure [Standard Box Types](@ref boxTypesImage)
FL_EMBOSSED_FRAME, ///< see figure [Standard Box Types](@ref boxTypesImage)
FL_BORDER_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage)
_FL_SHADOW_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage), use FL_SHADOW_BOX
FL_BORDER_FRAME, ///< see figure [Standard Box Types](@ref boxTypesImage)
_FL_SHADOW_FRAME, ///< see figure [Standard Box Types](@ref boxTypesImage), use FL_SHADOW_FRAME
_FL_ROUNDED_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage), use FL_ROUNDED_BOX
_FL_RSHADOW_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage), use FL_RSHADOW_BOX
_FL_ROUNDED_FRAME, ///< see figure [Standard Box Types](@ref boxTypesImage), use FL_ROUNDED_FRAME
_FL_RFLAT_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage), use FL_RFLAT_BOX
_FL_ROUND_UP_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage), use FL_ROUND_UP_BOX
_FL_ROUND_DOWN_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage), use FL_ROUND_DOWN_BOX
_FL_DIAMOND_UP_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage), use FL_DIAMOND_UP_BOX
_FL_DIAMOND_DOWN_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage), use FL_DIAMOND_DOWN_BOX
_FL_OVAL_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage), use FL_OVAL_BOX
_FL_OSHADOW_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage), use FL_OSHADOW_BOX
_FL_OVAL_FRAME, ///< see figure [Standard Box Types](@ref boxTypesImage), use FL_OVAL_FRAME
_FL_OFLAT_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage), use FL_OFLAT_BOX
_FL_PLASTIC_UP_BOX, ///< plastic version of FL_UP_BOX, use FL_PLASTIC_UP_BOX
_FL_PLASTIC_DOWN_BOX, ///< plastic version of FL_DOWN_BOX, use FL_PLASTIC_DOWN_BOX
_FL_PLASTIC_UP_FRAME, ///< plastic version of FL_UP_FRAME, use FL_PLASTIC_UP_FRAME
_FL_PLASTIC_DOWN_FRAME, ///< plastic version of FL_DOWN_FRAME, use FL_PLASTIC_DOWN_FRAME
_FL_PLASTIC_THIN_UP_BOX, ///< plastic version of FL_THIN_UP_BOX, use FL_PLASTIC_THIN_UP_BOX
_FL_PLASTIC_THIN_DOWN_BOX, ///< plastic version of FL_THIN_DOWN_BOX, use FL_PLASTIC_THIN_DOWN_BOX
_FL_PLASTIC_ROUND_UP_BOX, ///< plastic version of FL_ROUND_UP_BOX, use FL_PLASTIC_ROUND_UP_BOX
_FL_PLASTIC_ROUND_DOWN_BOX, ///< plastic version of FL_ROUND_DOWN_BOX, use FL_PLASTIC_ROUND_DOWN_BOX
_FL_GTK_UP_BOX, ///< gtk+ version of FL_UP_BOX, use FL_GTK_UP_BOX
_FL_GTK_DOWN_BOX, ///< gtk+ version of FL_DOWN_BOX, use FL_GTK_DOWN_BOX
_FL_GTK_UP_FRAME, ///< gtk+ version of FL_UP_FRAME, use FL_GTK_UP_FRAME
_FL_GTK_DOWN_FRAME, ///< gtk+ version of FL_DOWN_FRAME, use FL_GTK_DOWN_FRAME
_FL_GTK_THIN_UP_BOX, ///< gtk+ version of FL_THIN_UP_BOX, use FL_GTK_THIN_UP_BOX
_FL_GTK_THIN_DOWN_BOX, ///< gtk+ version of FL_THIN_DOWN_BOX, use FL_GTK_THIN_DOWN_BOX
_FL_GTK_THIN_UP_FRAME, ///< gtk+ version of FL_THIN_UP_FRAME, use FL_GTK_THIN_UP_FRAME
_FL_GTK_THIN_DOWN_FRAME, ///< gtk+ version of FL_THIN_DOWN_FRAME, use FL_GTK_THIN_DOWN_FRAME
_FL_GTK_ROUND_UP_BOX, ///< gtk+ version of FL_ROUND_UP_BOX, use FL_GTK_ROUND_UP_BOX
_FL_GTK_ROUND_DOWN_BOX, ///< gtk+ version of FL_ROUND_DOWN_BOX, use FL_GTK_ROUND_DOWN_BOX
_FL_GLEAM_UP_BOX, ///< gleam version of FL_UP_BOX, use FL_GLEAM_UP_BOX
_FL_GLEAM_DOWN_BOX, ///< gleam version of FL_DOWN_BOX, use FL_GLEAM_DOWN_BOX
_FL_GLEAM_UP_FRAME, ///< gleam version of FL_UP_FRAME, use FL_GLEAM_UP_FRAME
_FL_GLEAM_DOWN_FRAME, ///< gleam version of FL_DOWN_FRAME, use FL_GLEAM_DOWN_FRAME
_FL_GLEAM_THIN_UP_BOX, ///< gleam version of FL_THIN_UP_BOX, use FL_GLEAM_THIN_UP_BOX
_FL_GLEAM_THIN_DOWN_BOX, ///< gleam version of FL_THIN_DOWN_BOX, use FL_GLEAM_THIN_DOWN_BOX
_FL_GLEAM_ROUND_UP_BOX, ///< gleam version of FL_ROUND_UP_BOX, use FL_GLEAM_ROUND_UP_BOX
_FL_GLEAM_ROUND_DOWN_BOX, ///< gleam version of FL_ROUND_DOWN_BOX, use FL_GLEAM_ROUND_DOWN_BOX
_FL_OXY_UP_BOX, ///< oxy version of FL_UP_BOX, use FL_OXY_UP_BOX
_FL_OXY_DOWN_BOX, ///< oxy version of FL_DOWN_BOX, use FL_OXY_DOWN_BOX
_FL_OXY_UP_FRAME, ///< oxy version of FL_UP_FRAME, use FL_OXY_UP_FRAME
_FL_OXY_DOWN_FRAME, ///< oxy version of FL_DOWN_FRAME, use FL_OXY_DOWN_FRAME
_FL_OXY_THIN_UP_BOX, ///< oxy version of FL_THIN_UP_BOX, use FL_OXY_THIN_UP_BOX
_FL_OXY_THIN_DOWN_BOX, ///< oxy version of FL_THIN_DOWN_BOX, use FL_OXY_THIN_DOWN_BOX
_FL_OXY_THIN_UP_FRAME, ///< oxy version of FL_THIN_UP_FRAME, use FL_OXY_THIN_UP_FRAME
_FL_OXY_THIN_DOWN_FRAME, ///< oxy version of FL_THIN_DOWN_FRAME, use FL_OXY_THIN_DOWN_FRAME
_FL_OXY_ROUND_UP_BOX, ///< oxy version of FL_ROUND_UP_BOX, use FL_OXY_ROUND_UP_BOX
_FL_OXY_ROUND_DOWN_BOX, ///< oxy version of FL_ROUND_DOWN_BOX, use FL_OXY_ROUND_DOWN_BOX
_FL_OXY_BUTTON_UP_BOX, ///< FL_OXY_BUTTON_UP_BOX (new boxtype ?), use FL_OXY_BUTTON_UP_BOX
_FL_OXY_BUTTON_DOWN_BOX, ///< FL_OXY_BUTTON_DOWN_BOX (new boxtype ?), use FL_OXY_BUTTON_DOWN_BOX
FL_FREE_BOXTYPE, ///< the first free box type for creation of new box types
FL_MAX_BOXTYPE = 255 ///< highest legal index for a box type
};
#ifndef FL_DOXYGEN
extern FL_EXPORT Fl_Boxtype fl_define_FL_ROUND_UP_BOX();
#define FL_ROUND_UP_BOX fl_define_FL_ROUND_UP_BOX()
#define FL_ROUND_DOWN_BOX (Fl_Boxtype)(fl_define_FL_ROUND_UP_BOX()+1)
extern FL_EXPORT Fl_Boxtype fl_define_FL_SHADOW_BOX();
#define FL_SHADOW_BOX fl_define_FL_SHADOW_BOX()
#define FL_SHADOW_FRAME (Fl_Boxtype)(fl_define_FL_SHADOW_BOX()+2)
extern FL_EXPORT Fl_Boxtype fl_define_FL_ROUNDED_BOX();
#define FL_ROUNDED_BOX fl_define_FL_ROUNDED_BOX()
#define FL_ROUNDED_FRAME (Fl_Boxtype)(fl_define_FL_ROUNDED_BOX()+2)
extern FL_EXPORT Fl_Boxtype fl_define_FL_RFLAT_BOX();
#define FL_RFLAT_BOX fl_define_FL_RFLAT_BOX()
extern FL_EXPORT Fl_Boxtype fl_define_FL_RSHADOW_BOX();
#define FL_RSHADOW_BOX fl_define_FL_RSHADOW_BOX()
extern FL_EXPORT Fl_Boxtype fl_define_FL_DIAMOND_BOX();
#define FL_DIAMOND_UP_BOX fl_define_FL_DIAMOND_BOX()
#define FL_DIAMOND_DOWN_BOX (Fl_Boxtype)(fl_define_FL_DIAMOND_BOX()+1)
extern FL_EXPORT Fl_Boxtype fl_define_FL_OVAL_BOX();
#define FL_OVAL_BOX fl_define_FL_OVAL_BOX()
#define FL_OSHADOW_BOX (Fl_Boxtype)(fl_define_FL_OVAL_BOX()+1)
#define FL_OVAL_FRAME (Fl_Boxtype)(fl_define_FL_OVAL_BOX()+2)
#define FL_OFLAT_BOX (Fl_Boxtype)(fl_define_FL_OVAL_BOX()+3)
extern FL_EXPORT Fl_Boxtype fl_define_FL_PLASTIC_UP_BOX();
#define FL_PLASTIC_UP_BOX fl_define_FL_PLASTIC_UP_BOX()
#define FL_PLASTIC_DOWN_BOX (Fl_Boxtype)(fl_define_FL_PLASTIC_UP_BOX()+1)
#define FL_PLASTIC_UP_FRAME (Fl_Boxtype)(fl_define_FL_PLASTIC_UP_BOX()+2)
#define FL_PLASTIC_DOWN_FRAME (Fl_Boxtype)(fl_define_FL_PLASTIC_UP_BOX()+3)
#define FL_PLASTIC_THIN_UP_BOX (Fl_Boxtype)(fl_define_FL_PLASTIC_UP_BOX()+4)
#define FL_PLASTIC_THIN_DOWN_BOX (Fl_Boxtype)(fl_define_FL_PLASTIC_UP_BOX()+5)
#define FL_PLASTIC_ROUND_UP_BOX (Fl_Boxtype)(fl_define_FL_PLASTIC_UP_BOX()+6)
#define FL_PLASTIC_ROUND_DOWN_BOX (Fl_Boxtype)(fl_define_FL_PLASTIC_UP_BOX()+7)
extern FL_EXPORT Fl_Boxtype fl_define_FL_GTK_UP_BOX();
#define FL_GTK_UP_BOX fl_define_FL_GTK_UP_BOX()
#define FL_GTK_DOWN_BOX (Fl_Boxtype)(fl_define_FL_GTK_UP_BOX()+1)
#define FL_GTK_UP_FRAME (Fl_Boxtype)(fl_define_FL_GTK_UP_BOX()+2)
#define FL_GTK_DOWN_FRAME (Fl_Boxtype)(fl_define_FL_GTK_UP_BOX()+3)
#define FL_GTK_THIN_UP_BOX (Fl_Boxtype)(fl_define_FL_GTK_UP_BOX()+4)
#define FL_GTK_THIN_DOWN_BOX (Fl_Boxtype)(fl_define_FL_GTK_UP_BOX()+5)
#define FL_GTK_THIN_UP_FRAME (Fl_Boxtype)(fl_define_FL_GTK_UP_BOX()+6)
#define FL_GTK_THIN_DOWN_FRAME (Fl_Boxtype)(fl_define_FL_GTK_UP_BOX()+7)
#define FL_GTK_ROUND_UP_BOX (Fl_Boxtype)(fl_define_FL_GTK_UP_BOX()+8)
#define FL_GTK_ROUND_DOWN_BOX (Fl_Boxtype)(fl_define_FL_GTK_UP_BOX()+9)
extern FL_EXPORT Fl_Boxtype fl_define_FL_GLEAM_UP_BOX();
#define FL_GLEAM_UP_BOX fl_define_FL_GLEAM_UP_BOX()
#define FL_GLEAM_DOWN_BOX (Fl_Boxtype)(fl_define_FL_GLEAM_UP_BOX()+1)
#define FL_GLEAM_UP_FRAME (Fl_Boxtype)(fl_define_FL_GLEAM_UP_BOX()+2)
#define FL_GLEAM_DOWN_FRAME (Fl_Boxtype)(fl_define_FL_GLEAM_UP_BOX()+3)
#define FL_GLEAM_THIN_UP_BOX (Fl_Boxtype)(fl_define_FL_GLEAM_UP_BOX()+4)
#define FL_GLEAM_THIN_DOWN_BOX (Fl_Boxtype)(fl_define_FL_GLEAM_UP_BOX()+5)
#define FL_GLEAM_ROUND_UP_BOX (Fl_Boxtype)(fl_define_FL_GLEAM_UP_BOX()+6)
#define FL_GLEAM_ROUND_DOWN_BOX (Fl_Boxtype)(fl_define_FL_GLEAM_UP_BOX()+7)
extern FL_EXPORT Fl_Boxtype fl_define_FL_OXY_UP_BOX();
#define FL_OXY_UP_BOX fl_define_FL_OXY_UP_BOX()
#define FL_OXY_DOWN_BOX (Fl_Boxtype)(fl_define_FL_OXY_UP_BOX()+1)
#define FL_OXY_UP_FRAME (Fl_Boxtype)(fl_define_FL_OXY_UP_BOX()+2)
#define FL_OXY_DOWN_FRAME (Fl_Boxtype)(fl_define_FL_OXY_UP_BOX()+3)
#define FL_OXY_THIN_UP_BOX (Fl_Boxtype)(fl_define_FL_OXY_UP_BOX()+4)
#define FL_OXY_THIN_DOWN_BOX (Fl_Boxtype)(fl_define_FL_OXY_UP_BOX()+5)
#define FL_OXY_THIN_UP_FRAME (Fl_Boxtype)(fl_define_FL_OXY_UP_BOX()+6)
#define FL_OXY_THIN_DOWN_FRAME (Fl_Boxtype)(fl_define_FL_OXY_UP_BOX()+7)
#define FL_OXY_ROUND_UP_BOX (Fl_Boxtype)(fl_define_FL_OXY_UP_BOX()+8)
#define FL_OXY_ROUND_DOWN_BOX (Fl_Boxtype)(fl_define_FL_OXY_UP_BOX()+9)
#define FL_OXY_BUTTON_UP_BOX (Fl_Boxtype)(fl_define_FL_OXY_UP_BOX()+10)
#define FL_OXY_BUTTON_DOWN_BOX (Fl_Boxtype)(fl_define_FL_OXY_UP_BOX()+11)
#endif // ! FL_DOXYGEN
// conversions of box types to other boxtypes:
/**
Get the filled version of a frame.
If no filled version of a given frame exists, the behavior of this function
is undefined and some random box or frame is returned.
*/
inline Fl_Boxtype fl_box(Fl_Boxtype b) {
return (Fl_Boxtype)((b<FL_UP_BOX||b%4>1)?b:(b-2));
}
/**
Get the "pressed" or "down" version of a box.
If no "down" version of a given box exists, the behavior of this function
is undefined and some random box or frame is returned.
*/
inline Fl_Boxtype fl_down(Fl_Boxtype b) {
return (Fl_Boxtype)((b<FL_UP_BOX)?b:(b|1));
}
/**
Get the unfilled, frame only version of a box.
If no frame version of a given box exists, the behavior of this function
is undefined and some random box or frame is returned.
*/
inline Fl_Boxtype fl_frame(Fl_Boxtype b) {
return (Fl_Boxtype)((b%4<2)?b:(b+2));
}
// back-compatibility box types:
#define FL_FRAME FL_ENGRAVED_FRAME
#define FL_FRAME_BOX FL_ENGRAVED_BOX
#define FL_CIRCLE_BOX FL_ROUND_DOWN_BOX
#define FL_DIAMOND_BOX FL_DIAMOND_DOWN_BOX
/**@}*/ // group: Box Types
/**
The labeltype() method sets the type of the label.
\note The documented \p enum \p Fl_Labeltype contains some values (names)
with leading underscores, e.g. \p \b _FL_IMAGE_LABEL. This is due to
technical reasons - please use the same values (names) without the
leading underscore in your code! Enum values with leading underscores
are reserved for internal use and subject to change without notice!
The following standard label types are included:
*/
enum Fl_Labeltype { // labeltypes:
FL_NORMAL_LABEL = 0, ///< draws the text (0)
FL_NO_LABEL, ///< does nothing
_FL_SHADOW_LABEL, ///< draws a drop shadow under the text
_FL_ENGRAVED_LABEL, ///< draws edges as though the text is engraved
_FL_EMBOSSED_LABEL, ///< draws edges as though the text is raised
_FL_MULTI_LABEL, ///< draws a composite label \see Fl_Multi_Label
_FL_ICON_LABEL, ///< draws the icon associated with the text
_FL_IMAGE_LABEL, ///< the label displays an "icon" based on a Fl_Image
FL_FREE_LABELTYPE ///< first free labeltype to use for creating own labeltypes
};
/**
Sets the current label type and returns its corresponding Fl_Labeltype value.
@{
*/
/** FL_SYMBOL_LABEL is an alias for FL_NORMAL_LABEL.
'@' symbols can be drawn with normal labels as well.\n
This definition is for historical reasons only (forms compatibility).
You should use FL_NORMAL_LABEL instead.
*/
#define FL_SYMBOL_LABEL FL_NORMAL_LABEL
/**
Initializes the internal table entry for FL_SHADOW_LABEL and returns
its internal value. Internal use only.
*/
extern Fl_Labeltype FL_EXPORT fl_define_FL_SHADOW_LABEL();
/**
Draws a label with shadows behind the text.
*/
#define FL_SHADOW_LABEL fl_define_FL_SHADOW_LABEL()
/**
Initializes the internal table entry for FL_ENGRAVED_LABEL and returns
its internal value. Internal use only.
*/
extern Fl_Labeltype FL_EXPORT fl_define_FL_ENGRAVED_LABEL();
/**
Draws a label with engraved text.
*/
#define FL_ENGRAVED_LABEL fl_define_FL_ENGRAVED_LABEL()
/**
Initializes the internal table entry for FL_EMBOSSED_LABEL and returns
its internal value. Internal use only.
*/
extern Fl_Labeltype FL_EXPORT fl_define_FL_EMBOSSED_LABEL();
/**
Draws a label with embossed text.
*/
#define FL_EMBOSSED_LABEL fl_define_FL_EMBOSSED_LABEL()
/**
Initializes the internal table entry for FL_MULTI_LABEL and returns
its internal value. Internal use only.
*/
extern Fl_Labeltype FL_EXPORT fl_define_FL_MULTI_LABEL();
/**
Draws a label that can comprise several parts like text and images.
\see Fl_Multi_Label
*/
#define FL_MULTI_LABEL fl_define_FL_MULTI_LABEL()
/**
Initializes the internal table entry for FL_ICON_LABEL and returns
its internal value. Internal use only.
*/
extern Fl_Labeltype FL_EXPORT fl_define_FL_ICON_LABEL();
/**
Draws an icon as the label.
*/
#define FL_ICON_LABEL fl_define_FL_ICON_LABEL()
/**
Initializes the internal table entry for FL_IMAGE_LABEL and returns
its internal value. Internal use only.
*/
extern Fl_Labeltype FL_EXPORT fl_define_FL_IMAGE_LABEL();
/**
Draws an image (Fl_Image) as the label.
This is useful for one particular part of an Fl_Multi_Label.
Use Fl_Widget::image() and/or Fl_Widget::deimage() for normal widgets
with images as labels.
*/
#define FL_IMAGE_LABEL fl_define_FL_IMAGE_LABEL()
/** @} */
/** \name Alignment Flags
Flags to control the label alignment.
This controls how the label is displayed next to or inside the widget.
The default value is FL_ALIGN_CENTER (0) for most widgets, which centers
the label inside the widget.
All alignment flags use the common prefix "FL_ALIGN_". In the following
descriptions this prefix is sometimes omitted for brevity.
Flags can be or'd to achieve a combination of alignments, but there
are some \e "magic values" (e.g. combinations of TOP and BOTTOM and of
LEFT and RIGHT) that have special meanings (see below). For instance:\n
FL_ALIGN_TOP_LEFT == (FL_ALIGN_TOP | FL_ALIGN_LEFT) != FL_ALIGN_LEFT_TOP.
\code
Outside alignments (FL_ALIGN_INSIDE is not set):
TOP_LEFT TOP TOP_RIGHT
+---------------------------------+
LEFT_TOP| |RIGHT_TOP
| |
LEFT| CENTER |RIGHT
| |
LEFT_BOTTOM| |RIGHT_BOTTOM
+---------------------------------+
BOTTOM_LEFT BOTTOM BOTTOM_RIGHT
Inside alignments (FL_ALIGN_INSIDE is set):
+---------------------------------+
|TOP_LEFT TOP TOP_RIGHT|
| |
|LEFT CENTER RIGHT|
| |
|BOTTOM_LEFT BOTTOM BOTTOM_RIGHT|
+---------------------------------+
\endcode
\see Fl_Align, #FL_ALIGN_CENTER, etc.
\note
-# Bit positions not defined in the following constants of type
\p Fl_Align are reserved for future extensions. Do not use.
-# The \e "magic values" (FL_ALIGN_)LEFT_TOP, RIGHT_TOP, LEFT_BOTTOM,
and RIGHT_BOTTOM must not be used together with FL_ALIGN_INSIDE.
Use TOP_LEFT, TOP_RIGHT, BOTTOM_LEFT, or BOTTOM_RIGHT instead.
-# Although bits can be or'd together there are some unused/illegal
combinations, for instance:
- setting both FL_ALIGN_TOP and FL_ALIGN_BOTTOM in combinations other
than those given in the \p Fl_Align constants below (magic values)
- setting both FL_ALIGN_LEFT and FL_ALIGN_RIGHT in combinations other
than those given in the \p Fl_Align constants below (magic values)
- using one of the "magic values" (2) together with FL_ALIGN_INSIDE
\note
Using illegal bit combinations or undefined bits may yield unexpected
behavior, and this behavior may be changed without notice in future
FLTK versions.
*/
/**@{*/
/** FLTK type for alignment control. */
typedef unsigned Fl_Align;
/** Align the label horizontally in the middle. */
const Fl_Align FL_ALIGN_CENTER = 0x0000;
/** Align the label at the top of the widget. Inside labels appear below the top,
outside labels are drawn on top of the widget. */
const Fl_Align FL_ALIGN_TOP = 0x0001;
/** Align the label at the bottom of the widget. */
const Fl_Align FL_ALIGN_BOTTOM = 0x0002;
/** Align the label at the left of the widget. Inside labels appear left-justified
starting at the left side of the widget, outside labels are right-justified and
drawn to the left of the widget. */
const Fl_Align FL_ALIGN_LEFT = 0x0004;
/** Align the label to the right of the widget. */
const Fl_Align FL_ALIGN_RIGHT = 0x0008;
/** Draw the label inside of the widget. */
const Fl_Align FL_ALIGN_INSIDE = 0x0010;
/** If the label contains an image, draw the text on top of the image. */
const Fl_Align FL_ALIGN_TEXT_OVER_IMAGE = 0x0020;
/** If the label contains an image, draw the text below the image. */
const Fl_Align FL_ALIGN_IMAGE_OVER_TEXT = 0x0000;
/** All parts of the label that are larger than the widget will not be drawn. */
const Fl_Align FL_ALIGN_CLIP = 0x0040;
/** Wrap text that does not fit the width of the widget. */
const Fl_Align FL_ALIGN_WRAP = 0x0080;
/** If the label contains an image, draw the text to the right of the image. */
const Fl_Align FL_ALIGN_IMAGE_NEXT_TO_TEXT = 0x0100;
/** If the label contains an image, draw the text to the left of the image. */
const Fl_Align FL_ALIGN_TEXT_NEXT_TO_IMAGE = 0x0120;
/** If the label contains an image, draw the image or deimage in the background. */
const Fl_Align FL_ALIGN_IMAGE_BACKDROP = 0x0200;
const Fl_Align FL_ALIGN_TOP_LEFT = FL_ALIGN_TOP | FL_ALIGN_LEFT;
const Fl_Align FL_ALIGN_TOP_RIGHT = FL_ALIGN_TOP | FL_ALIGN_RIGHT;
const Fl_Align FL_ALIGN_BOTTOM_LEFT = FL_ALIGN_BOTTOM | FL_ALIGN_LEFT;
const Fl_Align FL_ALIGN_BOTTOM_RIGHT = FL_ALIGN_BOTTOM | FL_ALIGN_RIGHT;
/** Outside only, left of widget, top position, magic value: TOP | BOTTOM | LEFT. */
const Fl_Align FL_ALIGN_LEFT_TOP = 0x0007;
/** Outside only, right of widget, top position, magic value: TOP | BOTTOM | RIGHT. */
const Fl_Align FL_ALIGN_RIGHT_TOP = 0x000b;
/** Outside only, left of widget, bottom position, magic value: TOP | LEFT | RIGHT. */
const Fl_Align FL_ALIGN_LEFT_BOTTOM = 0x000d;
/** Outside only, right of widget, bottom position, magic value: BOTTOM | LEFT | RIGHT. */
const Fl_Align FL_ALIGN_RIGHT_BOTTOM = 0x000e;
/** Nothing, same as FL_ALIGN_CENTER, for back compatibility. */
const Fl_Align FL_ALIGN_NOWRAP = 0x0000;
/** Mask value to test for TOP, BOTTOM, LEFT, and RIGHT flags. */
const Fl_Align FL_ALIGN_POSITION_MASK = 0x000f;
/** Mask value to test for image alignment flags. */
const Fl_Align FL_ALIGN_IMAGE_MASK = 0x0320;
/**@}*/
/** \name Font Numbers
The following constants define the standard FLTK fonts:
*/
/**@{*/
/** A font number is an index into the internal font table. */
typedef int Fl_Font;
const Fl_Font FL_HELVETICA = 0; ///< Helvetica (or Arial) normal (0)
const Fl_Font FL_HELVETICA_BOLD = 1; ///< Helvetica (or Arial) bold
const Fl_Font FL_HELVETICA_ITALIC = 2; ///< Helvetica (or Arial) oblique
const Fl_Font FL_HELVETICA_BOLD_ITALIC = 3; ///< Helvetica (or Arial) bold-oblique
const Fl_Font FL_COURIER = 4; ///< Courier normal
const Fl_Font FL_COURIER_BOLD = 5; ///< Courier bold
const Fl_Font FL_COURIER_ITALIC = 6; ///< Courier italic
const Fl_Font FL_COURIER_BOLD_ITALIC = 7; ///< Courier bold-italic
const Fl_Font FL_TIMES = 8; ///< Times roman
const Fl_Font FL_TIMES_BOLD = 9; ///< Times roman bold
const Fl_Font FL_TIMES_ITALIC = 10; ///< Times roman italic
const Fl_Font FL_TIMES_BOLD_ITALIC = 11; ///< Times roman bold-italic
const Fl_Font FL_SYMBOL = 12; ///< Standard symbol font
const Fl_Font FL_SCREEN = 13; ///< Default monospaced screen font
const Fl_Font FL_SCREEN_BOLD = 14; ///< Default monospaced bold screen font
const Fl_Font FL_ZAPF_DINGBATS = 15; ///< Zapf-dingbats font
const Fl_Font FL_FREE_FONT = 16; ///< first one to allocate
const Fl_Font FL_BOLD = 1; ///< add this to Helvetica, Courier, or Times
const Fl_Font FL_ITALIC = 2; ///< add this to Helvetica, Courier, or Times
const Fl_Font FL_BOLD_ITALIC = 3; ///< add this to Helvetica, Courier, or Times
/**@}*/
/** Size of a font in pixels.
This is the approximate height of a font in pixels.
*/
typedef int Fl_Fontsize;
extern FL_EXPORT Fl_Fontsize FL_NORMAL_SIZE; ///< normal font size
/** \name Colors
The Fl_Color type holds an FLTK color value.
Colors are either 8-bit indexes into a <a href="fltk-colormap.png">virtual colormap</a>
or 24-bit RGB color values. (See \ref drawing_colors for the default FLTK colormap)
Color indices occupy the lower 8 bits of the value, while
RGB colors occupy the upper 24 bits, for a byte organization of RGBI.
<pre>
Fl_Color => 0xrrggbbii
| | | |
| | | +--- \ref drawing_colors "index" between 0 and 255
| | +----- blue color component (8 bit)
| +------- green component (8 bit)
+--------- red component (8 bit)
</pre>
A color can have either an index or an rgb value. Colors with rgb set
and an index >0 are reserved for special use.
*/
/**@{*/
/** An FLTK color value; see also \ref drawing_colors */
typedef unsigned int Fl_Color;
// Standard colors. These are used as default colors in widgets and altered as necessary
const Fl_Color FL_FOREGROUND_COLOR = 0; ///< the default foreground color (0) used for labels and text
const Fl_Color FL_BACKGROUND2_COLOR = 7; ///< the default background color for text, list, and valuator widgets
const Fl_Color FL_INACTIVE_COLOR = 8; ///< the inactive foreground color
const Fl_Color FL_SELECTION_COLOR = 15; ///< the default selection/highlight color
// boxtypes generally limit themselves to these colors so
// the whole ramp is not allocated:
const Fl_Color FL_GRAY0 = 32; // 'A'
const Fl_Color FL_DARK3 = 39; // 'H'
const Fl_Color FL_DARK2 = 45; // 'N'
const Fl_Color FL_DARK1 = 47; // 'P'
/** Default background color */
const Fl_Color FL_BACKGROUND_COLOR = 49; // 'R' default background color
const Fl_Color FL_LIGHT1 = 50; // 'S'
const Fl_Color FL_LIGHT2 = 52; // 'U'
const Fl_Color FL_LIGHT3 = 54; // 'W'
// FLTK provides a 5x8x5 color cube that is used with colormap visuals
const Fl_Color FL_BLACK = 56;
const Fl_Color FL_RED = 88;
const Fl_Color FL_GREEN = 63;
const Fl_Color FL_YELLOW = 95;
const Fl_Color FL_BLUE = 216;
const Fl_Color FL_MAGENTA = 248;
const Fl_Color FL_CYAN = 223;
const Fl_Color FL_DARK_RED = 72;
const Fl_Color FL_DARK_GREEN = 60;
const Fl_Color FL_DARK_YELLOW = 76;
const Fl_Color FL_DARK_BLUE = 136;
const Fl_Color FL_DARK_MAGENTA = 152;
const Fl_Color FL_DARK_CYAN = 140;
const Fl_Color FL_WHITE = 255;
/** Colors numbered between FL_FREE_COLOR and FL_FREE_COLOR + FL_NUM_FREE_COLOR - 1
are free for the user to be given any value using Fl::set_color(). */
#define FL_FREE_COLOR (Fl_Color)16
#define FL_NUM_FREE_COLOR 16
#define FL_GRAY_RAMP (Fl_Color)32
#define FL_NUM_GRAY 24
#define FL_GRAY FL_BACKGROUND_COLOR
#define FL_COLOR_CUBE (Fl_Color)56
#define FL_NUM_RED 5
#define FL_NUM_GREEN 8
#define FL_NUM_BLUE 5
FL_EXPORT Fl_Color fl_inactive(Fl_Color c);
/**
Type of a custom fl_contrast() function.
Use this signature to define your own custom fl_contrast() function together
with fl_contrast_mode(FL_CONTRAST_CUSTOM).
Example:
\code
Fl_Color my_contrast(Fl_Color fg, Fl_Color bg, int context, int size) {
// calculate contrast and ...
return color;
}
// call this early in your main() program:
fl_contrast_function(my_contrast);
fl_contrast_mode(FL_CONTRAST_CUSTOM);
fl_contrast_level(50); // optional, must be called after fl_contrast_mode()
\endcode
For parameters and types see fl_contrast(Fl_Color, Fl_Color, int, int).
\see fl_contrast(Fl_Color, Fl_Color, int, int)
\see fl_contrast_mode(int)
*/
typedef Fl_Color (Fl_Contrast_Function)(Fl_Color, Fl_Color, int, int);
FL_EXPORT void fl_contrast_function(Fl_Contrast_Function *f);
/**
Define the possible modes to calculate fl_contrast().
*/
enum Fl_Contrast_Mode {
FL_CONTRAST_NONE = 0, ///< always return foreground color
FL_CONTRAST_LEGACY, ///< legacy (FLTK 1.3.x) contrast function
FL_CONTRAST_CIELAB, ///< new (FLTK 1.4.0) default function
FL_CONTRAST_CUSTOM, ///< optional custom contrast function
FL_CONTRAST_LAST ///< internal use only (invalid contrast mode)
};
// The following functions are defined and documented in src/fl_contrast.cxx
FL_EXPORT void fl_contrast_level(int level);
FL_EXPORT int fl_contrast_level();
FL_EXPORT void fl_contrast_mode(int mode);
FL_EXPORT int fl_contrast_mode();
FL_EXPORT Fl_Color fl_contrast(Fl_Color fg, Fl_Color bg, int context = 0, int size = 0);
FL_EXPORT double fl_lightness(Fl_Color color);
FL_EXPORT double fl_luminance(Fl_Color color);
// Other color functions are defined and documented in src/fl_color.cxx
FL_EXPORT Fl_Color fl_color_average(Fl_Color c1, Fl_Color c2, float weight);
/** Returns a lighter version of the specified color. */
inline Fl_Color fl_lighter(Fl_Color c) { return fl_color_average(c, FL_WHITE, .67f); }
/** Returns a darker version of the specified color. */
inline Fl_Color fl_darker(Fl_Color c) { return fl_color_average(c, FL_BLACK, .67f); }
/** Returns the 24-bit color value closest to \p r, \p g, \p b. */
inline Fl_Color fl_rgb_color(uchar r, uchar g, uchar b) {
if (!r && !g && !b) return FL_BLACK;
else return (Fl_Color)(((((r << 8) | g) << 8) | b) << 8);
}
/** Returns the 24-bit color value closest to \p g (grayscale). */
inline Fl_Color fl_rgb_color(uchar g) {
if (!g) return FL_BLACK;
else return (Fl_Color)(((((g << 8) | g) << 8) | g) << 8);
}
/** Returns a gray color value from black (i == 0) to white (i == FL_NUM_GRAY - 1).
FL_NUM_GRAY is defined to be 24 in the current FLTK release.
To get the closest FLTK gray value to an 8-bit grayscale color 'I' use:
\code
fl_gray_ramp(I * (FL_NUM_GRAY - 1) / 255)
\endcode
*/
inline Fl_Color fl_gray_ramp(int i) {return (Fl_Color)(i+FL_GRAY_RAMP);}
/** Returns a color out of the color cube.
\p r must be in the range 0 to FL_NUM_RED (5) minus 1,
\p g must be in the range 0 to FL_NUM_GREEN (8) minus 1,
\p b must be in the range 0 to FL_NUM_BLUE (5) minus 1.
To get the closest color to a 8-bit set of R,G,B values use:
\code
fl_color_cube(R * (FL_NUM_RED - 1) / 255,
G * (FL_NUM_GREEN - 1) / 255,
B * (FL_NUM_BLUE - 1) / 255);
\endcode
*/
inline Fl_Color fl_color_cube(int r, int g, int b) {
return (Fl_Color)((b*FL_NUM_RED + r) * FL_NUM_GREEN + g + FL_COLOR_CUBE);}
/**@}*/ // group: Colors
/** \name Cursors */
/**@{*/
/** The following constants define the mouse cursors that are available in FLTK.
Cursors are provided by the system when available, or bitmaps built into
FLTK as a fallback.
*/
/* FIXME: We should renumber these, but that will break the ABI */
enum Fl_Cursor {
FL_CURSOR_DEFAULT = 0, /**< the default cursor, usually an arrow: ↖*/ // U+2196
FL_CURSOR_ARROW = 35, /**< an arrow pointer: ↖*/ // U+2196
FL_CURSOR_CROSS = 66, /**< crosshair: ＋*/ // U+FF0B
FL_CURSOR_WAIT = 76, /**< busy indicator (for instance hourglass): ⌚,⌛*/ // U+231A, U+231B
FL_CURSOR_INSERT = 77, /**< I-beam: ⌶*/ // U+2336
FL_CURSOR_HAND = 31, /**< pointing hand: ☜*/ // U+261C
FL_CURSOR_HELP = 47, /**< question mark pointer: ?*/
FL_CURSOR_MOVE = 27, /**< 4-pointed arrow or hand: ✥, ✋*/ // U+2725, U+270B
/* Resize indicators */
FL_CURSOR_NS = 78, /**< up/down resize: ⇕ */ // U+21D5
FL_CURSOR_WE = 79, /**< left/right resize: ⇔*/ // U+21D4
FL_CURSOR_NWSE = 80, /**< diagonal resize: ⤡*/ // U+2921
FL_CURSOR_NESW = 81, /**< diagonal resize: ⤢*/ // U+2922
FL_CURSOR_N = 70, /**< upwards resize: ⤒*/ // U+2912
FL_CURSOR_NE = 69, /**< upwards, right resize: ↗*/ // U+2197
FL_CURSOR_E = 49, /**< rightwards resize: ⇥*/ // U+21E5
FL_CURSOR_SE = 8, /**< downwards, right resize: ⇲*/ // U+21F2
FL_CURSOR_S = 9, /**< downwards resize: ⤓*/ // U+2913
FL_CURSOR_SW = 7, /**< downwards, left resize: ↙*/ // U+2199
FL_CURSOR_W = 36, /**< leftwards resize: ⇤*/ // U+21E4
FL_CURSOR_NW = 68, /**< upwards, left resize: ⇱*/ // U+21F1
FL_CURSOR_NONE =255 /**< invisible. */
};
/**@}*/ // group: Cursors
/** FD "when" conditions */
enum { // values for "when" passed to Fl::add_fd()
FL_READ = 1, /**< Call the callback when there is data to be read. */
FL_WRITE = 4, /**< Call the callback when data can be written without blocking. */
FL_EXCEPT = 8 /**< Call the callback if an exception occurs on the file. */
};
/** visual types and Fl_Gl_Window::mode() (values match Glut) */
enum Fl_Mode {
FL_RGB = 0,
FL_INDEX = 1,
FL_SINGLE = 0,
FL_DOUBLE = 2,
FL_ACCUM = 4,
FL_ALPHA = 8,
FL_DEPTH = 16,
FL_STENCIL = 32,
FL_RGB8 = 64,
FL_MULTISAMPLE= 128,
FL_STEREO = 256,
FL_FAKE_SINGLE = 512, // Fake single buffered windows using double-buffer
FL_OPENGL3 = 1024
};
// image alpha blending
#define FL_IMAGE_WITH_ALPHA 0x40000000
/** Damage masks */
enum Fl_Damage {
FL_DAMAGE_CHILD = 0x01, /**< A child needs to be redrawn. */
FL_DAMAGE_EXPOSE = 0x02, /**< The window was exposed. */
FL_DAMAGE_SCROLL = 0x04, /**< The Fl_Scroll widget was scrolled. Used by other widgets for other widget specific damages. */
FL_DAMAGE_OVERLAY = 0x08, /**< The overlay planes need to be redrawn. */
FL_DAMAGE_USER1 = 0x10, /**< First user-defined damage bit. */
FL_DAMAGE_USER2 = 0x20, /**< Second user-defined damage bit. */
FL_DAMAGE_ALL = 0x80 /**< Everything needs to be redrawn. */
};
// FLTK 1.0.x compatibility definitions (FLTK_1_0_COMPAT) dropped in 1.4.0
/** Arrow types define the type of arrow drawing function.
FLTK schemes can draw several graphical elements in their particular way.
One of these elements is an arrow type that can be in different GUI
elements like scrollbars, choice buttons, and FLTK's Fl_Return_Button.
\note This enum is not yet stable (as of FLTK 1.4.0) and may be changed
without notice as necessary.
\since 1.4.0
*/
enum Fl_Arrow_Type {
FL_ARROW_SINGLE = 0x01, ///< Single arrow, e.g. in Fl_Scrollbar
FL_ARROW_DOUBLE = 0x02, ///< Double arrow, e.g. in Fl_Counter
FL_ARROW_CHOICE = 0x03, ///< Dropdown box, e.g. in Fl_Choice
FL_ARROW_RETURN = 0x04 ///< Return arrow, e.g. in Fl_Return_Button
};
/** Fl_Orientation describes the orientation of a GUI element.
FLTK schemes can draw several graphical elements, for instance arrows,
pointing at different directions. This enum defines the direction
to use for drawing a particular GUI element.
The definition of this enum was chosen such that the enum value can
be multiplied by 45 to get a rotation angle in degrees starting
at the horizontal axis (0 = right, 1 = NE, 2 = up, ...) that can be
used with fl_rotate(). Note: angle is counter-clockwise in degrees.
The 'unspecified' value \b FL_ORIENT_NONE shall be used for elements
that would usually not be rotated, like the return arrow of the
Fl_Return_Button. It can still be used as an angle though since it is
the same value as \p FL_ORIENT_RIGHT (0 degrees).
\note This enum is not yet stable (as of FLTK 1.4.0) and may be changed
without notice as necessary.
\since 1.4.0
*/
enum Fl_Orientation {
FL_ORIENT_NONE = 0x00, ///< GUI element direction is unspecified
FL_ORIENT_RIGHT = 0x00, ///< GUI element pointing right ( 0°)
FL_ORIENT_NE = 0x01, ///< GUI element pointing NE ( 45°)
FL_ORIENT_UP = 0x02, ///< GUI element pointing up ( 90°)
FL_ORIENT_NW = 0x03, ///< GUI element pointing NW (135°)
FL_ORIENT_LEFT = 0x04, ///< GUI element pointing left (180°)
FL_ORIENT_SW = 0x05, ///< GUI element pointing SW (225°)
FL_ORIENT_DOWN = 0x06, ///< GUI element pointing down (270°)
FL_ORIENT_SE = 0x07 ///< GUI element pointing SE (315°)
};
#endif
================================================
FILE: Game Trainers/common/include/FL/Fl.H
================================================
//
// Main header file for the Fast Light Tool Kit (FLTK).
//
// Copyright 1998-2024 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/Fl.H
\brief Fl static class.
*/
#ifndef Fl_H
# define Fl_H
#include <FL/fl_config.h> // build configuration
#include <FL/Fl_Export.H>
#include <FL/platform_types.h> // for FL_SOCKET
#include <FL/fl_casts.H> // experimental
#ifdef FLTK_HAVE_CAIRO
# include <FL/Fl_Cairo.H>
#endif
# include "fl_utf8.h"
# include "Enumerations.H"
# ifndef Fl_Object
# define Fl_Object Fl_Widget /**< for back compatibility - use Fl_Widget! */
# endif
# ifdef check
# undef check
# endif
# ifdef BSD
# undef BSD
# endif
#include <string.h> // FIXME: Fl::is_scheme(): strcmp needs string.h
class Fl_Widget;
class Fl_Window;
class Fl_Image;
struct Fl_Label;
class Fl_Screen_Driver;
class Fl_System_Driver;
// Pointers you can use to change FLTK to another language.
// Note: Similar pointers are defined in FL/fl_ask.H and src/fl_ask.cxx
extern FL_EXPORT const char* fl_local_alt; ///< string pointer used in shortcuts, you can change it to another language
extern FL_EXPORT const char* fl_local_ctrl; ///< string pointer used in shortcuts, you can change it to another language
extern FL_EXPORT const char* fl_local_meta; ///< string pointer used in shortcuts, you can change it to another language
extern FL_EXPORT const char* fl_local_shift; ///< string pointer used in shortcuts, you can change it to another language
/** \defgroup callback_functions Callback Function Typedefs
\brief Typedefs defined in <FL/Fl.H> for callback or handler functions passed as function parameters.
FLTK uses callback functions as parameters for some function calls, e.g. to
set up global event handlers (Fl::add_handler()), to add a timeout handler
(Fl::add_timeout()), and many more.
The typedefs defined in this group describe the function parameters used to set
up or clear the callback functions and should also be referenced to define the
callback function to handle such events in the user's code.
\see Fl::add_handler(), Fl::add_timeout(), Fl::repeat_timeout(),
Fl::remove_timeout() and others
@{
*/
/** Signature of some label drawing functions passed as parameters */
typedef void (Fl_Label_Draw_F)(const Fl_Label *label, int x, int y, int w, int h, Fl_Align align);
/** Signature of some label measurement functions passed as parameters */
typedef void (Fl_Label_Measure_F)(const Fl_Label *label, int &width, int &height);
/** Signature of some box drawing functions passed as parameters */
typedef void (Fl_Box_Draw_F)(int x, int y, int w, int h, Fl_Color color);
/** Signature of box focus frame drawing functions */
typedef void (Fl_Box_Draw_Focus_F)(Fl_Boxtype bt, int x, int y, int w, int h, Fl_Color fg, Fl_Color bg);
/** Signature of timeout callback functions passed as parameters.
Please see Fl::add_timeout() for details.
*/
typedef void (*Fl_Timeout_Handler)(void *data);
/** Signature of some wakeup callback functions passed as parameters */
typedef void (*Fl_Awake_Handler)(void *data);
/** Signature of add_idle callback functions passed as parameters */
typedef void (*Fl_Idle_Handler)(void *data);
/** Signature of set_idle callback functions passed as parameters */
typedef void (*Fl_Old_Idle_Handler)();
/** Signature of add_fd functions passed as parameters */
typedef void (*Fl_FD_Handler)(FL_SOCKET fd, void *data);
/** Signature of add_handler functions passed as parameters */
typedef int (*Fl_Event_Handler)(int event);
/** Signature of add_system_handler functions passed as parameters */
typedef int (*Fl_System_Handler)(void *event, void *data);
/** Signature of set_abort functions passed as parameters */
typedef void (*Fl_Abort_Handler)(const char *format,...);
/** Signature of set_atclose functions passed as parameters */
typedef void (*Fl_Atclose_Handler)(Fl_Window *window, void *data);
/** Signature of args functions passed as parameters */
typedef int (*Fl_Args_Handler)(int argc, char **argv, int &i);
/** Signature of event_dispatch functions passed as parameters.
\see Fl::event_dispatch(Fl_Event_Dispatch) */
typedef int (*Fl_Event_Dispatch)(int event, Fl_Window *w);
/** Signature of add_clipboard_notify functions passed as parameters */
typedef void (*Fl_Clipboard_Notify_Handler)(int source, void *data);
/** @} */ /* group callback_functions */
/**
The Fl is the FLTK global (static) class containing
state information and global methods for the current application.
*/
class FL_EXPORT Fl {
friend class Fl_System_Driver;
Fl() {} // no constructor!
private:
static int use_high_res_GL_;
static int draw_GL_text_with_textures_;
static int box_shadow_width_;
static int box_border_radius_max_;
static int selection_to_clipboard_;
public:
static Fl_Screen_Driver *screen_driver();
static Fl_System_Driver *system_driver();
#ifdef __APPLE__ // deprecated in 1.4 - only for compatibility with 1.3
static void reset_marked_text();
static void insertion_point_location(int x, int y, int height);
#endif
/** Get the box shadow width of all "shadow" boxtypes in pixels.
\since 1.4.0
*/
static int box_shadow_width() { return box_shadow_width_; }
/** Set the box shadow width of all "shadow" boxtypes in pixels.
Must be at least 1, default = 3. There is no upper limit.
\since 1.4.0
*/
static void box_shadow_width(int W) { box_shadow_width_ = W < 1 ? 1 : W; }
/** Get the maximum border radius of all "rounded" boxtypes in pixels.
\since 1.4.0
*/
static int box_border_radius_max() { return box_border_radius_max_; }
/** Set the maximum border radius of all "rounded" boxtypes in pixels.
Must be at least 5, default = 15.
\note This does \b not apply to the "round" boxtypes which have really round sides
(i.e. composed of half circles) as opposed to "rounded" boxtypes that have only
rounded corners with a straight border between corners.
The box border radius of "rounded" boxtypes is typically calculated as about 2/5 of
the box height or width, whichever is smaller. The upper limit can be set by this
method for all "rounded" boxtypes.
\since 1.4.0
*/
static void box_border_radius_max(int R) { box_border_radius_max_ = R < 5 ? 5 : R; }
public: // should be private!
#ifndef FL_DOXYGEN
static int e_number;
static int e_x;
static int e_y;
static int e_x_root;
static int e_y_root;
static int e_dx;
static int e_dy;
static int e_state;
static int e_clicks;
static int e_is_click;
static int e_keysym;
static char* e_text;
static int e_length;
static void *e_clipboard_data;
static const char *e_clipboard_type;
static Fl_Event_Dispatch e_dispatch;
static Fl_Callback_Reason callback_reason_;
static Fl_Widget* belowmouse_;
static Fl_Widget* pushed_;
static Fl_Widget* focus_;
static int damage_;
static Fl_Widget* selection_owner_;
static Fl_Window* modal_;
static Fl_Window* grab_;
static int compose_state; // used for dead keys (Windows) or marked text (MacOS)
static void call_screen_init(); // recompute screen number and dimensions
#endif // FL_DOXYGEN
/**
If true then flush() will do something.
*/
static void damage(int d) {damage_ = d;}
public:
/** Enumerator for global FLTK options.
These options can be set system wide, per user, or for the running
application only.
\see Fl::option(Fl_Option, bool)
\see Fl::option(Fl_Option)
*/
typedef enum {
/// When switched on, moving the text cursor beyond the start or end of
/// a text in a text widget will change focus to the next text widget.
/// (This is considered 'old' behavior)
///
/// When switched off (default), the cursor will stop at the end of the text.
/// Pressing Tab or Ctrl-Tab will advance the keyboard focus.
///
/// See also: Fl_Input_::tab_nav()
///
OPTION_ARROW_FOCUS = 0,
// When switched on, FLTK will use the file chooser dialog that comes
// with your operating system whenever possible. When switched off, FLTK
// will present its own file chooser.
// \todo implement me
// OPTION_NATIVE_FILECHOOSER,
// When Filechooser Preview is enabled, the FLTK or native file chooser
// will show a preview of a selected file (if possible) before the user
// decides to choose the file.
// \todo implement me
//OPTION_FILECHOOSER_PREVIEW,
/// If visible focus is switched on (default), FLTK will draw a dotted rectangle
/// inside the widget that will receive the next keystroke. If switched
/// off, no such indicator will be drawn and keyboard navigation
/// is disabled.
OPTION_VISIBLE_FOCUS,
/// If text drag-and-drop is enabled (default), the user can select and drag text
/// from any text widget. If disabled, no dragging is possible, however
/// dropping text from other applications still works.
OPTION_DND_TEXT,
/// If tooltips are enabled (default), hovering the mouse over a widget with a
/// tooltip text will open a little tooltip window until the mouse leaves
/// the widget. If disabled, no tooltip is shown.
OPTION_SHOW_TOOLTIPS,
/// When switched on (default), Fl_Native_File_Chooser runs GTK file dialogs
/// if the GTK library is available on the platform (linux/unix only).
/// When switched off, GTK file dialogs aren't used even if the GTK library is available.
OPTION_FNFC_USES_GTK,
/// Meaningful for the Wayland/X11 platform only. When switched on, the library uses a Zenity-based file dialog.
/// When switched off (default), no zenity-based file dialog is used.
OPTION_FNFC_USES_ZENITY,
/// Meaningful for the Wayland/X11 platform only.
/// When switched on, the library uses a kdialog-based file dialog if command 'kdialog' is available on the running system.
/// When switched off (default), no kdialog-based file dialog is used.
OPTION_FNFC_USES_KDIALOG,
/// When switched on (default), Fl_Printer runs the GTK printer dialog
/// if the GTK library is available on the platform (linux/unix only).
/// When switched off, the GTK printer dialog isn't used even if the GTK library is available.
OPTION_PRINTER_USES_GTK,
/// When switched on (default), the library shows in a transient yellow window the zoom factor
/// value.
/// When switched off, no such window gets displayed.
OPTION_SHOW_SCALING,
/// When switched on and when the keyboard in use has '+' in the shifted position of its key,
/// pressing that key and ctrl triggers the zoom-in operation.
/// When switched off (default), the zoom-in operation requires that also the shift key is pressed.
/// Under macOS, this option has no effect because the OS itself generates ⌘= followed
/// by ⌘+ when pressing ⌘ and the '=|+' key without pressing shift.
OPTION_SIMPLE_ZOOM_SHORTCUT,
// don't change this, leave it always as the last element
/// For internal use only.
OPTION_LAST
} Fl_Option;
private:
static unsigned char options_[OPTION_LAST];
static unsigned char options_read_;
static int program_should_quit_; // non-zero means the program was asked to cleanly terminate
public:
/*
Return a global setting for all FLTK applications, possibly overridden
by a setting specifically for this application.
*/
static bool option(Fl_Option opt);
/*
Override an option while the application is running.
*/
static void option(Fl_Option opt, bool val);
/**
The currently executing idle callback function: DO NOT USE THIS DIRECTLY!
This is now used as part of a higher level system allowing multiple
idle callback functions to be called.
\see add_idle(), remove_idle()
*/
static void (*idle)();
#ifndef FL_DOXYGEN
private:
static Fl_Awake_Handler *awake_ring_;
static void **awake_data_;
static int awake_ring_size_;
static int awake_ring_head_;
static int awake_ring_tail_;
public:
static const char* scheme_;
static Fl_Image* scheme_bg_;
static int e_original_keysym; // late addition
static int scrollbar_size_;
static int menu_linespacing_; // STR #2927
#endif
static int add_awake_handler_(Fl_Awake_Handler, void*);
static int get_awake_handler_(Fl_Awake_Handler&, void*&);
public:
// API version number
static double version();
static int api_version();
// ABI version number
static int abi_version();
/**
Returns whether the runtime library ABI version is correct.
This enables you to check the ABI version of the linked FLTK
library at runtime.
Returns 1 (true) if the compiled ABI version (in the header files)
and the linked library ABI version (used at runtime) are the same,
0 (false) otherwise.
Argument \p val can be used to query a particular library ABI version.
Use for instance 10303 to query if the runtime library is compatible
with FLTK ABI version 1.3.3. This is rarely useful.
The default \p val argument is FL_ABI_VERSION, which checks the version
defined at configure time (i.e. in the header files at program
compilation time) against the linked library version used at runtime.
This is particularly useful if you linked with a shared object library,
but it also concerns static linking.
\see Fl::abi_version()
*/
static inline int abi_check(const int val = FL_ABI_VERSION) {
return val == abi_version();
}
// argument parsers:
static int arg(int argc, char **argv, int& i);
static int args(int argc, char **argv, int& i, Fl_Args_Handler cb = 0);
static void args(int argc, char **argv);
/**
Usage string displayed if Fl::args() detects an invalid argument.
This may be changed to point to customized text at run-time.
*/
static const char* const help;
// things called by initialization:
static void display(const char*);
static int visual(int);
/**
This does the same thing as Fl::visual(int) but also requires OpenGL
drawing to work. This <I>must</I> be done if you want to draw in
normal windows with OpenGL with gl_start() and gl_end().
It may be useful to call this so your X windows use the same visual
as an Fl_Gl_Window, which on some servers will reduce colormap flashing.
See Fl_Gl_Window for a list of additional values for the argument.
*/
static int gl_visual(int, int *alist=0); // platform dependent
static void own_colormap();
static void get_system_colors();
static void foreground(uchar, uchar, uchar);
static void background(uchar, uchar, uchar);
static void background2(uchar, uchar, uchar);
// schemes:
static int scheme(const char *name);
/** See void scheme(const char *name) */
static const char* scheme() {return scheme_;}
/** Returns whether the current scheme is the given name.
This is a fast inline convenience function to support scheme-specific
code in widgets, e.g. in their draw() methods, if required.
Use a valid scheme name, not \p NULL (although \p NULL is allowed,
this is not a useful argument - see below).
If Fl::scheme() has not been set or has been set to the default
scheme ("none" or "base"), then this will always return 0 regardless
of the argument, because Fl::scheme() is \p NULL in this case.
\note The stored scheme name is always lowercase, and this method will
do a case-sensitive compare, so you \b must provide a lowercase string to
return the correct value. This is intentional for performance reasons.
Example:
\code
if (Fl::is_scheme("gtk+")) { your_code_here(); }
\endcode
\param[in] name \b lowercase string of requested scheme name.
\return 1 if the given scheme is active, 0 otherwise.
\see Fl::scheme(const char *name)
*/
static int is_scheme(const char *name) {
return (scheme_ && name && !strcmp(name,scheme_));
}
static int reload_scheme(); // defined in 'src/Fl_get_system_colors.cxx'
static int scrollbar_size();
static void scrollbar_size(int W);
static int menu_linespacing();
static void menu_linespacing(int H);
// execution:
static int wait();
static double wait(double time);
static int check();
static int ready();
static int run();
/** Returns non-zero when a request for program termination was received and accepted.
On the MacOS platform, the "Quit xxx" item of the application menu is such a request,
that is considered accepted when all windows are closed. On other platforms, this function
returns 0 until \p Fl::program_should_quit(1) is called.
\version 1.4.0
*/
static int program_should_quit() {return program_should_quit_;}
/** Indicate to the FLTK library whether a program termination request was received and accepted.
A program may set this to 1, for example, while performing a platform-independent command asking the program to cleanly
terminate, similarly to the "Quit xxx" item of the application menu under MacOS.
\version 1.4.0
*/
static void program_should_quit(int should_i) { program_should_quit_ = should_i; }
static void hide_all_windows();
static Fl_Widget* readqueue();
//
// cross-platform timer support
//
static void add_timeout(double t, Fl_Timeout_Handler cb, void *data = 0);
static void repeat_timeout(double t, Fl_Timeout_Handler cb, void *data = 0);
static int has_timeout(Fl_Timeout_Handler cb, void *data = 0);
static void remove_timeout(Fl_Timeout_Handler cb, void *data = 0);
static int remove_next_timeout(Fl_Timeout_Handler cb, void *data = 0, void **data_return = 0);
static void add_check(Fl_Timeout_Handler, void* = 0);
static int has_check(Fl_Timeout_Handler, void* = 0);
static void remove_check(Fl_Timeout_Handler, void* = 0);
static Fl_Timestamp now(double offset = 0);
static double seconds_since(Fl_Timestamp& then);
static double seconds_between(Fl_Timestamp& back, Fl_Timestamp& further_back);
static long ticks_since(Fl_Timestamp& then);
static long ticks_between(Fl_Timestamp& back, Fl_Timestamp& further_back);
// private
static void run_idle();
static void run_checks();
static void add_fd(int fd, int when, Fl_FD_Handler cb, void* = 0); // platform dependent
static void add_fd(int fd, Fl_FD_Handler cb, void* = 0); // platform dependent
/** Removes a file descriptor handler. */
static void remove_fd(int, int when); // platform dependent
/** Removes a file descriptor handler. */
static void remove_fd(int); // platform dependent
static void add_idle(Fl_Idle_Handler cb, void* data = 0);
static int has_idle(Fl_Idle_Handler cb, void* data = 0);
static void remove_idle(Fl_Idle_Handler cb, void* data = 0);
/** If true then flush() will do something. */
static int damage() {return damage_;}
static void redraw();
static void flush();
/** \addtogroup group_comdlg
@{ */
/**
FLTK calls Fl::warning() to output a warning message.
The default version on Windows returns \e without printing a warning
message, because Windows programs normally don't have stderr (a console
window) enabled.
The default version on all other platforms prints the warning message to stderr.
You can override the behavior by setting the function pointer to your
own routine.
Fl::warning() means that there was a recoverable problem, the display may
be messed up, but the user can probably keep working - all X protocol
errors call this, for example. The default implementation returns after
displaying the message.
\note \#include <FL/Fl.H>
*/
static void (*warning)(const char*, ...);
/**
FLTK calls Fl::error() to output a normal error message.
The default version on Windows displays the error message in a MessageBox window.
The default version on all other platforms prints the error message to stderr.
You can override the behavior by setting the function pointer to your
own routine.
Fl::error() means there is a recoverable error such as the inability to read
an image file. The default implementation returns after displaying the message.
\note \#include <FL/Fl.H>
*/
static void (*error)(const char*, ...);
/**
FLTK calls Fl::fatal() to output a fatal error message.
The default version on Windows displays the error message in a MessageBox window.
The default version on all other platforms prints the error message to stderr.
You can override the behavior by setting the function pointer to your
own routine.
Fl::fatal() must not return, as FLTK is in an unusable state, however your
version may be able to use longjmp or an exception to continue, as long as
it does not call FLTK again. The default implementation exits with status 1
after displaying the message.
\note \#include <FL/Fl.H>
*/
static void (*fatal)(const char*, ...);
/** @} */
/** \defgroup fl_windows Windows handling functions
\brief Windows and standard dialogs handling declared in <FL/Fl.H>
@{ */
static Fl_Window* first_window();
static void first_window(Fl_Window*);
static Fl_Window* next_window(const Fl_Window*);
/**
Returns the top-most modal() window currently shown.
This is the most recently shown() window with modal() true, or NULL
if there are no modal() windows shown().
The modal() window has its handle() method called
for all events, and no other windows will have handle()
called (grab() overrides this).
*/
static Fl_Window* modal() {return modal_;}
/** Returns the window that currently receives all events.
\return The window that currently receives all events,
or NULL if event grabbing is currently OFF.
*/
static Fl_Window* grab() {return grab_;}
/** Selects the window to grab.
This is used when pop-up menu systems are active.
Send all events to the passed window no matter where the pointer or
focus is (including in other programs). The window <I>does not have
to be shown()</I> , this lets the handle() method of a
"dummy" window override all event handling and allows you to
map and unmap a complex set of windows (under both X and Windows
<I>some</I> window must be mapped because the system interface needs a
window id).
If grab() is on it will also affect show() of windows by doing
system-specific operations (on X it turns on override-redirect).
These are designed to make menus popup reliably
and faster on the system.
To turn off grabbing do Fl::grab(0).
<I>Be careful that your program does not enter an infinite loop
while grab() is on. On X this will lock up your screen!</I>
To avoid this potential lockup, all newer operating systems seem to
limit mouse pointer grabbing to the time during which a mouse button
is held down. Some OS's may not support grabbing at all.
*/
static void grab(Fl_Window*); // platform dependent
/** @} */
/** \defgroup fl_events Events handling functions
Fl class events handling API declared in <FL/Fl.H>
@{
*/
// event information:
/**
Returns the last event that was processed. This can be used
to determine if a callback is being done in response to a
keypress, mouse click, etc.
*/
static int event() {return e_number;}
/**
Returns the mouse position of the event relative to the Fl_Window
it was passed to.
*/
static int event_x() {return e_x;}
/**
Returns the mouse position of the event relative to the Fl_Window
it was passed to.
*/
static int event_y() {return e_y;}
/**
Returns the mouse position on the screen of the event. To find the
absolute position of an Fl_Window on the screen, use the
difference between event_x_root(),event_y_root() and
event_x(),event_y().
*/
static int event_x_root() {return e_x_root;}
/**
Returns the mouse position on the screen of the event. To find the
absolute position of an Fl_Window on the screen, use the
difference between event_x_root(),event_y_root() and
event_x(),event_y().
*/
static int event_y_root() {return e_y_root;}
/**
Returns the current horizontal mouse scrolling associated with the
FL_MOUSEWHEEL event. Right is positive.
*/
static int event_dx() {return e_dx;}
/**
Returns the current vertical mouse scrolling associated with the
FL_MOUSEWHEEL event. Down is positive.
*/
static int event_dy() {return e_dy;}
/**
Return where the mouse is on the screen by doing a round-trip query to
the server. You should use Fl::event_x_root() and
Fl::event_y_root() if possible, but this is necessary if you are
not sure if a mouse event has been processed recently (such as to
position your first window). If the display is not open, this will
open it.
*/
static void get_mouse(int &,int &);
/**
Returns non zero if we had a double click event.
\retval Non-zero if the most recent FL_PUSH or FL_KEYBOARD was a "double click".
\retval N-1 for N clicks.
A double click is counted if the same button is pressed
again while event_is_click() is true.
*/
static int event_clicks() {return e_clicks;}
/**
Manually sets the number returned by Fl::event_clicks().
This can be used to set it to zero so that
later code does not think an item was double-clicked.
\param[in] i corresponds to no double-click if 0, i+1 mouse clicks otherwise
\see int event_clicks()
*/
static void event_clicks(int i) {e_clicks = i;}
/**
Returns non-zero if the mouse has not moved far enough
and not enough time has passed since the last FL_PUSH or
FL_KEYBOARD event for it to be considered a "drag" rather than a
"click". You can test this on FL_DRAG, FL_RELEASE,
and FL_MOVE events.
*/
static int event_is_click() {return e_is_click;}
/**
Clears the value returned by Fl::event_is_click().
Useful to prevent the <I>next</I>
click from being counted as a double-click or to make a popup menu
pick an item with a single click. Don't pass non-zero to this.
*/
static void event_is_click(int i) {e_is_click = i;}
/**
Gets which particular mouse button caused the current event.
This returns garbage if the most recent event was not a FL_PUSH or FL_RELEASE event.
\retval FL_LEFT_MOUSE
\retval FL_MIDDLE_MOUSE
\retval FL_RIGHT_MOUSE
\retval FL_BACK_MOUSE
\retval FL_FORWARD_MOUSE
\see Fl::event_buttons(), Fl::event_state()
*/
static int event_button() { return e_keysym - FL_Button; }
/**
Returns the keyboard and mouse button states of the last event.
This is a bitfield of what shift states were on and what mouse buttons
were held down during the most recent event.
\note FLTK platforms differ in what Fl::event_state() returns when it is called
while a modifier key or mouse button is being pressed or released.
- Under X11 and Wayland, Fl::event_state() indicates the state of the modifier keys and
mouse buttons just \b prior to the event. Thus, during the \c FL_KEYDOWN event generated
when pressing the shift key, for example, the \c FL_SHIFT bit of event_state() is 0 and
becomes 1 only at the next event which can be any other event, including e.g. \c FL_MOVE.
- Under other platforms the reported state of modifier keys or mouse buttons includes that
of the key or button being pressed or released.
- Fl::event_state() returns the same value under all platforms when it's called while a
non-modifier key (e.g. a letter or function key) is being pressed or released.
- X servers do not agree on shift states, and \c FL_NUM_LOCK, \c FL_META, and \c FL_SCROLL_LOCK
may not work.
- The values were selected to match the XFree86 server on Linux.
\note This inconsistency \b may be fixed (on X11 and Wayland) in a later release.
The legal event state bits are:
| Device | State Bit | Key or Button | Since |
|----------|----------------|-------------------------|--------|
| Keyboard | FL_SHIFT | Shift | |
| Keyboard | FL_CAPS_LOCK | Caps Lock | |
| Keyboard | FL_CTRL | Ctrl | |
| Keyboard | FL_ALT | Alt | |
| Keyboard | FL_NUM_LOCK | Num Lock | |
| Keyboard | FL_META | Meta, e.g. "Windows" | |
| Keyboard | FL_SCROLL_LOCK | Scroll Lock | |
| Mouse | FL_BUTTON1 | left button | |
| Mouse | FL_BUTTON2 | middle button | |
| Mouse | FL_BUTTON3 | right button | |
| Mouse | FL_BUTTON4 | side button 1 (back) | 1.3.10 |
| Mouse | FL_BUTTON5 | side button 2 (forward) | 1.3.10 |
*/
static int event_state() {return e_state;}
/** Returns non-zero if any of the passed event state bits are turned on.
Use \p mask to pass the event states you're interested in.
The legal event state bits are defined in Fl::event_state().
*/
static int event_state(int mask) {return e_state&mask;}
/**
Gets which key on the keyboard was last pushed.
The returned integer 'key code' is not necessarily a text
equivalent for the keystroke. For instance: if someone presses '5' on the
numeric keypad with numlock on, Fl::event_key() may return the 'key code'
for this key, and NOT the character '5'. To always get the '5', use Fl::event_text() instead.
\returns an integer 'key code', or 0 if the last event was not a key press or release.
\see int event_key(int), event_text(), compose(int&).
*/
static int event_key() {return e_keysym;}
/**
Returns the keycode of the last key event, regardless of the NumLock state.
If NumLock is deactivated, FLTK translates events from the
numeric keypad into the corresponding arrow key events.
event_key() returns the translated key code, whereas
event_original_key() returns the keycode before NumLock translation.
*/
static int event_original_key(){return e_original_keysym;}
/**
Returns true if the given \p key was held
down (or pressed) <I>during</I> the last event. This is constant until
the next event is read from the server.
Fl::get_key(int) returns true if the given key is held down <I>now</I>.
Under X this requires a round-trip to the server and is <I>much</I>
slower than Fl::event_key(int).
Keys are identified by the <I>unshifted</I> values. FLTK defines a
set of symbols that should work on most modern machines for every key
on the keyboard:
\li All keys on the main keyboard producing a printable ASCII
character use the value of that ASCII character (as though shift,
ctrl, and caps lock were not on). The space bar is 32.
\li All keys on the numeric keypad producing a printable ASCII
character use the value of that ASCII character plus FL_KP
(e.g., FL_KP + '4', FL_KP + '/').
The highest possible value is FL_KP_Last so you can
range-check to see if something is on the keypad.
\li All numbered function keys use the number on the function key plus
FL_F. The highest possible number is FL_F_Last, so you
can range-check a value.
\li Buttons on the mouse are considered keys, and use the button
number (where the left button is 1) plus FL_Button.
\li All other keys on the keypad have a symbol: FL_Escape,
FL_BackSpace, FL_Tab, FL_Enter, FL_Print, FL_Scroll_Lock, FL_Pause,
FL_Insert, FL_Home, FL_Page_Up, FL_Delete, FL_End, FL_Page_Down,
FL_Left, FL_Up, FL_Right, FL_Down, FL_Iso_Key, FL_Shift_L, FL_Shift_R,
FL_Control_L, FL_Control_R, FL_Caps_Lock, FL_Alt_L, FL_Alt_R,
FL_Meta_L, FL_Meta_R, FL_Menu, FL_Num_Lock, FL_KP_Enter. Be
careful not to confuse these with the very similar, but all-caps,
symbols used by Fl::event_state().
On X Fl::get_key(FL_Button+n) does not work.
On Windows Fl::get_key(FL_KP_Enter) and Fl::event_key(FL_KP_Enter) do not work.
*/
static int event_key(int key);
/**
Returns true if the given \p key is held down <I>now</I>.
Under X this requires a round-trip to the server and is <I>much</I>
slower than Fl::event_key(int). \see event_key(int)
*/
static int get_key(int key); // platform dependent
/**
Returns the text associated with the current event, including FL_PASTE or FL_DND_RELEASE events.
This can be used in response to FL_KEYUP, FL_KEYDOWN, FL_PASTE, and FL_DND_RELEASE.
When responding to FL_KEYUP/FL_KEYDOWN, use this function instead of Fl::event_key()
to get the text equivalent of keystrokes suitable for inserting into strings
and text widgets.
The returned string is guaranteed to be NULL terminated.
However, see Fl::event_length() for the actual length of the string,
in case the string itself contains NULLs that are part of the text data.
\returns A NULL terminated text string equivalent of the last keystroke.
*/
static const char* event_text() {return e_text;}
/**
Returns the length of the text in Fl::event_text(). There
will always be a nul at this position in the text. However there may
be a nul before that if the keystroke translates to a nul character or
you paste a nul character.
*/
static int event_length() {return e_length;}
/** During an FL_PASTE event of non-textual data, returns a pointer to the pasted data.
The returned data is an Fl_RGB_Image * when the result of Fl::event_clipboard_type() is Fl::clipboard_image.
*/
static void *event_clipboard() { return e_clipboard_data; }
/** Returns the type of the pasted data during an FL_PASTE event.
This type can be Fl::clipboard_plain_text or Fl::clipboard_image.
*/
static const char *event_clipboard_type() {return e_clipboard_type; }
static int compose(int &del);
static void compose_reset();
static int event_inside(int,int,int,int);
static int event_inside(const Fl_Widget*);
static int test_shortcut(Fl_Shortcut);
static void enable_im();
static void disable_im();
// event destinations:
static int handle(int, Fl_Window*);
static int handle_(int, Fl_Window*);
/** Gets the widget that is below the mouse.
\see belowmouse(Fl_Widget*) */
static Fl_Widget* belowmouse() {return belowmouse_;}
static void belowmouse(Fl_Widget*);
/** Gets the widget that is being pushed.
\see void pushed(Fl_Widget*) */
static Fl_Widget* pushed() {return pushed_;}
static void pushed(Fl_Widget*);
/** Gets the current Fl::focus() widget. \sa Fl::focus(Fl_Widget*) */
static Fl_Widget* focus() {return focus_;}
static void focus(Fl_Widget*);
static void add_handler(Fl_Event_Handler ha);
static void add_handler(Fl_Event_Handler ha, Fl_Event_Handler before);
static Fl_Event_Handler last_handler();
static void remove_handler(Fl_Event_Handler h);
static void add_system_handler(Fl_System_Handler h, void *data);
static void remove_system_handler(Fl_System_Handler h);
static void event_dispatch(Fl_Event_Dispatch d);
static Fl_Event_Dispatch event_dispatch();
static Fl_Callback_Reason callback_reason();
/** @} */
/** \defgroup fl_clipboard Selection & Clipboard functions
FLTK global copy/cut/paste functions declared in <FL/Fl.H>
@{ */
/**
Copies data to the selection buffer, the clipboard, or both.
The \p destination can be:
- 0: selection buffer (see note below)
- 1: clipboard
- 2: both
The selection buffer exists only on the X11 platform and is used for middle-mouse
pastes and for drag-and-drop selections. The clipboard is used for traditional
copy/cut/paste operations. On all other platforms the selection buffer
(\p destination = 0) is mapped to the clipboard, i.e. on platforms other than X11
all \p destinations are equivalent and the data is always copied to the clipboard.
\note Please see Fl::selection_to_clipboard() to enable duplication of the
selection buffer to the clipboard on X11, i.e. if \p destination = 0
(selection buffer) \b and Fl::selection_to_clipboard() is enabled, then
the data is copied to both the selection buffer and the clipboard.
This makes the X11 behavior similar to other platforms but keeps the
selection buffer for X11 specific inter process communication.
\p type should always be \p Fl::clipboard_plain_text which is the default.
Other values are ignored and reserved for future extensions.
\note This function is, at present, intended only to copy UTF-8 encoded
textual data. To copy graphical data, use the Fl_Copy_Surface class.
The \p type argument may allow to copy other kinds of data in the future.
\param[in] stuff text data to be copied
\param[in] len the number of relevant bytes in \p stuff
\param[in] destination 0 = selection, 1 = clipboard, 2 = both (see description)
\param[in] type usually plain text (see description)
\internal
Documented here because it is platform dependent (calls the platform driver):
\code
Fl::screen_driver()->copy(stuff, len, clipboard, type);
\endcode
*/
static void copy(const char *stuff, int len, int destination = 0,
const char *type = Fl::clipboard_plain_text);
/**
Copies selections on X11 directly to the clipboard if enabled.
This method can be called on all platforms. Other platforms than X11 are
not affected by this feature.
If this is switched on (\p mode = 1), Fl::copy() copies all data to the
clipboard regardless of its \p destination argument. If the destination is 0
(selection buffer) data is copied to both the selection buffer and the clipboard.
Drag and drop is also affected since drag-and-drop data is copied to the selection
buffer.
You can use this to make the experience of data selection and copying more like
that on other platforms (Windows, macOS, and even Wayland).
The default operation mode is the standard X11 behavior (disabled).
\note This feature is experimental and enabling it may have unexpected side effects.
It is your own responsibility if you enable it.
\since 1.4.0
\param[in] mode 1 = enable selection_to_clipboard, 0 = disable selection_to_clipboard
\see copy(const char *, int, int, const char *)
*/
static void selection_to_clipboard(int mode) {
selection_to_clipboard_ = mode ? 1 : 0;
}
/**
\brief Returns the current selection_to_clipboard mode.
\see void selection_to_clipboard(int)
*/
static int selection_to_clipboard() { return selection_to_clipboard_; }
/**
Pastes the data from the selection buffer (\p source is 0) or the clipboard
(\p source is 1) into \p receiver.
The selection buffer (\p source is 0) is used for middle-mouse pastes and for
drag-and-drop selections. The clipboard (\p source is 1) is used for
copy/cut/paste operations.
If \p source is 1, the optional \p type argument indicates what type of data is requested from the clipboard.
At present, Fl::clipboard_plain_text (requesting text data) and
Fl::clipboard_image (requesting image data) are possible.
Set things up so the handle function of the \p receiver widget will be called with an FL_PASTE event some
time in the future if the clipboard does contain data of the requested type.
The handle function of \p receiver can process the FL_PASTE event as follows:
\li If the \p receiver widget is known to only receive text data, the text string
from the specified \p source is in Fl::event_text() with UTF-8 encoding, and the
number of bytes is in Fl::event_length(). If Fl::paste() gets called during the
drop step of a files-drag-and-drop operation,
Fl::event_text() contains a list of filenames (see \ref events_dnd).
\li If the \p receiver widget can potentially receive non-text data, use
Fl::event_clipboard_type() to determine what sort of data is being sent.
If Fl::event_clipboard_type() returns Fl::clipboard_plain_text, proceed as above.
It it returns Fl::clipboard_image, the pointer returned by Fl::event_clipboard()
can be safely cast to type Fl_RGB_Image * to obtain a pointer to the pasted image.
If \p receiver accepts the clipboard image, receiver.handle() should return 1 and the
application should take ownership of this image (that is, delete it after use).
Conversely, if receiver.handle() returns 0, the application must not use the image.
The receiver should be prepared to be called \e directly by this, or for
it to happen \e later, or possibly <i>not at all</i>. This
allows the window system to take as long as necessary to retrieve
the paste buffer (or even to screw up completely) without complex
and error-prone synchronization code in FLTK.
\par Platform details for image data:
\li Unix/Linux platform: Clipboard images in PNG or BMP formats are recognized. Requires linking with the fltk_images library.
\li Windows platform: Both bitmap and vectorial (Enhanced metafile) data from clipboard
can be pasted as image data.
\li Mac OS X platform: Both bitmap (TIFF) and vectorial (PDF) data from clipboard
can be pasted as image data.
*/
static void paste(Fl_Widget &receiver, int source, const char *type = Fl::clipboard_plain_text);
/**
FLTK will call the registered callback whenever there is a change to the
selection buffer or the clipboard. The source argument indicates which
of the two has changed. Only changes by other applications are reported.
Example:
\code
void clip_callback(int source, void *data) {
if ( source == 0 ) printf("CLIP CALLBACK: selection buffer changed\n");
if ( source == 1 ) printf("CLIP CALLBACK: clipboard changed\n");
}
[..]
int main() {
[..]
Fl::add_clipboard_notify(clip_callback);
[..]
}
\endcode
\note Some systems require polling to monitor the clipboard and may
therefore have some delay in detecting changes.
*/
static void add_clipboard_notify(Fl_Clipboard_Notify_Handler h, void *data = 0);
/**
Stop calling the specified callback when there are changes to the selection
buffer or the clipboard.
*/
static void remove_clipboard_notify(Fl_Clipboard_Notify_Handler h);
/** Returns non 0 if the clipboard contains data matching \p type.
The clipboard can contain both text and image data; in that situation this function
returns non 0 to both requests.
This function is \e not meant to check whether the clipboard is empty.
This function does not allow to query the selection buffer because FLTK
allows to copy/paste non-textual data only from/to the clipboard.
\param type can be Fl::clipboard_plain_text or Fl::clipboard_image.
*/
static int clipboard_contains(const char *type);
/** Denotes plain textual data
*/
static char const * const clipboard_plain_text;
/** Denotes image data
*/
static char const * const clipboard_image;
/**
Initiate a Drag And Drop operation. The selection buffer should be
filled with relevant data before calling this method. FLTK will
then initiate the system wide drag and drop handling. Dropped data
will be marked as <i>text</i>.
Create a selection first using:
Fl::copy(const char *stuff, int len, 0)
*/
static int dnd(); // platform dependent
// These are for back-compatibility only:
/** back-compatibility only: Gets the widget owning the current selection
\see Fl_Widget* selection_owner(Fl_Widget*) */
static Fl_Widget* selection_owner() {return selection_owner_;}
static void selection_owner(Fl_Widget*);
static void selection(Fl_Widget &owner, const char*, int len);
static void paste(Fl_Widget &receiver);
/** @} */
/** \defgroup fl_screen Screen functions
Fl global screen functions declared in <FL/Fl.H>.
FLTK supports high-DPI screens using a screen scaling factor.
The scaling factor is initialized by the library to a value
based on information obtained from the OS. If this initial value
is not satisfactory, the FLTK_SCALING_FACTOR environment variable
can be set to a value FLTK will multiply to the OS-given value.
The 2 variants of functions Fl::screen_scale() allow to programmatically get and set
scaling factor values. The scaling factor value can be further changed at runtime
by typing \c Ctrl/+/-/0/ (\c Cmd/+/-/0/ under macOS).
See \ref events_fl_shortcut for more details about these shortcuts.
@{ */
static int x(); // via screen driver
static int y(); // via screen driver
static int w(); // via screen driver
static int h(); // via screen driver
// multi-head support:
static int screen_count(); // via screen driver
static void screen_xywh(int &X, int &Y, int &W, int &H); // via screen driver
static void screen_xywh(int &X, int &Y, int &W, int &H, int mx, int my); // via screen driver
static void screen_xywh(int &X, int &Y, int &W, int &H, int n); // via screen driver
static void screen_xywh(int &X, int &Y, int &W, int &H, int mx, int my, int mw, int mh); // via screen driver
static int screen_num(int x, int y); // via screen driver
static int screen_num(int x, int y, int w, int h); // via screen driver
static void screen_dpi(float &h, float &v, int n=0); // via screen driver
static void screen_work_area(int &X, int &Y, int &W, int &H, int mx, int my); // via screen driver
static void screen_work_area(int &X, int &Y, int &W, int &H, int n); // via screen driver
static void screen_work_area(int &X, int &Y, int &W, int &H); // via screen driver
static float screen_scale(int n); // via screen driver
static void screen_scale(int n, float factor); // via screen driver
static int screen_scaling_supported();
static void keyboard_screen_scaling(int value);
/** @} */
/** \defgroup fl_attributes Color & Font functions
fl global color, font functions.
These functions are declared in <FL/Fl.H> or <FL/fl_draw.H>.
@{ */
// color map:
static void set_color(Fl_Color, uchar, uchar, uchar);
static void set_color(Fl_Color, uchar, uchar, uchar, uchar);
/**
Sets an entry in the fl_color index table. You can set it to any
8-bit RGB color. The color is not allocated until fl_color(i) is used.
*/
static void set_color(Fl_Color i, unsigned c); // platform dependent
static unsigned get_color(Fl_Color i);
static void get_color(Fl_Color i, uchar &red, uchar &green, uchar &blue);
static void get_color(Fl_Color i, uchar &red, uchar &green, uchar &blue, uchar &alpha);
/**
Frees the specified color from the colormap, if applicable.
If overlay is non-zero then the color is freed from the
overlay colormap.
*/
static void free_color(Fl_Color i, int overlay = 0); // platform dependent
// fonts:
static const char* get_font(Fl_Font);
/**
Get a human-readable string describing the family of this face. This
is useful if you are presenting a choice to the user. There is no
guarantee that each face has a different name. The return value points
to a static buffer that is overwritten each call.
The integer pointed to by \p attributes (if the pointer is not
zero) is set to zero, FL_BOLD or FL_ITALIC or
FL_BOLD | FL_ITALIC. To locate a "family" of fonts, search
forward and back for a set with non-zero attributes, these faces along
with the face with a zero attribute before them constitute a family.
*/
static const char* get_font_name(Fl_Font, int* attributes = 0);
/**
Return an array of sizes in \p sizep. The return value is the
length of this array. The sizes are sorted from smallest to largest
and indicate what sizes can be given to fl_font() that will
be matched exactly (fl_font() will pick the closest size for
other sizes). A zero in the first location of the array indicates a
scalable font, where any size works, although the array may list sizes
that work "better" than others. Warning: the returned array
points at a static buffer that is overwritten each call. Under X this
will open the display.
*/
static int get_font_sizes(Fl_Font, int*& sizep);
static void set_font(Fl_Font, const char*);
static void set_font(Fl_Font, Fl_Font);
/**
FLTK will open the display, and add every fonts on the server to the
face table. It will attempt to put "families" of faces together, so
that the normal one is first, followed by bold, italic, and bold
italic.
The only argument to this function is somewhat obsolete since FLTK and most
underlying operating systems move to support Unicode. For completeness,
following is the original documentation and a few updates:
On X11, the optional argument is a string to describe the set of fonts to
add. Passing NULL will select only fonts that have the
ISO8859-1 character set (and are thus usable by normal text). Passing
"-*" will select all fonts with any encoding as long as they have
normal X font names with dashes in them. Passing "*" will list every
font that exists (on X this may produce some strange output). Other
values may be useful but are system dependent.
With the Xft option on Linux, this parameter is ignored.
With Windows, `NULL` selects fonts with ANSI_CHARSET encoding and non-NULL
selects all fonts.
On macOS, this parameter is ignored.
The return value is how many faces are in the table after this is done.
*/
static Fl_Font set_fonts(const char* = 0); // platform dependent
/** @} */
/** \defgroup fl_drawings Drawing functions
FLTK global graphics and GUI drawing functions.
These functions are declared in <FL/fl_draw.H>,
and in <FL/platform.H> for offscreen buffer-related ones.
@{ */
// <Hack to re-order the 'Drawing functions' group>
/** @} */
// labeltypes:
static void set_labeltype(Fl_Labeltype,Fl_Label_Draw_F*,Fl_Label_Measure_F*);
/** Sets the functions to call to draw and measure a specific labeltype. */
static void set_labeltype(Fl_Labeltype, Fl_Labeltype from); // is it defined ?
// boxtypes:
static Fl_Box_Draw_F *get_boxtype(Fl_Boxtype);
static void set_boxtype(Fl_Boxtype, Fl_Box_Draw_F*,
uchar, uchar, uchar, uchar,
Fl_Box_Draw_Focus_F* =NULL);
static void set_boxtype(Fl_Boxtype, Fl_Boxtype from);
static int box_dx(Fl_Boxtype);
static int box_dy(Fl_Boxtype);
static int box_dw(Fl_Boxtype);
static int box_dh(Fl_Boxtype);
static int draw_box_active();
static Fl_Color box_color(Fl_Color);
static void set_box_color(Fl_Color);
// back compatibility:
/** \addtogroup fl_windows
@{ */
/** For back compatibility, sets the void Fl::fatal handler callback */
static void set_abort(Fl_Abort_Handler f) {fatal = f;}
static void (*atclose)(Fl_Window*,void*);
static void default_atclose(Fl_Window*,void*);
/** For back compatibility, sets the Fl::atclose handler callback. You
can now simply change the callback for the window instead.
\see Fl_Window::callback(Fl_Callback*) */
static void set_atclose(Fl_Atclose_Handler f) {atclose = f;}
/** @} */
/** \addtogroup fl_events
@{ */
/** Returns non-zero if the Shift key is pressed. */
static int event_shift() {return e_state&FL_SHIFT;}
/** Returns non-zero if the Control key is pressed. */
static int event_ctrl() {return e_state&FL_CTRL;}
/** Returns non-zero if the FL_COMMAND key is pressed, either FL_CTRL or on OSX FL_META. */
static int event_command() {return e_state&FL_COMMAND;}
/** Returns non-zero if the Alt key is pressed. */
static int event_alt() {return e_state&FL_ALT;}
/**
Returns the mouse buttons state bits; if non-zero, then at least one
button is pressed now. This function returns the button state at the
time of the event. During an FL_RELEASE event, the state
of the released button will be 0. To find out, which button
caused an FL_RELEASE event, you can use Fl::event_button() instead.
\return a bit mask value like { [FL_BUTTON1] | [FL_BUTTON2] | ... | [FL_BUTTON5] }
*/
static int event_buttons() {return e_state & FL_BUTTONS;}
/**
Returns non-zero if mouse button 1 is currently held down.
For more details, see Fl::event_buttons().
*/
static int event_button1() {return e_state & FL_BUTTON1;}
/**
Returns non-zero if mouse button 2 is currently held down.
For more details, see Fl::event_buttons().
*/
static int event_button2() {return e_state & FL_BUTTON2;}
/**
Returns non-zero if mouse button 3 is currently held down.
For more details, see Fl::event_buttons().
*/
static int event_button3() {return e_state & FL_BUTTON3;}
/**
Returns non-zero if mouse button 4 is currently held down.
For more details, see Fl::event_buttons().
*/
static int event_button4() {return e_state & FL_BUTTON4;}
/**
Returns non-zero if mouse button 5 is currently held down.
For more details, see Fl::event_buttons().
*/
static int event_button5() {return e_state & FL_BUTTON5;}
/** @} */
/**
Sets an idle callback.
\deprecated This method is obsolete - use the add_idle() method instead.
*/
static void set_idle(Fl_Old_Idle_Handler cb) {idle = cb;}
/** See grab(Fl_Window*) */
static void grab(Fl_Window& win) {grab(&win);}
/** Releases the current grabbed window, equals grab(0).
\deprecated Use Fl::grab(0) instead.
\see grab(Fl_Window*) */
static void release() {grab(0);}
// Visible focus methods...
/**
Gets or sets the visible keyboard focus on buttons and other
non-text widgets. The default mode is to enable keyboard focus
for all widgets.
*/
static void visible_focus(int v) { option(OPTION_VISIBLE_FOCUS, (v!=0)); }
/**
Gets or sets the visible keyboard focus on buttons and other
non-text widgets. The default mode is to enable keyboard focus
for all widgets.
*/
static int visible_focus() { return option(OPTION_VISIBLE_FOCUS); }
// Drag-n-drop text operation methods...
/**
Sets whether drag and drop text operations are supported.
This specifically affects whether selected text can
be dragged from text fields or dragged within a text field as a
cut/paste shortcut.
*/
static void dnd_text_ops(int v) { option(OPTION_DND_TEXT, (v!=0)); }
/**
Gets whether drag and drop text operations are
supported. This returns whether selected text can
be dragged from text fields or dragged within a text field as a
cut/paste shortcut.
*/
static int dnd_text_ops() { return option(OPTION_DND_TEXT); }
/** \defgroup fl_multithread Multithreading support functions
fl multithreading support functions declared in <FL/Fl.H>
@{ */
// Multithreading support:
static int lock();
static void unlock();
static void awake(void* message = 0);
/** See void awake(void* message=0). */
static int awake(Fl_Awake_Handler cb, void* message = 0);
/**
The thread_message() method returns the last message
that was sent from a child by the awake() method.
See also: \ref advanced_multithreading
*/
static void* thread_message(); // platform dependent
/** @} */
/** \defgroup fl_del_widget Safe widget deletion support functions
These functions, declared in <FL/Fl.H>, support deletion of widgets inside callbacks.
Fl::delete_widget() should be called when deleting widgets
or complete widget trees (Fl_Group, Fl_Window, ...) inside
callbacks.
The other functions are intended for internal use. The preferred
way to use them is by using the helper class Fl_Widget_Tracker.
The following is to show how it works ...
There are three groups of related methods:
-# scheduled widget deletion
- Fl::delete_widget() schedules widgets for deletion
- Fl::do_widget_deletion() deletes all scheduled widgets
-# widget watch list ("smart pointers")
- Fl::watch_widget_pointer() adds a widget pointer to the watch list
- Fl::release_widget_pointer() removes a widget pointer from the watch list
- Fl::clear_widget_pointer() clears a widget pointer \e in the watch list
-# the class Fl_Widget_Tracker:
- the constructor calls Fl::watch_widget_pointer()
- the destructor calls Fl::release_widget_pointer()
- the access methods can be used to test, if a widget has been deleted
\see Fl_Widget_Tracker.
@{ */
// Widget deletion:
static void delete_widget(Fl_Widget *w);
static void do_widget_deletion();
static void watch_widget_pointer(Fl_Widget *&w);
static void release_widget_pointer(Fl_Widget *&w);
static void clear_widget_pointer(Fl_Widget const *w);
/** @} */
/** sets whether GL windows should be drawn at high resolution on Apple
computers with retina displays
\version 1.3.4
*/
static void use_high_res_GL(int val) { use_high_res_GL_ = val; }
/** returns whether GL windows should be drawn at high resolution on Apple
computers with retina displays.
Default is no.
\version 1.3.4
*/
static int use_high_res_GL() { return use_high_res_GL_; }
/** sets whether OpenGL uses textures to draw all text.
By default, FLTK draws OpenGL text using textures, if the necessary
hardware support is available. Call \p Fl::draw_GL_text_with_textures(0)
once in your program before the first call to gl_font() to have FLTK
draw instead OpenGL text using a legacy, platform-dependent procedure.
It's recommended not to deactivate textures under the MacOS platform
because the MacOS legacy procedure is extremely rudimentary.
\param val use 0 to prevent FLTK from drawing GL text with textures
\see gl_texture_pile_height(int max)
\version 1.4.0
*/
static void draw_GL_text_with_textures(int val) { draw_GL_text_with_textures_ = val; }
/** returns whether whether OpenGL uses textures to draw all text.
Default is yes.
\see draw_GL_text_with_textures(int val)
\version 1.4.0
*/
static int draw_GL_text_with_textures() { return draw_GL_text_with_textures_; }
static int system(const char *command);
// Convert Windows commandline arguments to UTF-8 (documented in src/Fl.cxx)
static int args_to_utf8(int argc, char ** &argv);
#ifdef FLTK_HAVE_CAIRO
/** \defgroup group_cairo Cairo Support Functions and Classes
@{
*/
public:
// Cairo support API
static cairo_t *cairo_make_current(Fl_Window *w);
/** When FLTK_HAVE_CAIRO is defined and cairo_autolink_context() is true,
any current window dc is linked to a current Cairo context.
This is not the default, because it may not be necessary
to add Cairo support to all fltk supported windows.
When you wish to associate a Cairo context in this mode,
you need to call explicitly in your draw() overridden method,
Fl::cairo_make_current(Fl_Window*). This will create a Cairo context
only for this Window.
Still in custom Cairo application it is possible to handle
completely this process automatically by setting \p alink to true.
In this last case, you don't need anymore to call Fl::cairo_make_current().
You can use Fl::cairo_cc() to get the current Cairo context anytime.
\note Only available when configure has the --enable-cairo option
*/
static void cairo_autolink_context(bool alink) {
cairo_state_.autolink(alink);
}
/**
Gets the current autolink mode for Cairo support.
\retval false if no Cairo context autolink is made for each window.
\retval true if any fltk window is attached a Cairo context when it
is current. \see void cairo_autolink_context(bool alink)
\note Only available when configure has the --enable-cairo option
*/
static bool cairo_autolink_context() {
return cairo_state_.autolink();
}
/** Gets the current Cairo context linked with a fltk window. */
static cairo_t *cairo_cc() {
return cairo_state_.cc();
}
/** Sets the current Cairo context to \p c.
Set \p own to true if you want fltk to handle this cc deletion.
\note Only available when configure has the --enable-Cairo option
*/
static void cairo_cc(cairo_t *c, bool own=false) {
cairo_state_.cc(c, own);
}
/** Flush Cairo drawings on Cairo context \p c.
This is \b required on Windows if you use the Cairo context provided
by the "Cairo autolink" option. Call this when all your drawings on
the Cairo context are finished. This is maybe not necessary on other
platforms than Windows but it does no harm if you call it always.
You don't need to use this if you use an Fl_Cairo_Window which does
this automatically after the draw callback returns.
Code example for "Cairo autolink" mode:
In the overridden draw() method of your subclass of Fl_Window or any
widget:
\code
cairo_t *cc = Fl::cairo_cc(); // get the "autolink" Cairo context
// ... your Cairo drawings are here ...
Fl::cairo_flush(cc); // flush Cairo drawings to the device
\endcode
If you configure FLTK with \c '--enable-cairo' or CMake option
\c 'FLTK_OPTION_CAIRO_WINDOW' (i.e. without \c '--enable-cairoext' or CMake option
\c 'FLTK_OPTION_CAIRO_EXT') or if you don't enable the \c 'autolink' Cairo
context you may do the equivalent to use Cairo drawings in an
overridden draw() method of derived classes by using
\code
// get the Cairo context for the \c window
cairo_t *cc = Fl::cairo_make_current(window);
// ... your Cairo drawings are here ...
Fl::cairo_flush(cc); // flush Cairo drawings to the device
\endcode
\see Fl::cairo_autolink_context(bool)
\see Fl::cairo_make_current(Fl_Window*);
*/
static void cairo_flush(cairo_t *c) {
// flush Cairo drawings: necessary at least for Windows
cairo_surface_t *s = cairo_get_target(c);
cairo_surface_flush(s);
}
private:
static cairo_t *cairo_make_current(void *gc);
static cairo_t *cairo_make_current(void *gc, int W, int H);
static Fl_Cairo_State cairo_state_;
public:
/** @} */
#endif // FLTK_HAVE_CAIRO
};
/**
This class should be used to control safe widget deletion.
You can use an Fl_Widget_Tracker object to watch another widget, if you
need to know whether this widget has been deleted during a callback.
This simplifies the use of the "safe widget deletion" methods
Fl::watch_widget_pointer() and Fl::release_widget_pointer() and
makes their use more reliable, because the destructor automatically
releases the widget pointer from the widget watch list.
Fl_Widget_Tracker is intended to be used as an automatic (local/stack)
variable, such that its destructor is called when the object's
scope is left. This ensures that no stale widget pointers are
left in the widget watch list (see example below).
You can also create Fl_Widget_Tracker objects with \c new, but then it
is your responsibility to delete the object (and thus remove the
widget pointer from the watch list) when it is no longer needed.
Example:
\code
int MyClass::handle (int event) {
if (...) {
Fl_Widget_Tracker wp(this); // watch myself
do_callback(); // call the callback
if (wp.deleted()) return 1; // exit, if deleted
// Now we are sure that the widget has not been deleted,
// and it is safe to access the widget:
box(FL_FLAT_BOX);
color(FL_WHITE);
redraw();
}
}
\endcode
*/
class FL_EXPORT Fl_Widget_Tracker {
Fl_Widget* wp_;
public:
Fl_Widget_Tracker(Fl_Widget *wi);
~Fl_Widget_Tracker();
/**
Returns a pointer to the watched widget.
This pointer is \c NULL, if the widget has been deleted.
*/
Fl_Widget *widget() {return wp_;}
/**
Returns 1, if the watched widget has been deleted.
This is a convenience method. You can also use something like
<tt> if (wp.widget() == 0) // ...</tt>
where \p wp is an Fl_Widget_Tracker object.
*/
int deleted() {return wp_ == 0;}
/**
Returns 1, if the watched widget exists (has not been deleted).
This is a convenience method. You can also use something like
<tt> if (wp.widget() != 0) // ...</tt>
where \p wp is an Fl_Widget_Tracker object.
*/
int exists() {return wp_ != 0;}
};
/** \defgroup fl_unicode Unicode and UTF-8 functions
fl global Unicode and UTF-8 handling functions declared in <FL/fl_utf8.h>
@{ */
/** @} */
#endif // !Fl_H
================================================
FILE: Game Trainers/common/include/FL/Fl_Adjuster.H
================================================
//
// Adjuster widget header file for the Fast Light Tool Kit (FLTK).
//
// Copyright 1998-2010 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_Adjuster widget . */
// 3-button "slider", made for Nuke
#ifndef Fl_Adjuster_H
#define Fl_Adjuster_H
#ifndef Fl_Valuator_H
#include "Fl_Valuator.H"
#endif
/**
The Fl_Adjuster widget was stolen from Prisms, and has proven
to be very useful for values that need a large dynamic range.
\image html adjuster1.png
\image latex adjuster1.png "Fl_Adjuster" width=4cm
<P>When you press a button and drag to the right the value increases.
When you drag to the left it decreases. The largest button adjusts by
100 * step(), the next by 10 * step() and that
smallest button by step(). Clicking on the buttons
increments by 10 times the amount dragging by a pixel does. Shift +
click decrements by 10 times the amount.
*/
class FL_EXPORT Fl_Adjuster : public Fl_Valuator {
int drag;
int ix;
int soft_;
protected:
void draw() FL_OVERRIDE;
int handle(int) FL_OVERRIDE;
void value_damage() FL_OVERRIDE;
public:
Fl_Adjuster(int X,int Y,int W,int H,const char *l=0);
/**
If "soft" is turned on, the user is allowed to drag the value outside
the range. If they drag the value to one of the ends, let go, then
grab again and continue to drag, they can get to any value. Default is
one.
*/
void soft(int s) {soft_ = s;}
/**
If "soft" is turned on, the user is allowed to drag the value outside
the range. If they drag the value to one of the ends, let go, then
grab again and continue to drag, they can get to any value. Default is
one.
*/
int soft() const {return soft_;}
};
#endif
================================================
FILE: Game Trainers/common/include/FL/Fl_Anim_GIF_Image.H
================================================
//
// Fl_Anim_GIF_Image class header for the Fast Light Tool Kit (FLTK).
//
// Copyright 2016-2023 by Christian Grabner <wcout@gmx.net>.
//
// 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_Anim_Gif_Image_H
#define Fl_Anim_Gif_Image_H
// forward declarations
class Fl_Image;
class Fl_Widget;
#include <FL/Fl_GIF_Image.H>
// Load and display animated GIF images
class FL_EXPORT Fl_Anim_GIF_Image : public Fl_GIF_Image {
class FrameInfo; // internal helper class
public:
/**
When opening an Fl_Anim_GIF_Image there are some options
that can be passed in a `flags` value.
*/
enum Flags {
/**
This flag indicates to the loader that it should not start
the animation immediately after successful load, which is
the default.
It can be started later using the \ref start() method.
*/
DONT_START = 1,
/**
This flag indicates to the loader that it should not
resize the canvas widget of the animation to the dimensions
of the animation, which is the default.
Needed for special use cases.
*/
DONT_RESIZE_CANVAS = 2,
/**
This flag indicates to the loader that it should not
set the animation as \ref image() member of the canvas widget,
which is the default.
Needed for special use cases.
*/
DONT_SET_AS_IMAGE = 4,
/**
Often frames change just a small area of the animation canvas.
This flag indicates to the loader to try using less memory
by storing frame data not as canvas-sized images but use the
sizes defined in the GIF file.
The drawbacks are higher cpu usage during playback and maybe
minor artifacts when resized.
*/
OPTIMIZE_MEMORY = 8,
/**
This flag can be used to print informations about the
decoding process to the console.
*/
LOG_FLAG = 64,
/**
This flag can be used to print even more informations about
the decoding process to the console.
*/
DEBUG_FLAG = 128
};
// -- constructors and destructor
Fl_Anim_GIF_Image(const char *filename, Fl_Widget *canvas = 0, unsigned short flags = 0);
Fl_Anim_GIF_Image(const char* imagename, const unsigned char *data,
const size_t length, Fl_Widget *canvas = 0,
unsigned short flags = 0);
Fl_Anim_GIF_Image();
~Fl_Anim_GIF_Image() FL_OVERRIDE;
// -- file handling
bool load(const char *name, const unsigned char *imgdata=NULL, size_t imglength=0);
bool valid() const;
// -- getters and setters
void frame_uncache(bool uncache);
bool frame_uncache() const;
double delay(int frame_) const;
void delay(int frame, double delay);
void canvas(Fl_Widget *canvas, unsigned short flags = 0);
Fl_Widget *canvas() const;
int canvas_w() const;
int canvas_h() const;
bool is_animated() const;
const char *name() const;
void speed(double speed);
double speed() const;
// -- animation
int frames() const;
void frame(int frame);
int frame() const;
Fl_Image *image() const;
Fl_Image *image(int frame) const;
bool start();
bool stop();
bool next();
/** Return if the animation is currently running or stopped.
\return true if the animation is running
*/
bool playing() const { return valid() && Fl::has_timeout(cb_animate, (void *)this); }
// -- image data
Fl_Anim_GIF_Image& resize(int w, int h);
Fl_Anim_GIF_Image& resize(double scale);
int frame_x(int frame) const;
int frame_y(int frame) const;
int frame_w(int frame) const;
int frame_h(int frame) const;
// -- overridden methods
void color_average(Fl_Color c, float i) FL_OVERRIDE;
Fl_Image *copy(int W, int H) const FL_OVERRIDE;
Fl_Image *copy() const { return Fl_Pixmap::copy(); }
void desaturate() FL_OVERRIDE;
void draw(int x, int y, int w, int h, int cx = 0, int cy = 0) FL_OVERRIDE;
void uncache() FL_OVERRIDE;
// -- debugging and logging
int debug() const;
// -- static methods
static int frame_count(const char *name, const unsigned char *imgdata = NULL, size_t imglength = 0);
/**
The loop flag can be used to (dis-)allow loop count.
If set (which is the default), the animation will be
stopped after the number of repeats specified in the
GIF file (typically this count is set to 'forever' anyway).
If cleared the animation will always be 'forever',
regardless of what is specified in the GIF file.
*/
static bool loop;
/**
The min_delay value can be used to set a minimum value
for the frame delay for playback. This is to prevent
CPU hogs caused by images with very low delay rates.
This is a global value for all Fl_Anim_GIF_Image objects.
*/
static double min_delay;
protected:
bool next_frame();
void clear_frames();
void set_frame(int frame);
static void cb_animate(void *d);
void scale_frame();
void set_frame();
void on_frame_data(Fl_GIF_Image::GIF_FRAME &f) FL_OVERRIDE;
void on_extension_data(Fl_GIF_Image::GIF_FRAME &f) FL_OVERRIDE;
private:
char *name_;
unsigned short flags_;
Fl_Widget *canvas_;
bool uncache_;
bool valid_;
int frame_; // current frame
double speed_;
FrameInfo *fi_;
};
#endif // Fl_Anim_Gif_Image_H
================================================
FILE: Game Trainers/common/include/FL/Fl_BMP_Image.H
================================================
//
// BMP image header file for the Fast Light Tool Kit (FLTK).
//
// Copyright 1998-2022 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_BMP_Image widget . */
#ifndef Fl_BMP_Image_H
#define Fl_BMP_Image_H
# include "Fl_Image.H"
/**
The Fl_BMP_Image class supports loading, caching,
and drawing of Windows Bitmap (BMP) image files.
*/
class FL_EXPORT Fl_BMP_Image : public Fl_RGB_Image {
public:
Fl_BMP_Image(const char* filename);
Fl_BMP_Image(const char* imagename, const unsigned char *data, const long length = -1);
protected:
void load_bmp_(class Fl_Image_Reader &rdr, int ico_height = 0, int ico_width = 0);
};
#endif
================================================
FILE: Game Trainers/common/include/FL/Fl_Bitmap.H
================================================
//
// Bitmap header file for the Fast Light Tool Kit (FLTK).
//
// Copyright 1998-2017 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_Bitmap widget . */
#ifndef Fl_Bitmap_H
#define Fl_Bitmap_H
#include "Fl_Image.H"
#include "Fl_Widget.H" // for fl_uintptr_t
class Fl_Widget;
struct Fl_Menu_Item;
/**
The Fl_Bitmap class supports caching and drawing of mono-color
(bitmap) images. Images are drawn using the current color.
*/
class FL_EXPORT Fl_Bitmap : public Fl_Image {
friend class Fl_Graphics_Driver;
public:
/** pointer to raw bitmap data */
const uchar *array;
/** Non-zero if array points to bitmap data allocated internally */
int alloc_array;
private:
/** for internal use */
fl_uintptr_t id_;
int cache_w_, cache_h_; // size of bitmap when cached
public:
/** The constructors create a new bitmap from the specified bitmap data.
\see Fl_Bitmap(const uchar *bits, int bits_length, int W, int H) */
Fl_Bitmap(const uchar *bits, int W, int H) :
Fl_Image(W,H,0), array(bits), alloc_array(0), id_(0), cache_w_(0),cache_h_(0) {data((const char **)&array, 1);}
/** The constructors create a new bitmap from the specified bitmap data.
\see Fl_Bitmap(const char *bits, int bits_length, int W, int H) */
Fl_Bitmap(const char *bits, int W, int H) :
Fl_Image(W,H,0), array((const uchar *)bits), alloc_array(0), id_(0), cache_w_(0),cache_h_(0) {data((const char **)&array, 1);}
Fl_Bitmap(const uchar *bits, int bits_length, int W, int H);
Fl_Bitmap(const char *bits, int bits_length, int W, int H);
virtual ~Fl_Bitmap();
Fl_Image *copy(int W, int H) const FL_OVERRIDE;
Fl_Image *copy() const { return Fl_Image::copy(); }
void draw(int X, int Y, int W, int H, int cx=0, int cy=0) FL_OVERRIDE;
void draw(int X, int Y) {draw(X, Y, w(), h(), 0, 0);}
void label(Fl_Widget*w) FL_OVERRIDE;
void label(Fl_Menu_Item*m) FL_OVERRIDE;
void uncache() FL_OVERRIDE;
int cache_w() {return cache_w_;}
int cache_h() {return cache_h_;}
};
#endif
================================================
FILE: Game Trainers/common/include/FL/Fl_Box.H
================================================
//
// Box header file for the Fast Light Tool Kit (FLTK).
//
// Copyright 1998-2025 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/Fl_Box.H
\brief Fl_Box widget.
*/
#ifndef Fl_Box_H
#define Fl_Box_H
#ifndef Fl_Widget_H
#include "Fl_Widget.H"
#endif
/**
This widget simply draws its box, and possibly its label.
Putting it before some other widgets and making it big enough to surround
them will let you draw a frame around them.
*/
class FL_EXPORT Fl_Box : public Fl_Widget {
protected:
void draw() FL_OVERRIDE;
public:
/**
Creates a new Fl_Box widget with the given coordinates, size, and label.
This constructor sets box() to FL_NO_BOX, which means it is invisible.
However such widgets are useful as placeholders or Fl_Group::resizable()
values. To change the box to something visible, use box(Fl_Boxtype).
The destructor removes the box from its parent group.
\param[in] X, Y the position of the widget relative to the enclosing window
\param[in] W, H size of the widget in pixels
\param[in] L optional text for the widget label (default: no label)
\see Fl_Box(Fl_Boxtype b, int X, int Y, int W, int H, const char *L)
*/
Fl_Box(int X, int Y, int W, int H, const char *L = 0);
/**
Creates a new Fl_Box widget with the given boxtype, coordinates, size, and label.
This constructor sets box() to the given Fl_Boxtype \c B.
You must also specify a label but it can be \c nullptr (0, NULL) if you
don't want or need a visible label.
The destructor removes the box from its parent group.
\param[in] B boxtype of the widget
\param[in] X, Y the position of the widget relative to the enclosing window
\param[in] W, H size of the widget in pixels
\param[in] L optional text for the widget label (see description)
\see Fl_Box(int X, int Y, int W, int H, const char *L)
*/
Fl_Box(Fl_Boxtype B, int X, int Y, int W, int H, const char *L);
int handle(int) FL_OVERRIDE;
};
#endif
================================================
FILE: Game Trainers/common/include/FL/Fl_Browser.H
================================================
//
// Browser header file for the Fast Light Tool Kit (FLTK).
//
// Copyright 1998-2023 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_Browser widget . */
// Forms-compatible browser. Probably useful for other
// lists of textual data. Notice that the line numbers
// start from 1, and 0 means "no line".
#ifndef Fl_Browser_H
#define Fl_Browser_H
#include "Fl_Browser_.H"
#include "Fl_Image.H"
struct FL_BLINE;
/**
The Fl_Browser widget displays a scrolling list of text
lines, and manages all the storage for the text. This is not a text
editor or spreadsheet! But it is useful for showing a vertical list of
named objects to the user.
\image html fl_hold_browser.png "Fl_Hold_Browser"
\image latex fl_hold_browser.png "Fl_Hold_Browser" width=4cm
\par
\image html fl_multi_browser.png "Fl_Multi_Browser"
\image latex fl_multi_browser.png "Fl_Multi_Browser" width=4cm
Each line in the browser is identified by number. <I>The numbers
start at one</I> (this is so that zero can be reserved for "no line" in
the selective browsers). <I>Unless otherwise noted, the methods do not
check to see if the passed line number is in range and legal. It must
always be greater than zero and <= size().</I>
Each line contains a null-terminated string of text and a void *
data pointer. The text string is displayed, the void *
pointer can be used by the callbacks to reference the object the text
describes.
The base class does nothing when the user clicks on it. The
subclasses
Fl_Select_Browser,
Fl_Hold_Browser, and
Fl_Multi_Browser react to user clicks to select lines in
the browser and do callbacks.
The base class
Fl_Browser_ provides the scrolling and selection mechanisms of
this and all the subclasses, but the dimensions and appearance of each
item are determined by the subclass. You can use Fl_Browser_
to display information other than text, or text that is dynamically
produced from your own data structures. If you find that loading the
browser is a lot of work or is inefficient, you may want to make a
subclass of Fl_Browser_.
Some common coding patterns used for working with Fl_Browser:
\code
// How to loop through all the items in the browser
for ( int t=1; t<=browser->size(); t++ ) { // index 1 based..!
printf("item #%d, label='%s'\n", t, browser->text(t));
}
\endcode
Note: If you are <I>subclassing</I> Fl_Browser, it's more efficient
to use the protected methods item_first() and item_next(), since
Fl_Browser internally uses linked lists to manage the browser's items.
For more info, see find_item(int).
*/
class FL_EXPORT Fl_Browser : public Fl_Browser_ {
FL_BLINE *first; // the array of lines
FL_BLINE *last;
FL_BLINE *cache;
int cacheline; // line number of cache
int lines; // Number of lines
int full_height_;
const int* column_widths_;
char format_char_; // alternative to @-sign
char column_char_; // alternative to tab
protected:
// required routines for Fl_Browser_ subclass:
void* item_first() const FL_OVERRIDE;
void* item_next(void* item) const FL_OVERRIDE;
void* item_prev(void* item) const FL_OVERRIDE;
void* item_last()const FL_OVERRIDE;
int item_selected(void* item) const FL_OVERRIDE;
void item_select(void* item, int val) FL_OVERRIDE;
int item_height(void* item) const FL_OVERRIDE;
int item_width(void* item) const FL_OVERRIDE;
void item_draw(void* item, int X, int Y, int W, int H) const FL_OVERRIDE;
int full_height() const FL_OVERRIDE;
int incr_height() const FL_OVERRIDE;
const char *item_text(void *item) const FL_OVERRIDE;
/** Swap the items \p a and \p b.
You must call redraw() to make any changes visible.
\param[in] a,b the items to be swapped.
\see swap(int,int), item_swap()
*/
void item_swap(void *a, void *b) FL_OVERRIDE { swap((FL_BLINE*)a, (FL_BLINE*)b); }
/** Return the item at specified \p line.
\param[in] line The line of the item to return. (1 based)
\returns The item, or NULL if line out of range.
\see item_at(), find_line(), lineno()
*/
void *item_at(int line) const FL_OVERRIDE { return (void*)find_line(line); }
FL_BLINE* find_line(int line) const ;
FL_BLINE* _remove(int line) ;
void insert(int line, FL_BLINE* item);
int lineno(void *item) const ;
void swap(FL_BLINE *a, FL_BLINE *b);
public:
void remove(int line);
void add(const char* newtext, void* d = 0);
void insert(int line, const char* newtext, void* d = 0);
void move(int to, int from);
int load(const char* filename);
void swap(int a, int b);
void clear();
/**
Returns how many lines are in the browser.
The last line number is equal to this.
Returns 0 if browser is empty.
*/
int size() const { return lines; }
void size(int W, int H) { Fl_Widget::size(W, H); }
/**
Gets the default text size (in pixels) for the lines in the browser.
*/
Fl_Fontsize textsize() const { return Fl_Browser_::textsize(); }
/*
Sets the default text size for the lines in the browser to newSize.
Defined and documented in Fl_Browser.cxx
*/
void textsize(Fl_Fontsize newSize);
int topline() const ;
/** For internal use only? */
enum Fl_Line_Position { TOP, BOTTOM, MIDDLE };
void lineposition(int line, Fl_Line_Position pos);
/**
Scrolls the browser so the top item in the browser
is showing the specified \p line.
\param[in] line The line to be displayed at the top.
\see topline(), middleline(), bottomline(), displayed(), lineposition()
*/
void topline(int line) { lineposition(line, TOP); }
/**
Scrolls the browser so the bottom item in the browser
is showing the specified \p line.
\param[in] line The line to be displayed at the bottom.
\see topline(), middleline(), bottomline(), displayed(), lineposition()
*/
void bottomline(int line) { lineposition(line, BOTTOM); }
/**
Scrolls the browser so the middle item in the browser
is showing the specified \p line.
\param[in] line The line to be displayed in the middle.
\see topline(), middleline(), bottomline(), displayed(), lineposition()
*/
void middleline(int line) { lineposition(line, MIDDLE); }
int select(int line, int val=1);
int selected(int line) const ;
void show(int line);
/** Shows the entire Fl_Browser widget -- opposite of hide(). */
void show() FL_OVERRIDE { Fl_Widget::show(); }
void hide(int line);
/** Hides the entire Fl_Browser widget -- opposite of show(). */
void hide() FL_OVERRIDE { Fl_Widget::hide(); }
int visible(int line) const ;
int value() const ;
/**
Sets the browser's value(), which selects the specified \p line.
This is the same as calling select(line).
\see select(), selected(), value(), item_select(), item_selected()
*/
void value(int line) { select(line); }
const char* text(int line) const ;
void text(int line, const char* newtext);
void* data(int line) const ;
void data(int line, void* d);
Fl_Browser(int X, int Y, int W, int H, const char *L = 0);
/**
The destructor deletes all list items and destroys the browser.
*/
~Fl_Browser() { clear(); }
/**
Gets the current format code prefix character, which by default is '\@'.
A string of formatting codes at the start of each column are stripped off
and used to modify how the rest of the line is printed:
\li <tt>'\@.'</tt> Print rest of line, don't look for more '\@' signs
\li <tt>'\@\@'</tt> Doubling the format character prints the format
character once, followed by the rest of line
\li <tt>'\@l'</tt> Use a LARGE (24 point) font
\li <tt>'\@m'</tt> Use a medium large (18 point) font
\li <tt>'\@s'</tt> Use a <SMALL>small</SMALL> (11 point) font
\li <tt>'\@b'</tt> Use a <B>bold</B> font (adds FL_BOLD to font)
\li <tt>'\@i'</tt> Use an <I>italic</I> font (adds FL_ITALIC to font)
\li <tt>'\@f' or '\@t'</tt> Use a fixed-pitch
font (sets font to FL_COURIER)
\li <tt>'\@c'</tt> Center the line horizontally
\li <tt>'\@r'</tt> Right-justify the text
\li <tt>'\@N'</tt> Use fl_inactive_color() to draw the text
\li <tt>'\@B0', '\@B1', ... '\@B255'</tt> Fill the background with
fl_color(n)
\li <tt>'\@C0', '\@C1', ... '\@C255'</tt> Use fl_color(n) to draw the text
\li <tt>'\@F0', '\@F1', ...</tt> Use fl_font(n) to draw the text
\li <tt>'\@S1', '\@S2', ...</tt> Use point size n to draw the text
\li <tt>'\@u' or '\@_'</tt> Underline the text.
\li <tt>'\@-'</tt> draw an engraved line through the middle.
Notice that the '\@.' command can be used to reliably
terminate the parsing. To print a random string in a random color, use
<tt>sprintf("@C%d@.%s", color, string)</tt> and it will work even if the
string starts with a digit or has the format character in it.
*/
char format_char() const { return format_char_; }
/**
Sets the current format code prefix character to \p c.
The default prefix is '\@'. Set the prefix to 0 to disable formatting.
\see format_char() for list of '\@' codes
*/
void format_char(char c) { format_char_ = c; }
/**
Gets the current column separator character.
The default is '\\t' (tab).
\see column_char(), column_widths()
*/
char column_char() const { return column_char_; }
/**
Sets the column separator to c.
This will only have an effect if you also set column_widths().
The default is '\\t' (tab).
\see column_char(), column_widths()
*/
void column_char(char c) { column_char_ = c; }
/**
Gets the current column width array.
This array is zero-terminated and specifies the widths in pixels of
each column. The text is split at each column_char() and each part is
formatted into it's own column. After the last column any remaining
text is formatted into the space between the last column and the
right edge of the browser, even if the text contains instances of
column_char() . The default value is a one-element array of just
a zero, which means there are no columns.
Example:
\code
Fl_Browser *b = new Fl_Browser(..);
static int widths[] = { 50, 50, 50, 70, 70, 40, 40, 70, 70, 50, 0 }; // widths for each column
b->column_widths(widths); // assign array to widget
b->column_char('\t'); // use tab as the column character
b->add("USER\tPID\tCPU\tMEM\tVSZ\tRSS\tTTY\tSTAT\tSTART\tTIME\tCOMMAND");
b->add("root\t2888\t0.0\t0.0\t1352\t0\ttty3\tSW\tAug15\t0:00\t@b@f/sbin/mingetty tty3");
b->add("root\t13115\t0.0\t0.0\t1352\t0\ttty2\tSW\tAug30\t0:00\t@b@f/sbin/mingetty tty2");
[..]
\endcode
\see column_char(), column_widths()
*/
const int* column_widths() const { return column_widths_; }
/**
Sets the current array to \p arr. Make sure the last entry is zero.
\see column_char(), column_widths()
*/
void column_widths(const int* arr) { column_widths_ = arr; }
/**
Returns non-zero if \p line has been scrolled to a position where it is being displayed.
Checks to see if the item's vertical position is within the top and bottom
edges of the display window. This does NOT take into account the hide()/show()
status of the widget or item.
\param[in] line The line to be checked
\returns 1 if visible, 0 if not visible.
\see topline(), middleline(), bottomline(), displayed(), lineposition()
*/
int displayed(int line) const { return Fl_Browser_::displayed(find_line(line)); }
/**
Make the item at the specified \p line visible().
Functionally similar to show(int line).
If \p line is out of range, redisplay top or bottom of list as appropriate.
\param[in] line The line to be made visible.
\see show(int), hide(int), display(), visible(), make_visible()
*/
void make_visible(int line) {
if (line < 1) Fl_Browser_::display(find_line(1));
else if (line > lines) Fl_Browser_::display(find_line(lines));
else Fl_Browser_::display(find_line(line));
}
// icon support
void icon(int line, Fl_Image* icon);
Fl_Image* icon(int line) const;
void remove_icon(int line);
/** For back compatibility only. */
void replace(int a, const char* b) { text(a, b); }
void display(int line, int val=1);
};
#endif
================================================
FILE: Game Trainers/common/include/FL/Fl_Browser_.H
================================================
//
// Common browser header file for the Fast Light Tool Kit (FLTK).
//
// Copyright 1998-2016 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_Browser_ widget . */
// Yes, I know this should be a template...
#ifndef Fl_Browser__H
#define Fl_Browser__H
#ifndef Fl_Group_H
#include "Fl_Group.H"
#endif
#include "Fl_Scrollbar.H"
#include <FL/Fl.H> // Fl::scrollbar_size()
#define FL_NORMAL_BROWSER 0 /**< type() of Fl_Browser */
#define FL_SELECT_BROWSER 1 /**< type() of FL_Select_Browser */
#define FL_HOLD_BROWSER 2 /**< type() of Fl_Hold_Browser */
#define FL_MULTI_BROWSER 3 /**< type() of Fl_Multi_Browser */
#define FL_SORT_ASCENDING 0 /**< sort browser items in ascending alphabetic order. */
#define FL_SORT_DESCENDING 1 /**< sort in descending order */
#define FL_SORT_CASEINSENSITIVE 0x2 /**< sort case insensitively */
/**
This is the base class for browsers. To be useful it must be
subclassed and several virtual functions defined. The Forms-compatible
browser and the file chooser's browser are subclassed off of this.
This has been designed so that the subclass has complete control
over the storage of the data, although because next() and
prev() functions are used to index, it works best as a linked list
or as a large block of characters in which the line breaks must be
searched for.
A great deal of work has been done so that the "height" of a data
object does not need to be determined until it is drawn. This is
useful if actually figuring out the size of an object requires
accessing image data or doing stat() on a file or doing some
other slow operation.
Callbacks are called when the value changes with \p FL_REASON_CHANGED.
If \p FL_WHEN_RELEASE is set, callbacks are called when the mouse button is
released with \p FL_REASON_CHANGED or \p FL_REASON_RESELECTED if the selection
did not change. If \p FL_WHEN_ENTER_KEY is set, callbacks are also called when
key presses or double clicks change the selection.
Keyboard navigation of browser items
------------------------------------
The keyboard navigation of browser items is only possible if
visible_focus() is enabled. If disabled, the widget rejects keyboard focus;
Tab and Shift-Tab focus navigation will skip the widget.
In 'Select' and 'Normal' mode, the widget rejects keyboard focus;
no navigation keys are supported (other than scrollbar positioning).
In 'Hold' mode, the widget accepts keyboard focus, and Up/Down arrow
keys can navigate the selected item.
In 'Multi' mode, the widget accepts keyboard focus, and Up/Down arrow
keys navigate the focus box; Space toggles the current item's selection,
Enter selects only the current item (deselects all others). If Shift
(or Ctrl) is combined with Up/Down arrow keys, the current item's
selection state is extended to the next item. In this way one can
extend a selection or de-selection.
*/
class FL_EXPORT Fl_Browser_ : public Fl_Group {
int position_; // where user wants it scrolled to
int real_position_; // the current vertical scrolling position
int hposition_; // where user wants it panned to
int real_hposition_; // the current horizontal scrolling position
int offset_; // how far down top_ item the real_position is
int max_width; // widest object seen so far
uchar has_scrollbar_; // which scrollbars are enabled
Fl_Font textfont_;
Fl_Fontsize textsize_;
Fl_Color textcolor_;
void* top_; // which item scrolling position is in
void* selection_; // which is selected (except for FL_MULTI_BROWSER)
void *redraw1,*redraw2; // minimal update pointers
void* max_width_item; // which item has max_width_
int scrollbar_size_; // size of scrollbar trough
int linespacing_;
void update_top();
protected:
// All of the following must be supplied by the subclass:
/**
This method must be provided by the subclass
to return the first item in the list.
\see item_first(), item_next(), item_last(), item_prev()
*/
virtual void *item_first() const = 0;
/**
This method must be provided by the subclass
to return the item in the list after \p item.
\see item_first(), item_next(), item_last(), item_prev()
*/
virtual void *item_next(void *item) const = 0;
/**
This method must be provided by the subclass
to return the item in the list before \p item.
\see item_first(), item_next(), item_last(), item_prev()
*/
virtual void *item_prev(void *item) const = 0;
/**
This method must be provided by the subclass
to return the last item in the list.
\see item_first(), item_next(), item_last(), item_prev()
*/
virtual void *item_last() const { return 0L; }
/**
This method must be provided by the subclass to return
the height of \p item in pixels.
Allow for two additional pixels for the list selection box.
\param[in] item The item whose height is returned.
\returns The height of the specified \p item in pixels.
\see item_height(), item_width(), item_quick_height()
*/
virtual int item_height(void *item) const = 0;
/**
This method must be provided by the subclass to return the width of the
\p item in pixels. Allow for two additional pixels for the list
selection box.
\param[in] item The item whose width is returned.
\returns The width of the item in pixels.
*/
virtual int item_width(void *item) const = 0;
virtual int item_quick_height(void *item) const ;
/**
This method must be provided by the subclass to draw the \p item
in the area indicated by \p X, \p Y, \p W, \p H.
*/
virtual void item_draw(void *item,int X,int Y,int W,int H) const = 0;
/**
This optional method returns a string (label) that may be used for sorting.
\param[in] item The item whose label text is returned.
\returns The item's text label. (Can be NULL if blank)
*/
virtual const char *item_text(void *item) const { (void)item; return 0L; }
/**
This optional method should be provided by the subclass
to efficiently swap browser items \p a and \p b, such as for sorting.
\param[in] a,b The two items to be swapped.
*/
virtual void item_swap(void *a,void *b) { (void)a; (void)b; }
/**
This method must be provided by the subclass
to return the item for the specified \p index.
\param[in] index The \p index of the item to be returned
\returns The item at the specified \p index.
*/
virtual void *item_at(int index) const { (void)index; return 0L; }
// you don't have to provide these but it may help speed it up:
virtual int full_width() const ; // current width of all items
virtual int full_height() const ; // current height of all items
virtual int incr_height() const ; // average height of an item
// These only need to be done by subclass if you want a multi-browser:
virtual void item_select(void *item,int val=1);
virtual int item_selected(void *item) const ;
// things the subclass may want to call:
/**
Returns the item that appears at the top of the list.
*/
void *top() const { return top_; }
/**
Returns the item currently selected, or NULL if there is no selection.
For multiple selection browsers this call returns the currently focused item,
even if it is not selected. To find all selected items, call
Fl_Multi_Browser::selected() for every item in question.
*/
void *selection() const { return selection_; }
void new_list(); // completely clobber all data, as though list replaced
void deleting(void *item); // get rid of any pointers to item
void replacing(void *a,void *b); // change a pointers to b
void swapping(void *a,void *b); // exchange pointers a and b
void inserting(void *a,void *b); // insert b near a
int displayed(void *item) const ; // true if this item is visible
void redraw_line(void *item); // minimal update, no change in size
/**
This method will cause the entire list to be redrawn.
\see redraw_lines(), redraw_line()
*/
void redraw_lines() { damage(FL_DAMAGE_SCROLL); } // redraw all of them
void bbox(int &X,int &Y,int &W,int &H) const;
int leftedge() const; // x position after scrollbar & border
void *find_item(int ypos); // item under mouse
void draw() FL_OVERRIDE;
Fl_Browser_(int X,int Y,int W,int H,const char *L=0);
public:
/**
Vertical scrollbar. Public, so that it can be accessed directly.
Use `scrollbar_left()` or `scrollbar_right()` to change what side
the vertical scrollbar is drawn on.
Use `scrollbar.align(int)` (see `Fl_Widget::align(Fl_Align)`)
to change what side either of the scrollbars is drawn on.
If the `FL_ALIGN_LEFT` bit is on, the vertical scrollbar is on
the left. If the `FL_ALIGN_TOP` bit is on, the horizontal
scrollbar is on the top. Note that only the alignment flags in
scrollbar are considered. The flags in hscrollbar however
are ignored.
*/
Fl_Scrollbar scrollbar;
/**
Horizontal scrollbar. Public, so that it can be accessed directly.
*/
Fl_Scrollbar hscrollbar;
int handle(int event) FL_OVERRIDE;
void resize(int X,int Y,int W,int H) FL_OVERRIDE;
int select(void *item,int val=1,int docallbacks=0);
int select_only(void *item,int docallbacks=0);
int deselect(int docallbacks=0);
/**
Gets the vertical scroll position of the list as a pixel position \p pos.
The position returned is how many pixels of the list are scrolled off the top edge
of the screen. Example: A position of '3' indicates the top 3 pixels of
the list are scrolled off the top edge of the screen.
\see position(), hposition()
*/
int vposition() const { return position_; }
FL_DEPRECATED("since 1.4.0 - use vposition() instead",
int position() const) { return vposition(); }
void vposition(int pos); // scroll to here
FL_DEPRECATED("since 1.4.0 - use vposition(pos) instead",
void position(int pos)) { return vposition(pos); }
void position(int x, int y) { Fl_Group::position(x, y); }
/**
Gets the horizontal scroll position of the list as a pixel position \p pos.
The position returned is how many pixels of the list are scrolled off the left edge
of the screen. Example: A position of '18' indicates the left 18 pixels of
the list are scrolled off the left edge of the screen.
\see position(), hposition()
*/
int hposition() const { return hposition_; }
void hposition(int); // pan to here
void display(void *item); // scroll so this item is shown
/**
Values for has_scrollbar().
*/
/** Anonymous enum bit flags for has_scrollbar().
- bit 0: horizontal
- bit 1: vertical
- bit 2: 'always' (to be combined with bits 0 and 1)
- bit 3-31: reserved for future use
*/
enum { // values for has_scrollbar()
HORIZONTAL = 1, ///< Only show horizontal scrollbar.
VERTICAL = 2, ///< Only show vertical scrollbar.
BOTH = 3, ///< Show both scrollbars. (default)
ALWAYS_ON = 4, ///< Specified scrollbar(s) should 'always' be shown (to be used with HORIZONTAL/VERTICAL)
HORIZONTAL_ALWAYS = 5, ///< Horizontal scrollbar always on.
VERTICAL_ALWAYS = 6, ///< Vertical scrollbar always on.
BOTH_ALWAYS = 7 ///< Both scrollbars always on.
};
/**
Returns the current scrollbar mode, see Fl_Browser_::has_scrollbar(uchar)
*/
uchar has_scrollbar() const { return has_scrollbar_; }
/**
Sets whether the widget should have scrollbars or not (default Fl_Browser_::BOTH).
By default you can scroll in both directions, and the scrollbars
disappear if the data will fit in the widget.
has_scrollbar() changes this based on the value of \p mode:
- 0 - No scrollbars.
- Fl_Browser_::HORIZONTAL - Only a horizontal scrollbar.
- Fl_Browser_::VERTICAL - Only a vertical scrollbar.
- Fl_Browser_::BOTH - The default is both scrollbars.
- Fl_Browser_::HORIZONTAL_ALWAYS - Horizontal scrollbar always on,
vertical always off.
- Fl_Browser_::VERTICAL_ALWAYS - Vertical scrollbar always on,
horizontal always off.
- Fl_Browser_::BOTH_ALWAYS - Both always on.
*/
void has_scrollbar(uchar mode) { has_scrollbar_ = mode; }
/**
Gets the default text font for the lines in the browser.
\see textfont(), textsize(), textcolor()
*/
Fl_Font textfont() const { return textfont_; }
/**
Sets the default text font for the lines in the browser to \p font.
*/
void textfont(Fl_Font font) { textfont_ = font; }
/**
Gets the default text size (in pixels) for the lines in the browser.
*/
Fl_Fontsize textsize() const { return textsize_; }
/**
Sets the default text size (in pixels) for the lines in the browser to \p size.
*/
void textsize(Fl_Fontsize newSize) { textsize_ = newSize; }
/**
Gets the default text color for the lines in the browser.
*/
Fl_Color textcolor() const { return textcolor_; }
/**
Sets the default text color for the lines in the browser to color \p col.
*/
void textcolor(Fl_Color col) { textcolor_ = col; }
/**
Gets the current size of the scrollbars' troughs, in pixels.
If this value is zero (default), this widget will use the
Fl::scrollbar_size() value as the scrollbar's width.
\returns Scrollbar size in pixels, or 0 if the global Fl::scrollbar_size() is being used.
\see Fl::scrollbar_size(int)
*/
int scrollbar_size() const {
return(scrollbar_size_);
}
/**
Sets the pixel size of the scrollbars' troughs to \p newSize, in pixels.
Normally you should not need this method, and should use
Fl::scrollbar_size(int) instead to manage the size of ALL
your widgets' scrollbars. This ensures your application
has a consistent UI, is the default behavior, and is normally
what you want.
Only use THIS method if you really need to override the global
scrollbar size. The need for this should be rare.
Setting \p newSize to the special value of 0 causes the widget to
track the global Fl::scrollbar_size(), which is the default.
\param[in] newSize Sets the scrollbar size in pixels.\n
If 0 (default), scrollbar size tracks the global Fl::scrollbar_size()
\see Fl::scrollbar_size()
*/
void scrollbar_size(int newSize) {
scrollbar_size_ = newSize;
}
/**
Returns the global value Fl::scrollbar_size().
\deprecated Use scrollbar_size() instead.
\todo This method should eventually be removed in 1.4+
*/
int scrollbar_width() const {
return(Fl::scrollbar_size());
}
/**
Sets the global Fl::scrollbar_size(), and forces this instance of the widget to use it.
\deprecated Use scrollbar_size() instead.
\todo This method should eventually be removed in 1.4+
*/
void scrollbar_width(int width) {
Fl::scrollbar_size(width);
scrollbar_size_ = 0;
}
/**
Moves the vertical scrollbar to the righthand side of the list.
For back compatibility.
*/
void scrollbar_right() { scrollbar.align(FL_ALIGN_RIGHT); }
/**
Moves the vertical scrollbar to the lefthand side of the list.
For back compatibility.
*/
void scrollbar_left() { scrollbar.align(FL_ALIGN_LEFT); }
void sort(int flags=0);
/**
Add some space between browser lines.
\param[in] pixels number of additional pixels between lines.
*/
void linespacing(int pixels) { linespacing_ = pixels; }
/** Return the height of additional spacing between browser lines.
\return spacing height in pixel units.
*/
int linespacing() const { return linespacing_; }
};
#endif
================================================
FILE: Game Trainers/common/include/FL/Fl_Button.H
================================================
//
// Button header file for the Fast Light Tool Kit (FLTK).
//
// Copyright 1998-2014 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_Button widget . */
#ifndef Fl_Button_H
#define Fl_Button_H
#ifndef Fl_Widget_H
#include "Fl_Widget.H"
#endif
// values for type()
#define FL_NORMAL_BUTTON 0 /**< value() will be set to 1 during the press of the button and
reverts back to 0 when the button is released */
#define FL_TOGGLE_BUTTON 1 ///< value() toggles between 0 and 1 at every click of the button
#define FL_RADIO_BUTTON (FL_RESERVED_TYPE+2) /**< is set to 1 at button press, and all other
buttons in the same group with <tt>type() == FL_RADIO_BUTTON</tt>
are set to zero.*/
#define FL_HIDDEN_BUTTON 3 ///< for Forms compatibility
extern FL_EXPORT Fl_Shortcut fl_old_shortcut(const char*);
class Fl_Widget_Tracker;
/**
\class Fl_Button
\brief Buttons generate callbacks when they are clicked by the user.
You control exactly when and how by changing the values for type(uchar) and
when(uchar). Buttons can also generate callbacks in response to \c FL_SHORTCUT
events. The button can either have an explicit shortcut(int s) value or a
letter shortcut can be indicated in the label() with an '\&' character
before it. For the label shortcut it does not matter if \e Alt is held
down, but if you have an input field in the same window, the user will have
to hold down the \e Alt key so that the input field does not eat the event
first as an \c FL_KEYBOARD event.
\see Fl_Widget::shortcut_label(int)
For an Fl_Button object, the type() call returns one of:
\li \c FL_NORMAL_BUTTON (0): value() remains unchanged after button press.
\li \c FL_TOGGLE_BUTTON: value() is inverted after button press.
\li \c FL_RADIO_BUTTON: value() is set to 1 after button press, and all other
buttons in the current group with <tt>type() == FL_RADIO_BUTTON</tt>
are set to zero.
For an Fl_Button object, the following when() values are useful, the default
being \c FL_WHEN_RELEASE:
\li \c 0: The callback is not done, instead changed() is turned on.
\li \c FL_WHEN_RELEASE: The callback is done after the user successfully
clicks the button, or when a shortcut is typed. The reason is
\p FL_REASON_RELEASED.
\li \c FL_WHEN_CHANGED: The callback is done each time the value() changes
(when the user pushes and releases the button, and as the mouse is
dragged around in and out of the button). The reason is set to
\p FL_REASON_CHANGED
\li \c FL_WHEN_NOT_CHANGED: The callback is done when the mouse button is
released, but the value did not changed. The reason is set to
\p FL_REASON_SELECTED
*/
class FL_EXPORT Fl_Button : public Fl_Widget {
int shortcut_;
char value_;
char oldval;
uchar down_box_;
uchar compact_;
protected:
static Fl_Widget_Tracker *key_release_tracker;
static void key_release_timeout(void*);
void simulate_key_action();
void draw() FL_OVERRIDE;
public:
int handle(int) FL_OVERRIDE;
Fl_Button(int X, int Y, int W, int H, const char *L = 0);
int value(int v);
/**
Returns the current value of the button (0 or 1).
*/
char value() const {return value_;}
/**
Same as \c value(1).
\see value(int v)
*/
int set() {return value(1);}
/**
Same as \c value(0).
\see value(int v)
*/
int clear() {return value(0);}
void setonly(); // this should only be called on FL_RADIO_BUTTONs
/**
Returns the current shortcut key for the button.
\retval int
*/
int shortcut() co
gitextract_g3w1hlj3/
├── .github/
│ └── workflows/
│ └── Release to server.yml
├── .gitignore
├── Game Trainers/
│ ├── .gitignore
│ ├── CMakeLists.txt
│ ├── common/
│ │ ├── CMakeLists.txt
│ │ ├── assets/
│ │ │ ├── elevate.xml
│ │ │ └── logo.psd
│ │ ├── include/
│ │ │ ├── CDPBase.h
│ │ │ ├── FL/
│ │ │ │ ├── Enumerations.H
│ │ │ │ ├── Fl.H
│ │ │ │ ├── Fl_Adjuster.H
│ │ │ │ ├── Fl_Anim_GIF_Image.H
│ │ │ │ ├── Fl_BMP_Image.H
│ │ │ │ ├── Fl_Bitmap.H
│ │ │ │ ├── Fl_Box.H
│ │ │ │ ├── Fl_Browser.H
│ │ │ │ ├── Fl_Browser_.H
│ │ │ │ ├── Fl_Button.H
│ │ │ │ ├── Fl_Cairo.H
│ │ │ │ ├── Fl_Cairo_Window.H
│ │ │ │ ├── Fl_Chart.H
│ │ │ │ ├── Fl_Check_Browser.H
│ │ │ │ ├── Fl_Check_Button.H
│ │ │ │ ├── Fl_Choice.H
│ │ │ │ ├── Fl_Clock.H
│ │ │ │ ├── Fl_Color_Chooser.H
│ │ │ │ ├── Fl_Copy_Surface.H
│ │ │ │ ├── Fl_Counter.H
│ │ │ │ ├── Fl_Device.H
│ │ │ │ ├── Fl_Dial.H
│ │ │ │ ├── Fl_Double_Window.H
│ │ │ │ ├── Fl_Export.H
│ │ │ │ ├── Fl_File_Browser.H
│ │ │ │ ├── Fl_File_Chooser.H
│ │ │ │ ├── Fl_File_Icon.H
│ │ │ │ ├── Fl_File_Input.H
│ │ │ │ ├── Fl_Fill_Dial.H
│ │ │ │ ├── Fl_Fill_Slider.H
│ │ │ │ ├── Fl_Flex.H
│ │ │ │ ├── Fl_Float_Input.H
│ │ │ │ ├── Fl_FormsBitmap.H
│ │ │ │ ├── Fl_FormsPixmap.H
│ │ │ │ ├── Fl_Free.H
│ │ │ │ ├── Fl_GIF_Image.H
│ │ │ │ ├── Fl_Gl_Window.H
│ │ │ │ ├── Fl_Graphics_Driver.H
│ │ │ │ ├── Fl_Grid.H
│ │ │ │ ├── Fl_Group.H
│ │ │ │ ├── Fl_Help_Dialog.H
│ │ │ │ ├── Fl_Help_View.H
│ │ │ │ ├── Fl_Hold_Browser.H
│ │ │ │ ├── Fl_Hor_Fill_Slider.H
│ │ │ │ ├── Fl_Hor_Nice_Slider.H
│ │ │ │ ├── Fl_Hor_Slider.H
│ │ │ │ ├── Fl_Hor_Value_Slider.H
│ │ │ │ ├── Fl_ICO_Image.H
│ │ │ │ ├── Fl_Image.H
│ │ │ │ ├── Fl_Image_Surface.H
│ │ │ │ ├── Fl_Input.H
│ │ │ │ ├── Fl_Input_.H
│ │ │ │ ├── Fl_Input_Choice.H
│ │ │ │ ├── Fl_Int_Input.H
│ │ │ │ ├── Fl_JPEG_Image.H
│ │ │ │ ├── Fl_Light_Button.H
│ │ │ │ ├── Fl_Line_Dial.H
│ │ │ │ ├── Fl_Menu.H
│ │ │ │ ├── Fl_Menu_.H
│ │ │ │ ├── Fl_Menu_Bar.H
│ │ │ │ ├── Fl_Menu_Button.H
│ │ │ │ ├── Fl_Menu_Item.H
│ │ │ │ ├── Fl_Menu_Window.H
│ │ │ │ ├── Fl_Multi_Browser.H
│ │ │ │ ├── Fl_Multi_Label.H
│ │ │ │ ├── Fl_Multiline_Input.H
│ │ │ │ ├── Fl_Multiline_Output.H
│ │ │ │ ├── Fl_Native_File_Chooser.H
│ │ │ │ ├── Fl_Nice_Slider.H
│ │ │ │ ├── Fl_Object.H
│ │ │ │ ├── Fl_Output.H
│ │ │ │ ├── Fl_Overlay_Window.H
│ │ │ │ ├── Fl_PDF_File_Surface.H
│ │ │ │ ├── Fl_PNG_Image.H
│ │ │ │ ├── Fl_PNM_Image.H
│ │ │ │ ├── Fl_Pack.H
│ │ │ │ ├── Fl_Paged_Device.H
│ │ │ │ ├── Fl_Pixmap.H
│ │ │ │ ├── Fl_Plugin.H
│ │ │ │ ├── Fl_Positioner.H
│ │ │ │ ├── Fl_PostScript.H
│ │ │ │ ├── Fl_Preferences.H
│ │ │ │ ├── Fl_Printer.H
│ │ │ │ ├── Fl_Progress.H
│ │ │ │ ├── Fl_RGB_Image.H
│ │ │ │ ├── Fl_Radio_Button.H
│ │ │ │ ├── Fl_Radio_Light_Button.H
│ │ │ │ ├── Fl_Radio_Round_Button.H
│ │ │ │ ├── Fl_Rect.H
│ │ │ │ ├── Fl_Repeat_Button.H
│ │ │ │ ├── Fl_Return_Button.H
│ │ │ │ ├── Fl_Roller.H
│ │ │ │ ├── Fl_Round_Button.H
│ │ │ │ ├── Fl_Round_Clock.H
│ │ │ │ ├── Fl_SVG_File_Surface.H
│ │ │ │ ├── Fl_SVG_Image.H
│ │ │ │ ├── Fl_Scheme.H
│ │ │ │ ├── Fl_Scheme_Choice.H
│ │ │ │ ├── Fl_Scroll.H
│ │ │ │ ├── Fl_Scrollbar.H
│ │ │ │ ├── Fl_Secret_Input.H
│ │ │ │ ├── Fl_Select_Browser.H
│ │ │ │ ├── Fl_Shared_Image.H
│ │ │ │ ├── Fl_Shortcut_Button.H
│ │ │ │ ├── Fl_Simple_Counter.H
│ │ │ │ ├── Fl_Single_Window.H
│ │ │ │ ├── Fl_Slider.H
│ │ │ │ ├── Fl_Spinner.H
│ │ │ │ ├── Fl_Sys_Menu_Bar.H
│ │ │ │ ├── Fl_Table.H
│ │ │ │ ├── Fl_Table_Row.H
│ │ │ │ ├── Fl_Tabs.H
│ │ │ │ ├── Fl_Terminal.H
│ │ │ │ ├── Fl_Text_Buffer.H
│ │ │ │ ├── Fl_Text_Display.H
│ │ │ │ ├── Fl_Text_Editor.H
│ │ │ │ ├── Fl_Tile.H
│ │ │ │ ├── Fl_Tiled_Image.H
│ │ │ │ ├── Fl_Timer.H
│ │ │ │ ├── Fl_Toggle_Button.H
│ │ │ │ ├── Fl_Toggle_Light_Button.H
│ │ │ │ ├── Fl_Toggle_Round_Button.H
│ │ │ │ ├── Fl_Tooltip.H
│ │ │ │ ├── Fl_Tree.H
│ │ │ │ ├── Fl_Tree_Item.H
│ │ │ │ ├── Fl_Tree_Item_Array.H
│ │ │ │ ├── Fl_Tree_Prefs.H
│ │ │ │ ├── Fl_Valuator.H
│ │ │ │ ├── Fl_Value_Input.H
│ │ │ │ ├── Fl_Value_Output.H
│ │ │ │ ├── Fl_Value_Slider.H
│ │ │ │ ├── Fl_Widget.H
│ │ │ │ ├── Fl_Widget_Surface.H
│ │ │ │ ├── Fl_Window.H
│ │ │ │ ├── Fl_Wizard.H
│ │ │ │ ├── Fl_XBM_Image.H
│ │ │ │ ├── Fl_XPM_Image.H
│ │ │ │ ├── Makefile.in
│ │ │ │ ├── README.Xcode
│ │ │ │ ├── filename.H
│ │ │ │ ├── fl_ask.H
│ │ │ │ ├── fl_attr.h
│ │ │ │ ├── fl_callback_macros.H
│ │ │ │ ├── fl_casts.H
│ │ │ │ ├── fl_config.h
│ │ │ │ ├── fl_draw.H
│ │ │ │ ├── fl_message.H
│ │ │ │ ├── fl_show_colormap.H
│ │ │ │ ├── fl_show_input.H
│ │ │ │ ├── fl_string_functions.h
│ │ │ │ ├── fl_types.h
│ │ │ │ ├── fl_utf8.h
│ │ │ │ ├── forms.H
│ │ │ │ ├── gl.h
│ │ │ │ ├── gl2opengl.h
│ │ │ │ ├── gl_draw.H
│ │ │ │ ├── glu.h
│ │ │ │ ├── glut.H
│ │ │ │ ├── mac.H
│ │ │ │ ├── math.h
│ │ │ │ ├── names.h
│ │ │ │ ├── platform.H
│ │ │ │ ├── platform_types.h
│ │ │ │ ├── wayland.H
│ │ │ │ ├── win32.H
│ │ │ │ ├── x.H
│ │ │ │ └── x11.H
│ │ │ ├── FLTKUtils.h
│ │ │ ├── Il2CppBase.h
│ │ │ ├── MinHook.h
│ │ │ ├── MonoBase.h
│ │ │ ├── MonoBridge.cpp
│ │ │ ├── MonoBridge.def
│ │ │ ├── TrainerBase.h
│ │ │ ├── il2cpp/
│ │ │ │ ├── hook.h
│ │ │ │ ├── il2cpp.cpp
│ │ │ │ ├── il2cpp.h
│ │ │ │ ├── il2cpp_api.h
│ │ │ │ ├── il2cpp_types.h
│ │ │ │ ├── memory.h
│ │ │ │ ├── unity.cpp
│ │ │ │ ├── unity.h
│ │ │ │ └── vec.h
│ │ │ └── nlohmann/
│ │ │ ├── adl_serializer.hpp
│ │ │ ├── byte_container_with_subtype.hpp
│ │ │ ├── detail/
│ │ │ │ ├── abi_macros.hpp
│ │ │ │ ├── conversions/
│ │ │ │ │ ├── from_json.hpp
│ │ │ │ │ ├── to_chars.hpp
│ │ │ │ │ └── to_json.hpp
│ │ │ │ ├── exceptions.hpp
│ │ │ │ ├── hash.hpp
│ │ │ │ ├── input/
│ │ │ │ │ ├── binary_reader.hpp
│ │ │ │ │ ├── input_adapters.hpp
│ │ │ │ │ ├── json_sax.hpp
│ │ │ │ │ ├── lexer.hpp
│ │ │ │ │ ├── parser.hpp
│ │ │ │ │ └── position_t.hpp
│ │ │ │ ├── iterators/
│ │ │ │ │ ├── internal_iterator.hpp
│ │ │ │ │ ├── iter_impl.hpp
│ │ │ │ │ ├── iteration_proxy.hpp
│ │ │ │ │ ├── iterator_traits.hpp
│ │ │ │ │ ├── json_reverse_iterator.hpp
│ │ │ │ │ └── primitive_iterator.hpp
│ │ │ │ ├── json_custom_base_class.hpp
│ │ │ │ ├── json_pointer.hpp
│ │ │ │ ├── json_ref.hpp
│ │ │ │ ├── macro_scope.hpp
│ │ │ │ ├── macro_unscope.hpp
│ │ │ │ ├── meta/
│ │ │ │ │ ├── call_std/
│ │ │ │ │ │ ├── begin.hpp
│ │ │ │ │ │ └── end.hpp
│ │ │ │ │ ├── cpp_future.hpp
│ │ │ │ │ ├── detected.hpp
│ │ │ │ │ ├── identity_tag.hpp
│ │ │ │ │ ├── is_sax.hpp
│ │ │ │ │ ├── std_fs.hpp
│ │ │ │ │ ├── type_traits.hpp
│ │ │ │ │ └── void_t.hpp
│ │ │ │ ├── output/
│ │ │ │ │ ├── binary_writer.hpp
│ │ │ │ │ ├── output_adapters.hpp
│ │ │ │ │ └── serializer.hpp
│ │ │ │ ├── string_concat.hpp
│ │ │ │ ├── string_escape.hpp
│ │ │ │ ├── string_utils.hpp
│ │ │ │ └── value_t.hpp
│ │ │ ├── json.hpp
│ │ │ ├── json_fwd.hpp
│ │ │ ├── ordered_map.hpp
│ │ │ └── thirdparty/
│ │ │ └── hedley/
│ │ │ ├── hedley.hpp
│ │ │ └── hedley_undef.hpp
│ │ └── libs/
│ │ ├── x64/
│ │ │ ├── fltk.lib
│ │ │ ├── fltk_forms.lib
│ │ │ ├── fltk_gl.lib
│ │ │ ├── fltk_images.lib
│ │ │ ├── fltk_jpeg.lib
│ │ │ ├── fltk_png.lib
│ │ │ ├── fltk_z.lib
│ │ │ └── libMinHook.x64.lib
│ │ └── x86/
│ │ ├── fltk.lib
│ │ ├── fltk_forms.lib
│ │ ├── fltk_gl.lib
│ │ ├── fltk_images.lib
│ │ ├── fltk_jpeg.lib
│ │ ├── fltk_png.lib
│ │ ├── fltk_z.lib
│ │ └── libMinHook.x86.lib
│ ├── documents/
│ │ └── trainer_template.h
│ ├── scripts/
│ │ ├── font_processor.py
│ │ ├── gcm_trainers.json
│ │ └── requirements.txt
│ └── trainers/
│ ├── Arrow a Row Trainer/
│ │ ├── CMakeLists.txt
│ │ ├── main.cpp
│ │ ├── resources.rc
│ │ ├── trainer.h
│ │ └── translations.json
│ ├── DREDGE Trainer/
│ │ ├── CMakeLists.txt
│ │ ├── GCMInjection.cs
│ │ ├── GCMInjection.csproj
│ │ ├── main.cpp
│ │ ├── resources.rc
│ │ ├── trainer.h
│ │ ├── translation_extra.txt
│ │ └── translations.json
│ ├── Feeding Frenzy 2_Shipwreck Showdown Trainer/
│ │ ├── CMakeLists.txt
│ │ ├── main.cpp
│ │ ├── resources.rc
│ │ ├── trainer.h
│ │ └── translations.json
│ ├── Headbangers_Rhythm Royale Trainer/
│ │ ├── CMakeLists.txt
│ │ ├── main.cpp
│ │ ├── resources.rc
│ │ ├── trainer.h
│ │ └── translations.json
│ ├── Heavy Weapon Trainer/
│ │ ├── CMakeLists.txt
│ │ ├── main.cpp
│ │ ├── resources.rc
│ │ ├── trainer.h
│ │ └── translations.json
│ ├── Inotia 4 Trainer/
│ │ ├── CMakeLists.txt
│ │ ├── main.cpp
│ │ ├── resources.rc
│ │ ├── trainer.h
│ │ └── translations.json
│ ├── Just Shapes & Beats Trainer/
│ │ ├── CMakeLists.txt
│ │ ├── IL2CPP.cpp
│ │ ├── main.cpp
│ │ ├── resources.rc
│ │ ├── trainer.h
│ │ └── translations.json
│ ├── Oil Rush Trainer/
│ │ ├── CMakeLists.txt
│ │ ├── main.cpp
│ │ ├── resources.rc
│ │ ├── trainer.h
│ │ └── translations.json
│ ├── Outland Trainer/
│ │ ├── CMakeLists.txt
│ │ ├── main.cpp
│ │ ├── resources.rc
│ │ ├── trainer.h
│ │ └── translations.json
│ ├── Plants vs. Zombies_GOTY Edition Trainer/
│ │ ├── CMakeLists.txt
│ │ ├── main.cpp
│ │ ├── resources.rc
│ │ ├── trainer.h
│ │ └── translations.json
│ ├── Plants vs. Zombies_Replanted Trainer/
│ │ ├── CMakeLists.txt
│ │ ├── IL2CPP.cpp
│ │ ├── main.cpp
│ │ ├── resources.rc
│ │ ├── trainer.h
│ │ ├── translation_extra.txt
│ │ └── translations.json
│ ├── PvZ2 Gardendless Trainer/
│ │ ├── CMakeLists.txt
│ │ ├── main.cpp
│ │ ├── resources.rc
│ │ ├── trainer.h
│ │ └── translations.json
│ └── Wizard of Legend 2 Trainer/
│ ├── CMakeLists.txt
│ ├── main.cpp
│ ├── resources.rc
│ ├── trainer.h
│ └── translations.json
├── LICENSE.txt
├── README.md
├── README_CN.md
├── README_TW.md
├── requirements.txt
└── src/
├── dependency/
│ ├── CE Translations/
│ │ └── zh_CN/
│ │ ├── Java.po
│ │ ├── SaveSessions.po
│ │ ├── Tutorial-x86_64.po
│ │ ├── VersionCheck.po
│ │ ├── cheatengine-x86_64.po
│ │ ├── lclstrconsts.po
│ │ ├── monoscript.po
│ │ ├── patchscan.po
│ │ └── pseudocodediagram.po
│ └── TrainerBGM.mid
├── locale/
│ ├── de_DE/
│ │ └── LC_MESSAGES/
│ │ └── Game Cheats Manager.po
│ ├── en_US/
│ │ └── LC_MESSAGES/
│ │ └── Game Cheats Manager.po
│ ├── zh_CN/
│ │ └── LC_MESSAGES/
│ │ └── Game Cheats Manager.po
│ └── zh_TW/
│ └── LC_MESSAGES/
│ └── Game Cheats Manager.po
└── scripts/
├── config.py
├── main.py
├── style_sheet.py
├── threads/
│ ├── download_base_thread.py
│ ├── download_display_thread.py
│ ├── download_trainers_thread.py
│ ├── other_threads.py
│ └── update_trainers_thread.py
└── widgets/
├── custom_dialogs.py
├── custom_widgets.py
└── trainer_management.py
SYMBOL INDEX (2261 symbols across 197 files)
FILE: Game Trainers/common/include/CDPBase.h
function CDPLaunchMethod (line 24) | enum class CDPLaunchMethod
FILE: Game Trainers/common/include/FL/Enumerations.H
type Fl_Event (line 198) | enum Fl_Event { // events
type Fl_When (line 428) | enum Fl_When { // Fl_Widget::when():
type Fl_Callback_Reason (line 448) | enum Fl_Callback_Reason {
type Fl_Boxtype (line 637) | enum Fl_Boxtype { // boxtypes (if you change these you must also change ...
function Fl_Boxtype (line 789) | inline Fl_Boxtype fl_box(Fl_Boxtype b) {
function Fl_Boxtype (line 797) | inline Fl_Boxtype fl_down(Fl_Boxtype b) {
function Fl_Boxtype (line 805) | inline Fl_Boxtype fl_frame(Fl_Boxtype b) {
type Fl_Labeltype (line 828) | enum Fl_Labeltype { // labeltypes:
type Fl_Align (line 979) | typedef unsigned Fl_Align;
type Fl_Font (line 1056) | typedef int Fl_Font;
type Fl_Fontsize (line 1085) | typedef int Fl_Fontsize;
type Fl_Color (line 1113) | typedef unsigned int Fl_Color;
type Fl_Color (line 1189) | typedef Fl_Color (Fl_Contrast_Function)(Fl_Color, Fl_Color, int, int);
type Fl_Contrast_Mode (line 1196) | enum Fl_Contrast_Mode {
function Fl_Color (line 1221) | inline Fl_Color fl_lighter(Fl_Color c) { return fl_color_average(c, FL_W...
function Fl_Color (line 1224) | inline Fl_Color fl_darker(Fl_Color c) { return fl_color_average(c, FL_BL...
function Fl_Color (line 1227) | inline Fl_Color fl_rgb_color(uchar r, uchar g, uchar b) {
function Fl_Color (line 1233) | inline Fl_Color fl_rgb_color(uchar g) {
function Fl_Color (line 1246) | inline Fl_Color fl_gray_ramp(int i) {return (Fl_Color)(i+FL_GRAY_RAMP);}
function Fl_Color (line 1262) | inline Fl_Color fl_color_cube(int r, int g, int b) {
type Fl_Cursor (line 1276) | enum Fl_Cursor {
type Fl_Mode (line 1312) | enum Fl_Mode {
type Fl_Damage (line 1333) | enum Fl_Damage {
type Fl_Arrow_Type (line 1357) | enum Fl_Arrow_Type {
type Fl_Orientation (line 1386) | enum Fl_Orientation {
FILE: Game Trainers/common/include/FL/Fl.H
type Fl_Label (line 52) | struct Fl_Label
function class (line 140) | class FL_EXPORT Fl {
function class (line 1575) | class FL_EXPORT Fl_Widget_Tracker {
FILE: Game Trainers/common/include/FL/Fl_Adjuster.H
function soft (line 57) | void soft(int s) {soft_ = s;}
FILE: Game Trainers/common/include/FL/Fl_Anim_GIF_Image.H
type Flags (line 37) | enum Flags {
function valid (line 90) | bool valid() const;
function Fl_Image (line 132) | Fl_Image *copy() const { return Fl_Pixmap::copy(); }
FILE: Game Trainers/common/include/FL/Fl_Bitmap.H
type Fl_Menu_Item (line 26) | struct Fl_Menu_Item
function Fl_Image (line 58) | Fl_Image *copy() const { return Fl_Image::copy(); }
function draw (line 60) | void draw(int X, int Y) {draw(X, Y, w(), h(), 0, 0);}
function cache_w (line 64) | int cache_w() {return cache_w_;}
function cache_h (line 65) | int cache_h() {return cache_h_;}
FILE: Game Trainers/common/include/FL/Fl_Browser.H
type FL_BLINE (line 30) | struct FL_BLINE
function full_height (line 110) | int full_height() const FL_OVERRIDE;
function size (line 148) | void size(int W, int H) { Fl_Widget::size(W, H); }
function Fl_Fontsize (line 153) | Fl_Fontsize textsize() const { return Fl_Browser_::textsize(); }
function bottomline (line 178) | void bottomline(int line) { lineposition(line, BOTTOM); }
function middleline (line 185) | void middleline(int line) { lineposition(line, MIDDLE); }
function show (line 191) | void show() FL_OVERRIDE { Fl_Widget::show(); }
function hide (line 194) | void hide() FL_OVERRIDE { Fl_Widget::hide(); }
function value (line 197) | int value() const ;
function format_char (line 252) | void format_char(char c) { format_char_ = c; }
function column_char (line 265) | void column_char(char c) { column_char_ = c; }
function column_widths (line 294) | void column_widths(const int* arr) { column_widths_ = arr; }
function displayed (line 305) | int displayed(int line) const { return Fl_Browser_::displayed(find_line(...
function make_visible (line 314) | void make_visible(int line) {
function replace (line 326) | void replace(int a, const char* b) { text(a, b); }
FILE: Game Trainers/common/include/FL/Fl_Browser_.H
function virtual (line 129) | virtual void *item_last() const { return 0L; }
function virtual (line 158) | virtual const char *item_text(void *item) const { (void)item; return 0L; }
function virtual (line 164) | virtual void item_swap(void *a,void *b) { (void)a; (void)b; }
function virtual (line 171) | virtual void *item_at(int index) const { (void)index; return 0L; }
function virtual (line 173) | virtual int full_width() const ; // current width of all items
function redraw_lines (line 204) | void redraw_lines() { damage(FL_DAMAGE_SCROLL); }
function leftedge (line 206) | int leftedge() const; // x position after scrollbar & border
function position (line 255) | void position(int x, int y) { Fl_Group::position(x, y); }
function has_scrollbar (line 312) | void has_scrollbar(uchar mode) { has_scrollbar_ = mode; }
function textfont (line 322) | void textfont(Fl_Font font) { textfont_ = font; }
function textsize (line 331) | void textsize(Fl_Fontsize newSize) { textsize_ = newSize; }
function textcolor (line 340) | void textcolor(Fl_Color col) { textcolor_ = col; }
function scrollbar_size (line 373) | void scrollbar_size(int newSize) {
function scrollbar_width (line 389) | void scrollbar_width(int width) {
function scrollbar_right (line 397) | void scrollbar_right() { scrollbar.align(FL_ALIGN_RIGHT); }
function scrollbar_left (line 402) | void scrollbar_left() { scrollbar.align(FL_ALIGN_LEFT); }
function linespacing (line 409) | void linespacing(int pixels) { linespacing_ = pixels; }
FILE: Game Trainers/common/include/FL/Fl_Button.H
function set (line 109) | int set() {return value(1);}
function clear (line 115) | int clear() {return value(0);}
function shortcut (line 144) | void shortcut(int s) {shortcut_ = s;}
function down_box (line 161) | void down_box(Fl_Boxtype b) {down_box_ = b;}
function shortcut (line 164) | void shortcut(const char *s) {shortcut(fl_old_shortcut(s));}
function down_color (line 170) | void down_color(unsigned c) {selection_color(c);}
function uchar (line 178) | uchar compact() { return compact_; }
FILE: Game Trainers/common/include/FL/Fl_Cairo.H
function class (line 56) | class FL_EXPORT Fl_Cairo_State {
function window (line 85) | void window(void *w) { window_ = w; }
function gc (line 87) | void gc(void *c) { gc_ = c; }
FILE: Game Trainers/common/include/FL/Fl_Cairo_Window.H
function set_draw_cb (line 119) | void set_draw_cb(cairo_draw_cb cb) { draw_cb_ = cb; }
FILE: Game Trainers/common/include/FL/Fl_Chart.H
type FL_CHART_ENTRY (line 43) | struct FL_CHART_ENTRY {
function bounds (line 119) | void bounds(double *a, double *b) const {
function size (line 138) | void size(int W, int H) { Fl_Widget::size(W, H); }
function textfont (line 151) | void textfont(Fl_Font s) { textfont_ = s; }
function textsize (line 157) | void textsize(Fl_Fontsize s) { textsize_ = s; }
function textcolor (line 163) | void textcolor(Fl_Color n) { textcolor_ = n; }
function autosize (line 175) | void autosize(uchar n) { autosize_ = n; }
FILE: Game Trainers/common/include/FL/Fl_Check_Browser.H
type cb_item (line 55) | struct cb_item {
function add (line 85) | int add(const char *s) { return add((char *)s); }
function add (line 87) | int add(const char *s, int b) { return add((char *)s, b); }
function set_checked (line 100) | void set_checked(int item) { checked(item, 1); }
FILE: Game Trainers/common/include/FL/Fl_Clock.H
function shadow (line 127) | void shadow(int mode) { shadow_ = mode ? 1 : 0; }
FILE: Game Trainers/common/include/FL/Fl_Color_Chooser.H
function mode (line 133) | int mode() {return choice.value();}
FILE: Game Trainers/common/include/FL/Fl_Counter.H
function lstep (line 73) | void lstep(double a) {lstep_ = a;}
function step (line 79) | void step(double a,double b) {Fl_Valuator::step(a); lstep_ = b;}
function step (line 85) | void step(double a) {Fl_Valuator::step(a);}
function step (line 90) | double step() const {return Fl_Valuator::step();}
function textfont (line 95) | void textfont(Fl_Font s) {textfont_ = s;}
function textsize (line 100) | void textsize(Fl_Fontsize s) {textsize_ = s;}
function textcolor (line 105) | void textcolor(Fl_Color s) {textcolor_ = s;}
FILE: Game Trainers/common/include/FL/Fl_Device.H
function class (line 57) | class FL_EXPORT Fl_Surface_Device {
function driver (line 71) | inline void driver(Fl_Graphics_Driver *graphics_driver) {pGraphicsDriver...
function Fl_Graphics_Driver (line 76) | inline Fl_Graphics_Driver *driver() {return pGraphicsDriver; }
function Fl_Surface_Device (line 81) | static inline Fl_Surface_Device *surface() {
function class (line 108) | class Fl_Device_Plugin : public Fl_Plugin {
FILE: Game Trainers/common/include/FL/Fl_Dial.H
function angle1 (line 72) | void angle1(short a) {a1 = a;}
function angle2 (line 76) | void angle2(short a) {a2 = a;}
function angles (line 78) | void angles(short a, short b) {a1 = a; a2 = b;}
FILE: Game Trainers/common/include/FL/Fl_Double_Window.H
function show (line 34) | void show() FL_OVERRIDE;
FILE: Game Trainers/common/include/FL/Fl_File_Browser.H
function full_height (line 45) | int full_height() const FL_OVERRIDE;
function iconsize (line 60) | void iconsize(uchar s) { iconsize_ = s; redraw(); }
function Fl_Fontsize (line 75) | Fl_Fontsize textsize() const { return Fl_Browser::textsize(); }
function filetype (line 91) | void filetype(int t) { filetype_ = t; }
FILE: Game Trainers/common/include/FL/Fl_File_Chooser.H
type Type (line 49) | enum Type {
FILE: Game Trainers/common/include/FL/Fl_File_Icon.H
function class (line 45) | class FL_EXPORT Fl_File_Icon { //// Icon data
FILE: Game Trainers/common/include/FL/Fl_File_Input.H
function down_box (line 69) | void down_box(Fl_Boxtype b) { down_box_ = b; }
function errorcolor (line 90) | void errorcolor(Fl_Color c) {(void)c;}
FILE: Game Trainers/common/include/FL/Fl_Flex.H
function fixed (line 158) | void fixed(Fl_Widget &w, int size) {
function margin (line 230) | int margin(int *left, int *top, int *right, int *bottom) const {
function margin (line 282) | void margin(int left, int top, int right, int bottom) {
function gap (line 305) | void gap(int g) {
function spacing (line 347) | void spacing(int i) {
FILE: Game Trainers/common/include/FL/Fl_FormsBitmap.H
function bitmap (line 36) | void bitmap(Fl_Bitmap *B) {b = B;}
function Fl_Bitmap (line 38) | Fl_Bitmap *bitmap() const {return b;}
FILE: Game Trainers/common/include/FL/Fl_FormsPixmap.H
function Pixmap (line 42) | void Pixmap(Fl_Pixmap *B) {b = B;}
function Fl_Pixmap (line 45) | Fl_Pixmap *Pixmap() const {return b;}
FILE: Game Trainers/common/include/FL/Fl_GIF_Image.H
function colors (line 61) | struct GIF_FRAME {
FILE: Game Trainers/common/include/FL/Fl_Gl_Window.H
function draw (line 76) | void draw() FL_OVERRIDE;
function valid (line 116) | void valid(char v) {if (v) valid_f_ |= 1; else valid_f_ &= 0xfe;}
function context_valid (line 129) | void context_valid(char v) {if (v) valid_f_ |= 2; else valid_f_ &= 0xfd;}
function can_do (line 132) | static int can_do(int m) {return can_do(m,0);}
function can_do (line 135) | static int can_do(const int *m) {return can_do(0, m);}
function can_do (line 137) | int can_do() {return can_do(mode_,alist);}
function mode (line 186) | int mode(int a) {return mode(a,0);}
function mode (line 198) | int mode(const int *a) {return mode(0, a);}
function swap_interval (line 207) | int swap_interval() const;
function Fl_Gl_Window (line 217) | Fl_Gl_Window const* as_gl_window() const FL_OVERRIDE { return this; }
function pixel_w (line 229) | int pixel_w() { return int(pixels_per_unit() * w() + 0.5f); }
function pixel_h (line 239) | int pixel_h() { return int(pixels_per_unit() * h() + 0.5f); }
FILE: Game Trainers/common/include/FL/Fl_Graphics_Driver.H
type Fl_Fontdesc (line 52) | struct Fl_Fontdesc
type PangoFontDescription (line 53) | typedef struct _PangoFontDescription PangoFontDescription;
function class (line 86) | class FL_EXPORT Fl_Graphics_Driver {
function class (line 392) | class Fl_Font_Descriptor {
type Fl_Fontdesc (line 404) | struct Fl_Fontdesc {
function floor (line 430) | inline int floor(int x) { return Fl_Scalable_Graphics_Driver::floor(x, s...
function xyline (line 447) | void xyline(int x, int y, int x1, int y2) FL_OVERRIDE {Fl_Graphics_Drive...
function xyline (line 448) | void xyline(int x, int y, int x1, int y2, int x3) FL_OVERRIDE {Fl_Graphi...
function yxline (line 451) | void yxline(int x, int y, int y1, int x2) FL_OVERRIDE {Fl_Graphics_Drive...
function yxline (line 452) | void yxline(int x, int y, int y1, int x2, int y3) FL_OVERRIDE {Fl_Graphi...
FILE: Game Trainers/common/include/FL/Fl_Grid.H
type Fl_Grid_Align (line 29) | typedef unsigned short Fl_Grid_Align;
function Cell (line 202) | Cell *next() {
function next (line 217) | void next(Cell *c) {
function Fl_Widget (line 221) | Fl_Widget *widget() const { return widget_; }
function rowspan (line 226) | void rowspan(short v) { rowspan_ = v; }
function colspan (line 227) | void colspan(short v) { colspan_ = v; }
function align (line 231) | void align(Fl_Grid_Align align) { align_ = align; }
function minimum_size (line 234) | void minimum_size(int w, int h) { if (w>=0) w_ = w; if (h>=0) h_ = h; }
function minimum_size (line 235) | void minimum_size(int *w, int *h) const { if (w) *w = w_; if (h) *h = h_; }
function need_layout (line 288) | void need_layout(int set) {
function show_grid (line 379) | void show_grid(int set) {
function show_grid (line 396) | void show_grid(int set, Fl_Color col) {
FILE: Game Trainers/common/include/FL/Fl_Group.H
function Fl_Widget (line 110) | Fl_Widget *child(int n) const {
function find (line 119) | int find(const Fl_Widget& o) const {return find(&o);}
function add (line 133) | void add(Fl_Widget* o) {add(*o);}
function insert (line 139) | void insert(Fl_Widget& o, Fl_Widget* before) {insert(o,find(before));}
function remove (line 146) | void remove(Fl_Widget* o) {remove(*o);}
function resizable (line 156) | void resizable(Fl_Widget& o) {resizable_ = &o;}
function resizable (line 210) | void resizable(Fl_Widget* o) {resizable_ = o;}
function Fl_Widget (line 215) | Fl_Widget* resizable() const {return resizable_;}
function add_resizable (line 219) | void add_resizable(Fl_Widget& o) {resizable_ = &o; add(o);}
function clip_children (line 231) | void clip_children(int c) { if (c) set_flag(CLIP_CHILDREN); else clear_f...
function clip_children (line 239) | unsigned int clip_children() { return (flags() & CLIP_CHILDREN) != 0; }
function Fl_Group (line 242) | Fl_Group* as_group() FL_OVERRIDE { return this; }
function Fl_Group (line 243) | Fl_Group const* as_group() const FL_OVERRIDE { return this; }
function focus (line 252) | void focus(Fl_Widget* W) {W->take_focus();}
function class (line 283) | class FL_EXPORT Fl_End {
FILE: Game Trainers/common/include/FL/Fl_Help_Dialog.H
function class (line 36) | class FL_EXPORT Fl_Help_Dialog {
FILE: Game Trainers/common/include/FL/Fl_Help_View.H
type Fl_Help_Block (line 46) | struct Fl_Help_Block {
type Fl_Help_Link (line 64) | struct Fl_Help_Link {
function Fl_Help_Font_Style (line 78) | struct FL_EXPORT Fl_Help_Font_Style {
function Fl_Help_Font_Stack (line 91) | struct FL_EXPORT Fl_Help_Font_Stack {
type Fl_Help_Target (line 127) | struct Fl_Help_Target {
function initfont (line 259) | void initfont(Fl_Font &f, Fl_Fontsize &s, Fl_Color &c) { f = textfont_; ...
function pushfont (line 260) | void pushfont(Fl_Font f, Fl_Fontsize s) {fstack_.push(f, s, textcolor_);}
function pushfont (line 261) | void pushfont(Fl_Font f, Fl_Fontsize s, Fl_Color c) {fstack_.push(f, s, ...
function popfont (line 262) | void popfont(Fl_Font &f, Fl_Fontsize &s, Fl_Color &c) {fstack_.pop(f, s,...
function link (line 327) | void link(Fl_Help_Func *fn) { link_ = fn; }
function size (line 332) | void size(int W, int H) { Fl_Widget::size(W, H); }
function textcolor (line 334) | void textcolor(Fl_Color c) { if (textcolor_ == defcolor_) textc...
function textfont (line 338) | void textfont(Fl_Font f) { textfont_ = f; format(); }
function textsize (line 342) | void textsize(Fl_Fontsize s) { textsize_ = s; format(); }
function scrollbar_size (line 390) | void scrollbar_size(int newSize) {
FILE: Game Trainers/common/include/FL/Fl_ICO_Image.H
type IconDirEntry (line 31) | struct IconDirEntry {
function IconDirEntry (line 49) | const IconDirEntry * icondirentry() const { return icondirentry_; }
type IconDirEntry (line 53) | struct IconDirEntry
FILE: Game Trainers/common/include/FL/Fl_Image.H
type Fl_Menu_Item (line 28) | struct Fl_Menu_Item
type Fl_Label (line 29) | struct Fl_Label
type Fl_RGB_Scaling (line 36) | enum Fl_RGB_Scaling {
function class (line 60) | class FL_EXPORT Fl_Image {
function Fl_Image (line 364) | Fl_Image *copy() const { return Fl_Image::copy(); }
function desaturate (line 366) | void desaturate() FL_OVERRIDE;
function cache_w (line 372) | int cache_w() {return cache_w_;}
function cache_h (line 373) | int cache_h() {return cache_h_;}
function max_size (line 383) | static void max_size(size_t size) { max_size_ = size;}
function max_size (line 388) | static size_t max_size() {return max_size_;}
function virtual (line 391) | virtual Fl_SVG_Image *as_svg_image() { return NULL; }
function virtual (line 394) | virtual void normalize() {}
FILE: Game Trainers/common/include/FL/Fl_Image_Surface.H
function class (line 100) | class Fl_Image_Surface_Driver : public Fl_Widget_Surface {
function virtual (line 110) | virtual ~Fl_Image_Surface_Driver() {}
function virtual (line 119) | virtual void mask(const Fl_RGB_Image *) {}
FILE: Game Trainers/common/include/FL/Fl_Input_.H
function yscroll (line 216) | void yscroll(int yOffset) { yscroll_ = yOffset; damage(FL_DAMAGE_EXPOSE);}
function ivalue (line 265) | int ivalue() const;
function maximum_size (line 300) | void maximum_size(int m) {maximum_size_ = m;}
function insert_position (line 325) | int insert_position(int p) { return insert_position(p, p); }
function mark (line 334) | int mark(int m) {return insert_position(insert_position(), m);}
function cut (line 349) | int cut() {return replace(insert_position(), mark(), 0);}
function cut (line 363) | int cut(int n) {return replace(insert_position(), insert_position()+n, 0);}
function cut (line 376) | int cut(int a, int b) {return replace(a, b, 0);}
function can_undo (line 401) | bool can_undo() const;
function shortcut (line 423) | void shortcut(int s) {shortcut_ = s;}
function textfont (line 432) | void textfont(Fl_Font s) {textfont_ = s;}
function textsize (line 441) | void textsize(Fl_Fontsize s) {textsize_ = s;}
function textcolor (line 452) | void textcolor(Fl_Color n) {textcolor_ = n;}
function cursor_color (line 461) | void cursor_color(Fl_Color n) {cursor_color_ = n;}
function input_type (line 470) | void input_type(int t) { type((uchar)(t | readonly())); }
function readonly (line 478) | void readonly(int b) { if (b) type((uchar)(type() | FL_INPUT_READONLY));
function wrap (line 491) | void wrap(int b) { if (b) type((uchar)(type() | FL_INPUT_WRAP));
function tab_nav (line 517) | void tab_nav(int val) {
FILE: Game Trainers/common/include/FL/Fl_Input_Choice.H
function class (line 46) | class InputMenuButton : public Fl_Menu_Button {
FILE: Game Trainers/common/include/FL/Fl_Menu_.H
function Fl_Menu_Item (line 95) | const Fl_Menu_Item* test_shortcut() {return picked(menu()->test_shortcut...
function Fl_Menu_Item (line 133) | const Fl_Menu_Item *menu() const {return menu_;}
function size (line 148) | int size() const ;
function mode (line 157) | void mode(int i,int fl) {menu_[i].flags = fl;}
function mode (line 159) | int mode(int i) const {return menu_[i].flags;}
function Fl_Menu_Item (line 162) | const Fl_Menu_Item *mvalue() const {return value_;}
function Fl_Menu_Item (line 167) | const Fl_Menu_Item *prev_mvalue() const {return prev_value_;}
function value (line 169) | int value() const;
function textfont (line 219) | void textfont(Fl_Font c) {textfont_=c;}
function textsize (line 223) | void textsize(Fl_Fontsize c) {textsize_=c;}
function textcolor (line 227) | void textcolor(Fl_Color c) {textcolor_=c;}
function down_box (line 235) | void down_box(Fl_Boxtype b) {down_box_ = b;}
function menu_box (line 245) | void menu_box(Fl_Boxtype b) { menu_box_ = b; }
function down_color (line 250) | void down_color(unsigned c) {selection_color(c);}
FILE: Game Trainers/common/include/FL/Fl_Menu_Bar.H
function virtual (line 93) | virtual void update() {}
FILE: Game Trainers/common/include/FL/Fl_Menu_Button.H
type popup_buttons (line 67) | enum popup_buttons {POPUP1 = 1, /**< pops up with the mouse 1st button. */
FILE: Game Trainers/common/include/FL/Fl_Menu_Item.H
function Fl_Menu_Item (line 124) | struct FL_EXPORT Fl_Menu_Item {
function Fl_Menu_Item (line 147) | const Fl_Menu_Item *first() const { return next(0); }
function Fl_Menu_Item (line 150) | Fl_Menu_Item *first() { return next(0); }
function label (line 191) | void label(const char* a) { text = a; }
function label (line 208) | void label(Fl_Labeltype a, const char* b) {
function multi_label (line 227) | void multi_label(const Fl_Multi_Label *ml) {
function image_label (line 245) | void image_label(const Fl_Image *image) {
function labeltype (line 265) | void labeltype(Fl_Labeltype a) {labeltype_ = a;}
function labelcolor (line 280) | void labelcolor(Fl_Color a) {labelcolor_ = a;}
function labelfont (line 295) | void labelfont(Fl_Font a) {labelfont_ = a;}
function labelsize (line 301) | void labelsize(Fl_Fontsize a) {labelsize_ = a;}
function callback (line 316) | void callback(Fl_Callback* c, void* p) {callback_=c; user_data_=p;}
function callback (line 323) | void callback(Fl_Callback* c) {callback_=c;}
function callback (line 330) | void callback(Fl_Callback0 *c) {
function user_data (line 352) | void user_data(void* v) {user_data_ = v;}
function argument (line 367) | void argument(long v) {user_data_ = (void*)(fl_intptr_t)v;}
function shortcut (line 387) | void shortcut(int s) {shortcut_ = s;}
function value (line 418) | void value(int v) { v ? set() : clear(); }
function set (line 424) | void set() {flags |= FL_MENU_VALUE;}
function clear (line 427) | void clear() {flags &= ~FL_MENU_VALUE;}
function show (line 435) | void show() {flags &= ~FL_MENU_INVISIBLE;}
function hide (line 438) | void hide() {flags |= FL_MENU_INVISIBLE;}
function activate (line 444) | void activate() {flags &= ~FL_MENU_INACTIVE;}
function deactivate (line 449) | void deactivate() {flags |= FL_MENU_INACTIVE;}
function image (line 460) | void image(Fl_Image* image) {image->label(this);}
function image (line 467) | void image(Fl_Image& image) {image.label(this);}
function do_callback (line 493) | void do_callback(Fl_Widget* o) const {Fl::callback_reason_=FL_REASON_SEL...
function do_callback (line 500) | void do_callback(Fl_Widget* o,void* arg) const {Fl::callback_reason_=FL_...
function do_callback (line 509) | void do_callback(Fl_Widget* o,long arg) const {Fl::callback_reason_=FL_R...
function check (line 525) | inline void check() {set();}
function uncheck (line 533) | inline void uncheck() {clear();}
FILE: Game Trainers/common/include/FL/Fl_Multi_Label.H
type Fl_Menu_Item (line 21) | struct Fl_Menu_Item
function Fl_Multi_Label (line 76) | struct FL_EXPORT Fl_Multi_Label {
FILE: Game Trainers/common/include/FL/Fl_Native_File_Chooser.H
type Type (line 134) | enum Type {
type Option (line 142) | enum Option {
function type (line 159) | int type() const ;
function class (line 234) | class Fl_Native_File_Chooser_FLTK_Driver : public Fl_Native_File_Chooser...
FILE: Game Trainers/common/include/FL/Fl_Overlay_Window.H
function hide (line 53) | void hide() FL_OVERRIDE;
function Fl_Overlay_Window (line 75) | Fl_Overlay_Window *as_overlay_window() FL_OVERRIDE {return this; }
FILE: Game Trainers/common/include/FL/Fl_PDF_File_Surface.H
function begin_job (line 57) | int begin_job(int, int *, int *, char **) FL_OVERRIDE {return 1;}
type Fl_Paged_Device (line 67) | enum Fl_Paged_Device
function printable_rect (line 70) | int printable_rect(int *w, int *h) FL_OVERRIDE { return platform_surface...
function margins (line 71) | void margins(int *left, int *top, int *right, int *bottom) FL_OVERRIDE {
function origin (line 74) | void origin(int x, int y) FL_OVERRIDE {platform_surface_->origin(x, y);}
function origin (line 75) | void origin(int *x, int *y) FL_OVERRIDE {platform_surface_->origin(x, y);}
function rotate (line 77) | void rotate(float angle) FL_OVERRIDE {platform_surface_->rotate(angle);}
function translate (line 78) | void translate(int x, int y) FL_OVERRIDE {platform_surface_->translate(x...
function untranslate (line 79) | void untranslate() FL_OVERRIDE {platform_surface_->untranslate();}
function begin_page (line 80) | int begin_page(void) FL_OVERRIDE {return platform_surface_->begin_page();}
function end_page (line 81) | int end_page(void) FL_OVERRIDE {return platform_surface_->end_page();}
function end_job (line 82) | void end_job(void) FL_OVERRIDE {return platform_surface_->end_job();}
function set_current (line 85) | void set_current() FL_OVERRIDE { if (platform_surface_) platform_surface...
function is_current (line 86) | bool is_current() FL_OVERRIDE { return surface() == platform_surface_; }
FILE: Game Trainers/common/include/FL/Fl_Pack.H
function spacing (line 79) | void spacing(int i) {spacing_ = i;}
function clear (line 98) | void clear() { Fl_Group::clear(); resizable(NULL); }
FILE: Game Trainers/common/include/FL/Fl_Paged_Device.H
type Page_Format (line 45) | enum Page_Format {
type Page_Layout (line 81) | enum Page_Layout {
type page_format (line 90) | typedef struct {
function virtual (line 102) | virtual ~Fl_Paged_Device() {}
function start_page (line 112) | int start_page() {return begin_page();}
FILE: Game Trainers/common/include/FL/Fl_Pixmap.H
type Fl_Menu_Item (line 25) | struct Fl_Menu_Item
function Fl_Image (line 67) | Fl_Image *copy() const { return Fl_Image::copy(); }
function desaturate (line 69) | void desaturate() FL_OVERRIDE;
function cache_w (line 75) | int cache_w() {return cache_w_;}
function cache_h (line 76) | int cache_h() {return cache_h_;}
FILE: Game Trainers/common/include/FL/Fl_Plugin.H
function class (line 59) | class FL_EXPORT Fl_Plugin {
function plugins (line 78) | int plugins() { return groups(); }
FILE: Game Trainers/common/include/FL/Fl_Positioner.H
function xminimum (line 68) | void xminimum(double a) {xbounds(a,xmax);}
function xmaximum (line 72) | void xmaximum(double a) {xbounds(xmin,a);}
function yminimum (line 77) | void yminimum(double a) {ybounds(a, ymax);}
function ymaximum (line 81) | void ymaximum(double a) {ybounds(ymin, a);}
function xstep (line 83) | void xstep(double a) {xstep_ = a;}
function ystep (line 85) | void ystep(double a) {ystep_ = a;}
FILE: Game Trainers/common/include/FL/Fl_Preferences.H
function class (line 125) | class FL_EXPORT Fl_Preferences {
FILE: Game Trainers/common/include/FL/Fl_Progress.H
function maximum (line 51) | void maximum(float v) { maximum_ = v; redraw(); }
function minimum (line 56) | void minimum(float v) { minimum_ = v; redraw(); }
function value (line 61) | void value(float v) { value_ = v; redraw(); }
FILE: Game Trainers/common/include/FL/Fl_Rect.H
function class (line 30) | class FL_EXPORT Fl_Rect {
function x (line 86) | void x(int X) { x_ = X; }
function y (line 87) | void y(int Y) { y_ = Y; }
function w (line 88) | void w(int W) { w_ = W; }
function h (line 89) | void h(int H) { h_ = H; }
function r (line 91) | void r(int R) { w_ = R - x_; }
function b (line 92) | void b(int B) { h_ = B - y_; }
function inset (line 104) | void inset(int d) {
function inset (line 125) | void inset(Fl_Boxtype bt) {
function inset (line 142) | void inset(int left, int top, int right, int bottom) {
FILE: Game Trainers/common/include/FL/Fl_Repeat_Button.H
function deactivate (line 42) | void deactivate() {
FILE: Game Trainers/common/include/FL/Fl_SVG_Image.H
type NSVGimage (line 22) | struct NSVGimage
function Fl_Image (line 161) | Fl_Image *copy() const {
function desaturate (line 165) | void desaturate() FL_OVERRIDE;
function Fl_SVG_Image (line 169) | Fl_SVG_Image *as_svg_image() FL_OVERRIDE { return this; }
FILE: Game Trainers/common/include/FL/Fl_Scheme.H
function class (line 22) | class Fl_Scheme {
FILE: Game Trainers/common/include/FL/Fl_Scroll.H
type Fl_Region_LRTB (line 113) | typedef struct {
type Fl_Scrollbar_Data (line 121) | typedef struct {
type ScrollInfo (line 135) | typedef struct {
function scrollbar_size (line 217) | void scrollbar_size(int newSize) {
FILE: Game Trainers/common/include/FL/Fl_Scrollbar.H
function value (line 63) | int value() const {return int(Fl_Slider::value());}
function value (line 87) | int value(int pos, int windowSize, int first_line, int total_lines) {
function linesize (line 101) | void linesize(int i) {linesize_ = i;}
FILE: Game Trainers/common/include/FL/Fl_Shared_Image.H
type Fl_Image (line 71) | typedef Fl_Image *(*Fl_Shared_Handler)(const char *name,
function refcount (line 137) | int refcount() { return refcount_; }
function original (line 146) | int original() { return original_; }
function release (line 148) | void release() FL_OVERRIDE;
function desaturate (line 160) | void desaturate() FL_OVERRIDE;
function uncache (line 163) | void uncache() FL_OVERRIDE;
FILE: Game Trainers/common/include/FL/Fl_Single_Window.H
function show (line 36) | void show(int argc, char **argv) { Fl_Window::show(argc, argv);}
function make_current (line 53) | void make_current() { Fl_Window::make_current(); }
function flush (line 58) | void flush() FL_OVERRIDE { Fl_Window::flush(); }
FILE: Game Trainers/common/include/FL/Fl_Slider.H
function slider (line 102) | void slider(Fl_Boxtype c) {slider_ = c;}
FILE: Game Trainers/common/include/FL/Fl_Spinner.H
function format (line 84) | void format(const char *f) { format_ = f; update(); }
function maximum (line 90) | void maximum(double m) { maximum_ = m; }
function minimum (line 96) | void minimum(double m) { minimum_ = m; }
function range (line 99) | void range(double a, double b) { minimum_ = a; maximum_ = b; }
function wrap (line 133) | void wrap(int set) { wrap_ = set ? 1 : 0; }
function textcolor (line 145) | void textcolor(Fl_Color c) { input_.textcolor(c); }
function textfont (line 151) | void textfont(Fl_Font f) { input_.textfont(f); }
function textsize (line 157) | void textsize(Fl_Fontsize s) { input_.textsize(s); }
function value (line 176) | void value(double v) { value_ = v; update(); }
function color (line 181) | void color(Fl_Color v) { input_.color(v); }
function selection_color (line 191) | void selection_color(Fl_Color val) { input_.selection_color(val); }
function maximum_size (line 201) | void maximum_size(int m) { if (m > 0) input_.maximum_size(m); }
FILE: Game Trainers/common/include/FL/Fl_Sys_Menu_Bar.H
function Fl_Menu_Item (line 111) | const Fl_Menu_Item *menu() const {return Fl_Menu_::menu();}
function update (line 113) | void update() FL_OVERRIDE;
FILE: Game Trainers/common/include/FL/Fl_Table.H
type std (line 32) | typedef std::vector<int> Fl_Int_Vector;
type TableContext (line 129) | enum TableContext {
type ResizeFlag (line 202) | enum ResizeFlag {
function is_fltk_container (line 385) | int is_fltk_container() { // does table contain fltk...
function redraw_range (line 397) | void redraw_range(int topRow, int botRow, int leftCol, int rightCol) {
function virtual (line 427) | virtual void clear() {
function table_box (line 440) | inline void table_box(Fl_Boxtype val) {
function Fl_Boxtype (line 448) | inline Fl_Boxtype table_box( void ) {
function rows (line 457) | inline int rows() {
function cols (line 466) | inline int cols() {
function visible_cells (line 498) | inline void visible_cells(int& r1, int& r2, int& c1, int& c2) {
function is_interactive_resize (line 509) | int is_interactive_resize() {
function row_resize (line 516) | inline int row_resize() {
function row_resize (line 526) | void row_resize(int flag) { // enable row resizing
function col_resize (line 533) | inline int col_resize() {
function col_resize (line 543) | void col_resize(int flag) { // enable col resizing
function col_resize_min (line 550) | inline int col_resize_min() { // column minimum resizing...
function col_resize_min (line 559) | void col_resize_min(int val) {
function row_resize_min (line 566) | inline int row_resize_min() { // column minimum resizing...
function row_resize_min (line 575) | void row_resize_min(int val) {
function row_header (line 582) | inline int row_header() { // set/get row header enab...
function row_header (line 590) | void row_header(int flag) {
function col_header (line 599) | inline int col_header() { // set/get col header enab...
function col_header (line 607) | void col_header(int flag) {
function col_header_height (line 616) | inline void col_header_height(int height) { // set/get col header height
function col_header_height (line 625) | inline int col_header_height() {
function row_header_width (line 632) | inline void row_header_width(int width) { // set/get row header width
function row_header_width (line 641) | inline int row_header_width() {
function row_header_color (line 648) | inline void row_header_color(Fl_Color val) { // set/get row header color
function Fl_Color (line 656) | inline Fl_Color row_header_color() {
function col_header_color (line 663) | inline void col_header_color(Fl_Color val) { // set/get col header color
function Fl_Color (line 671) | inline Fl_Color col_header_color() {
function row_height_all (line 689) | void row_height_all(int height) { // set all row/col heights
function col_width_all (line 699) | void col_width_all(int width) {
function row_position (line 711) | int row_position() {
function col_position (line 718) | int col_position() {
function top_row (line 727) | inline void top_row(int row) { // set/get top row (deprec...
function top_row (line 735) | inline int top_row() {
function init_sizes (line 762) | void init_sizes() {
function add (line 771) | void add(Fl_Widget& wgt) {
function add (line 784) | void add(Fl_Widget* wgt) {
function insert (line 792) | void insert(Fl_Widget& wgt, int n) {
function insert (line 801) | void insert(Fl_Widget& wgt, Fl_Widget* w2) {
function remove (line 808) | void remove(Fl_Widget& wgt) {
function begin (line 813) | void begin() {
function end (line 818) | void end() {
function Fl_Widget (line 835) | Fl_Widget*const* array() {
function Fl_Widget (line 853) | Fl_Widget *child(int n) const {
function find (line 870) | int find(const Fl_Widget *wgt) const {
function find (line 875) | int find(const Fl_Widget &wgt) const {
function callback_row (line 886) | int callback_row() {
function callback_col (line 895) | int callback_col() {
function TableContext (line 904) | TableContext callback_context() {
function do_callback (line 915) | void do_callback(TableContext context, int row, int col) {
function scrollbar_size (line 1066) | void scrollbar_size(int newSize) {
function tab_cell_nav (line 1084) | void tab_cell_nav(int val) {
FILE: Game Trainers/common/include/FL/Fl_Table_Row.H
type TableRowSelectMode (line 46) | enum TableRowSelectMode {
function init (line 56) | void init() {
function const (line 75) | char operator[](int x) const {
function size (line 81) | int size() {
function pop_back (line 85) | char pop_back() {
function push_back (line 90) | void push_back(char val) {
function back (line 95) | char back() {
function find_cell (line 116) | int find_cell(TableContext context, // find cell's x/y/w/h giv...
function rows (line 143) | int rows() { // get number of rows
function clear (line 172) | void clear() FL_OVERRIDE {
FILE: Game Trainers/common/include/FL/Fl_Tabs.H
type Fl_Menu_Item (line 25) | struct Fl_Menu_Item
function Fl_Widget (line 306) | Fl_Widget *push() const { return push_; }
function tab_align (line 323) | void tab_align(Fl_Align a) { tab_align_ = a; }
FILE: Game Trainers/common/include/FL/Fl_Terminal.H
type RedrawStyle (line 332) | enum RedrawStyle {
type Attrib (line 346) | enum Attrib {
type CharFlags (line 362) | enum CharFlags {
type OutFlags (line 378) | enum OutFlags {
type ScrollbarStyle (line 389) | enum ScrollbarStyle {
function left (line 409) | int left(void) const { return left_; }
function right (line 410) | int right(void) const { return right_; }
function top (line 411) | int top(void) const { return top_; }
function bottom (line 412) | int bottom(void) const { return bottom_; }
function left (line 413) | void left(int val) { left_ = val; }
function right (line 414) | void right(int val) { right_ = val; }
function top (line 415) | void top(int val) { top_ = val; }
function bottom (line 416) | void bottom(int val) { bottom_ = val; }
function class (line 425) | class FL_EXPORT CharStyle {
function col (line 515) | int col(void) const { return col_; }
function row (line 516) | int row(void) const { return row_; }
function h (line 517) | int h(void) const { return h_; }
function Fl_Color (line 518) | Fl_Color fgcolor(void) const { return fgcolor_; }
function Fl_Color (line 519) | Fl_Color bgcolor(void) const { return bgcolor_; }
function col (line 520) | void col(int val) { col_ = val >= 0 ? val : 0; }
function row (line 521) | void row(int val) { row_ = val >= 0 ? val : 0; }
function h (line 522) | void h(int val) { h_ = val; }
function fgcolor (line 523) | void fgcolor(Fl_Color val) { fgcolor_ = val; }
function bgcolor (line 524) | void bgcolor(Fl_Color val) { bgcolor_ = val; }
function left (line 525) | int left(void) { col_ = (col_>0) ? (col_-1) : 0; return co...
function right (line 526) | int right(void) { return ++col_; }
function up (line 527) | int up(void) { row_ = (row_>0) ? (row_-1) : 0; return ro...
function down (line 528) | int down(void) { return ++row_; }
function home (line 531) | void home(void) { row_ = 0; col_ = 0; }
function class (line 539) | class FL_EXPORT Utf8Char {
function class (line 587) | class FL_EXPORT RingBuffer {
function class (line 690) | class FL_EXPORT Selection {
function class (line 735) | class FL_EXPORT EscapeSeq {
function class (line 778) | class FL_EXPORT PartialUtf8Buf {
function PartialUtf8Buf (line 784) | PartialUtf8Buf(void) { clear(); }
function is_continuation (line 786) | bool is_continuation(char c) {
function buflen (line 802) | int buflen(void) const { return buflen_; }
function append (line 812) | bool append(const char* p, int len) {
function is_complete (line 820) | bool is_complete(void) const { return (buflen_ && (buflen_ == clen_)); }
function ring_cols (line 1055) | inline int ring_cols(void) const { return ring_.ring_cols(); }
function ring_srow (line 1057) | inline int ring_srow(void) const { return ring_.ring_srow(); }
function ring_erow (line 1059) | inline int ring_erow(void) const { return ring_.ring_erow(); }
function hist_rows (line 1061) | inline int hist_rows(void) const { return ring_.hist_rows(); }
function hist_cols (line 1063) | inline int hist_cols(void) const { return ring_.hist_cols(); }
function hist_srow (line 1065) | inline int hist_srow(void) const { return ring_.hist_srow(); }
function hist_erow (line 1067) | inline int hist_erow(void) const { return ring_.hist_erow(); }
function hist_use (line 1069) | inline int hist_use(void) const { return ring_.hist_use(); }
function hist_use_srow (line 1071) | inline int hist_use_srow(void) const { return ring_.hist_use_srow(); }
function disp_rows (line 1073) | inline int disp_rows(void) const { return ring_.disp_rows(); }
function disp_cols (line 1075) | inline int disp_cols(void) const { return ring_.disp_cols(); }
function disp_srow (line 1077) | inline int disp_srow(void) const { return ring_.disp_srow(); }
function disp_erow (line 1079) | inline int disp_erow(void) const { return ring_.disp_erow(); }
function offset (line 1081) | inline int offset(void) const { return ring_.offset(); }
function box (line 1111) | void box(Fl_Boxtype val) { Fl_Group::box(val); update_screen(false); }
function Fl_Boxtype (line 1113) | Fl_Boxtype box(void) const { return Fl_Group::box(); }
function margin_left (line 1116) | int margin_left(void) const { return margin_.left(); }
function margin_right (line 1118) | int margin_right(void) const { return margin_.right(); }
function margin_top (line 1120) | int margin_top(void) const { return margin_.top(); }
function margin_bottom (line 1122) | int margin_bottom(void) const { return margin_.bottom(); }
function Fl_Font (line 1137) | Fl_Font textfont(void) const { return current_style_->fontface(...
function Fl_Fontsize (line 1139) | Fl_Fontsize textsize(void) const { return current_style_->fontsize(...
function Fl_Color (line 1141) | Fl_Color color(void) const { return Fl_Group::color(); }
function Fl_Color (line 1143) | Fl_Color textcolor(void) const { return textfgcolor_default(); }
function Fl_Color (line 1145) | Fl_Color textfgcolor(void) const { return current_style_->fgcolor(); }
function Fl_Color (line 1147) | Fl_Color textbgcolor(void) const { return current_style_->bgcolor(); }
function Fl_Color (line 1149) | Fl_Color textfgcolor_default(void) const { return current_style_->d...
function Fl_Color (line 1151) | Fl_Color textbgcolor_default(void) const { return current_style_->d...
function selectionfgcolor (line 1155) | void selectionfgcolor(Fl_Color val) { select_.selectionfgcolor(val); }
function selectionbgcolor (line 1157) | void selectionbgcolor(Fl_Color val) { select_.selectionbgcolor(val); }
function Fl_Color (line 1159) | Fl_Color selectionfgcolor(void) const { return select_.selectionfgcolor(...
function Fl_Color (line 1161) | Fl_Color selectionbgcolor(void) const { return select_.selectionbgcolor(...
function uchar (line 1164) | uchar textattrib() const;
function error_char (line 1179) | void error_char(const char* val) { error_char_ = val; }
FILE: Game Trainers/common/include/FL/Fl_Text_Buffer.H
function class (line 100) | class FL_EXPORT Fl_Text_Selection {
function class (line 201) | class FL_EXPORT Fl_Text_Buffer {
function can_undo (line 337) | bool can_undo() const;
function secondary_selected (line 473) | int secondary_selected() { return mSecondary.selected(); }
function highlight (line 512) | int highlight() { return mHighlight.selected(); }
function call_modify_callbacks (line 553) | void call_modify_callbacks() { call_modify_callbacks(0, 0, 0, 0, 0); }
function call_predelete_callbacks (line 570) | void call_predelete_callbacks() { call_predelete_callbacks(0, 0); }
function Fl_Text_Selection (line 721) | const Fl_Text_Selection* primary_selection() const { return &mPrimary; }
function Fl_Text_Selection (line 726) | Fl_Text_Selection* primary_selection() { return &mPrimary; }
function Fl_Text_Selection (line 731) | const Fl_Text_Selection* secondary_selection() const { return &mSecondar...
function Fl_Text_Selection (line 736) | const Fl_Text_Selection* highlight_selection() const { return &mHighligh...
FILE: Game Trainers/common/include/FL/Fl_Text_Display.H
type Style_Table_Entry (line 145) | struct Style_Table_Entry {
function buffer (line 180) | void buffer(Fl_Text_Buffer& buf) { buffer(&buf); }
function Fl_Text_Buffer (line 189) | Fl_Text_Buffer* buffer() const { return mBuffer; }
function Fl_Text_Buffer (line 196) | Fl_Text_Buffer* style_buffer() const { return mStyleBuffer; }
function hide_cursor (line 238) | void hide_cursor() { show_cursor(0); }
function cursor_color (line 253) | void cursor_color(Fl_Color n) {mCursor_color = n;}
function scrollbar_width (line 269) | void scrollbar_width(int width) {
function scrollbar_size (line 306) | void scrollbar_size(int newSize) {
function scrollbar_align (line 320) | void scrollbar_align(Fl_Align a) { scrollbar_align_ = a; }
function word_start (line 327) | int word_start(int pos) const { return buffer()->word_start(pos); }
function word_end (line 334) | int word_end(int pos) const { return buffer()->word_end(pos); }
function shortcut (line 357) | void shortcut(int s) {shortcut_ = s;}
function textfont (line 369) | void textfont(Fl_Font s) {textfont_ = s; mColumnScale = 0; }
function textsize (line 381) | void textsize(Fl_Fontsize s) {textsize_ = s; mColumnScale = 0; }
function textcolor (line 393) | void textcolor(Fl_Color n) {textcolor_ = n;}
function grammar_underline_color (line 399) | void grammar_underline_color(Fl_Color color) { grammar_underline_color_ ...
function spelling_underline_color (line 411) | void spelling_underline_color(Fl_Color color) { spelling_underline_color...
function secondary_selection_color (line 423) | void secondary_selection_color(Fl_Color color) { secondary_selection_col...
function linenumber_width (line 455) | int linenumber_width() const;
function scroll_col (line 543) | int scroll_col() { return mHorizOffset; }
FILE: Game Trainers/common/include/FL/Fl_Text_Editor.H
type Key_Binding (line 44) | struct Key_Binding {
function insert_mode (line 59) | void insert_mode(int b) { insert_mode_ = b; }
function insert_mode (line 65) | int insert_mode() { return insert_mode_; }
function tab_nav (line 67) | int tab_nav() const;
function remove_key_binding (line 74) | void remove_key_binding(int key, int state)
function remove_all_key_bindings (line 78) | void remove_all_key_bindings() { remove_all_key_bindings(&key_bindings); }
function Key_Func (line 82) | Key_Func bound_key_function(int key, int state) const
function default_key_function (line 85) | void default_key_function(Key_Func f) { default_key_function_ = f; }
FILE: Game Trainers/common/include/FL/Fl_Tile.H
function position (line 37) | void position(int x, int y) { Fl_Group::position(x, y); }
function Fl_Cursor (line 50) | Fl_Cursor cursor(int n) {
type Size_Range (line 56) | typedef struct { int minw, minh, maxw, maxh; } Size_Range;
FILE: Game Trainers/common/include/FL/Fl_Tiled_Image.H
function Fl_Image (line 43) | Fl_Image *copy() const {
function desaturate (line 47) | void desaturate() FL_OVERRIDE;
function Fl_Image (line 51) | Fl_Image *image() { return image_; }
FILE: Game Trainers/common/include/FL/Fl_Timer.H
function direction (line 65) | void direction(char d) {direction_ = d;}
FILE: Game Trainers/common/include/FL/Fl_Tooltip.H
function class (line 34) | class FL_EXPORT Fl_Tooltip {
function delay (line 40) | static void delay(float f) { delay_ = f; }
function hidedelay (line 42) | static float hidedelay() { return hidedelay_; }
function hidedelay (line 44) | static void hidedelay(float f) { hidedelay_ = f; }
function hoverdelay (line 49) | static float hoverdelay() { return hoverdelay_; }
function hoverdelay (line 54) | static void hoverdelay(float f) { hoverdelay_ = f; }
function enabled (line 56) | static int enabled() { return Fl::option(Fl::OPTION_SHOW_TOOLTIPS); }
function disable (line 60) | static void disable() { enable(0); }
function Fl_Widget (line 65) | static Fl_Widget* current() {return widget_;}
function Fl_Font (line 69) | static Fl_Font font() { return font_; }
function font (line 71) | static void font(Fl_Font i) { font_ = i; }
function Fl_Fontsize (line 73) | static Fl_Fontsize size() { return (size_ == -1 ? FL_NORMAL_SIZE : size_...
function size (line 75) | static void size(Fl_Fontsize s) { size_ = s; }
function Fl_Color (line 77) | static Fl_Color color() { return color_; }
function color (line 79) | static void color(Fl_Color c) { color_ = c; }
function Fl_Color (line 81) | static Fl_Color textcolor() { return textcolor_; }
function textcolor (line 83) | static void textcolor(Fl_Color c) { textcolor_ = c; }
function margin_width (line 85) | static int margin_width() { return margin_width_; }
function margin_width (line 87) | static void margin_width(int v) { margin_width_ = v; }
function margin_height (line 89) | static int margin_height() { return margin_height_; }
function margin_height (line 91) | static void margin_height(int v) { margin_height_ = v; }
function wrap_width (line 93) | static int wrap_width() { return wrap_width_; }
function wrap_width (line 95) | static void wrap_width(int v) { wrap_width_ = v; }
FILE: Game Trainers/common/include/FL/Fl_Tree.H
type Fl_Tree_Reason (line 275) | enum Fl_Tree_Reason {
FILE: Game Trainers/common/include/FL/Fl_Tree_Item.H
function class (line 65) | class FL_EXPORT Fl_Tree_Item {
function select_toggle (line 309) | void select_toggle() {
function select_all (line 320) | int select_all() {
function deselect (line 332) | void deselect() {
function deselect_all (line 339) | int deselect_all() {
function deactivate (line 376) | void deactivate() {
function usericon (line 415) | void usericon(Fl_Image *val) {
function Fl_Image (line 420) | Fl_Image *usericon() const {
function userdeicon (line 449) | void userdeicon(Fl_Image* val) {
function Fl_Image (line 454) | Fl_Image* userdeicon() const {
function is_flag (line 482) | inline int is_flag(unsigned short val) const {
FILE: Game Trainers/common/include/FL/Fl_Tree_Item_Array.H
function class (line 45) | class FL_EXPORT Fl_Tree_Item_Array {
FILE: Game Trainers/common/include/FL/Fl_Tree_Prefs.H
type Fl_Tree_Sort (line 47) | enum Fl_Tree_Sort {
type Fl_Tree_Connector (line 56) | enum Fl_Tree_Connector {
type Fl_Tree_Select (line 65) | enum Fl_Tree_Select {
type Fl_Tree_Item_Reselect_Mode (line 78) | enum Fl_Tree_Item_Reselect_Mode {
type Fl_Tree_Item_Draw_Mode (line 87) | enum Fl_Tree_Item_Draw_Mode {
function class (line 105) | class FL_EXPORT Fl_Tree_Prefs {
function Fl_Tree_Item_Draw_Callback (line 432) | Fl_Tree_Item_Draw_Callback* item_draw_callback() const {
function do_item_draw_callback (line 438) | void do_item_draw_callback(Fl_Tree_Item *o) const {
FILE: Game Trainers/common/include/FL/Fl_Valuator.H
function handle_push (line 62) | void handle_push() {previous_value_ = value_;}
function set_value (line 68) | void set_value(double v) {value_ = v;}
function bounds (line 75) | void bounds(double a, double b) {min=a; max=b;}
function minimum (line 79) | void minimum(double a) {min = a;}
function maximum (line 83) | void maximum(double a) {max = a;}
function range (line 104) | void range(double a, double b) {min = a; max = b;}
function step (line 106) | void step(int a) {A = a; B = 1;}
function step (line 108) | void step(double a, int b) {A = a; B = b;}
FILE: Game Trainers/common/include/FL/Fl_Value_Input.H
function soft (line 75) | void soft(char s) {soft_ = s;}
function shortcut (line 105) | void shortcut(int s) {input.shortcut(s);}
function textfont (line 110) | void textfont(Fl_Font s) {input.textfont(s);}
function textsize (line 114) | void textsize(Fl_Fontsize s) {input.textsize(s);}
function textcolor (line 118) | void textcolor(Fl_Color n) {input.textcolor(n);}
function cursor_color (line 122) | void cursor_color(Fl_Color n) {input.cursor_color(n);}
FILE: Game Trainers/common/include/FL/Fl_Value_Output.H
function soft (line 58) | void soft(uchar s) {soft_ = s;}
function textfont (line 70) | void textfont(Fl_Font s) {textfont_ = s;}
function textsize (line 73) | void textsize(Fl_Fontsize s) {textsize_ = s;}
function textcolor (line 77) | void textcolor(Fl_Color s) {textcolor_ = s;}
FILE: Game Trainers/common/include/FL/Fl_Value_Slider.H
function textfont (line 49) | void textfont(Fl_Font s) { textfont_ = s; }
function textsize (line 55) | void textsize(Fl_Fontsize s) { textsize_ = s; }
function textcolor (line 61) | void textcolor(Fl_Color s) { textcolor_ = s; }
function value_width (line 78) | void value_width(int s) {
function value_height (line 107) | void value_height(int s) {
FILE: Game Trainers/common/include/FL/Fl_Widget.H
type Fl_Callback (line 35) | typedef Fl_Callback* Fl_Callback_p;
function Fl_Label (line 49) | struct FL_EXPORT Fl_Label {
function class (line 92) | class FL_EXPORT Fl_Callback_User_Data {
function class (line 112) | class FL_EXPORT Fl_Widget {
function argument (line 817) | void argument(long v) {user_data((void*)(fl_intptr_t)v);}
function when (line 866) | void when(uchar i) {when_ = i;}
function set_visible (line 908) | void set_visible() {flags_ &= ~INVISIBLE;}
function clear_visible (line 914) | void clear_visible() {flags_ |= INVISIBLE;}
function active_r (line 926) | int active_r() const;
function set_output (line 964) | void set_output() {flags_ |= OUTPUT;}
function clear_output (line 969) | void clear_output() {flags_ &= ~OUTPUT;}
function set_changed (line 1001) | void set_changed() {flags_ |= CHANGED;}
function clear_changed (line 1006) | void clear_changed() {flags_ &= ~CHANGED;}
function clear_active (line 1012) | void clear_active() {flags_ |= INACTIVE;}
function set_active (line 1018) | void set_active() {flags_ &= ~INACTIVE;}
function set_visible_focus (line 1035) | void set_visible_focus() { flags_ |= VISIBLE_FOCUS; }
function clear_visible_focus (line 1041) | void clear_visible_focus() { flags_ &= ~VISIBLE_FOCUS; }
function visible_focus (line 1047) | void visible_focus(int v) { if (v) set_visible_focus(); else clear_visib...
function do_callback (line 1089) | void do_callback(Fl_Callback_Reason reason=FL_REASON_UNKNOWN) {do_callba...
function do_callback (line 1098) | void do_callback(Fl_Widget *widget, long arg, Fl_Callback_Reason reason=...
function _set_fullscreen (line 1111) | void _set_fullscreen() {flags_ |= FULLSCREEN;}
function _clear_fullscreen (line 1112) | void _clear_fullscreen() {flags_ &= ~FULLSCREEN;}
function inside (line 1127) | int inside(const Fl_Widget *wgt) const {return wgt ? wgt->contains(this)...
function measure_label (line 1186) | void measure_label(int& ww, int& hh) const {label_.measure(ww, hh);}
function virtual (line 1215) | virtual Fl_Group* as_group() { return NULL; }
function virtual (line 1216) | virtual Fl_Group const* as_group() const { return NULL; }
function virtual (line 1230) | virtual Fl_Window* as_window() { return 0; }
function virtual (line 1231) | virtual Fl_Window const* as_window() const { return NULL; }
function Fl_Gl_Window (line 1243) | Fl_Gl_Window* as_gl_window() { return NULL; }
function Fl_Gl_Window (line 1244) | Fl_Gl_Window const* as_gl_window() const { return NULL; }
function use_accents_menu (line 1248) | int use_accents_menu() { return flags() & MAC_USE_ACCENTS_MENU; }
function color2 (line 1258) | void color2(unsigned a) {color2_ = a;}
function shortcut_label (line 1271) | void shortcut_label(int value) {
FILE: Game Trainers/common/include/FL/Fl_Window.H
function clear_border (line 230) | void clear_border() {set_flag(NOBORDER);}
function set_override (line 234) | void set_override() {set_flag(NOBORDER|OVERRIDE);}
function set_modal (line 245) | void set_modal() {set_flag(MODAL);}
function set_non_modal (line 254) | void set_non_modal() {set_flag(NON_MODAL);}
function clear_modal_states (line 295) | void clear_modal_states() {clear_flag(NON_MODAL | MODAL);}
function set_menu_window (line 310) | void set_menu_window() {set_flag(MENU_WINDOW);}
function set_tooltip_window (line 331) | void set_tooltip_window() { set_flag(TOOLTIP_WINDOW);
function free_position (line 357) | void free_position() {clear_flag(FORCE_POSITION);}
type HICON__ (line 386) | struct HICON__
function shown (line 431) | int shown() {return flx_ != 0;}
function x_root (line 548) | int x_root() const ;
function Fl_Overlay_Window (line 602) | Fl_Overlay_Window *as_overlay_window() {return 0L; }
function Fl_Double_Window (line 607) | Fl_Double_Window *as_double_window() {return 0L;}
function show_next_window_iconic (line 625) | static void show_next_window_iconic(char stat) {
function show_next_window_iconic (line 636) | static char show_next_window_iconic() {
FILE: Game Trainers/common/include/FL/filename.H
function fl_filename_expand (line 98) | inline int fl_filename_expand(char *to, const char *from) { return fl_fi...
function fl_filename_absolute (line 99) | inline int fl_filename_absolute(char *to, const char *from) { return fl_...
function fl_filename_relative (line 100) | inline int fl_filename_relative(char *to, const char *from) { return fl_...
type dirent (line 108) | struct dirent
type dirent (line 108) | struct dirent
type dirent (line 109) | struct dirent
type dirent (line 109) | struct dirent
type dirent (line 110) | struct dirent
type dirent (line 110) | struct dirent
type dirent (line 111) | struct dirent
type dirent (line 111) | struct dirent
type dirent (line 114) | struct dirent
type dirent (line 114) | struct dirent
type dirent (line 123) | struct dirent
type dirent (line 125) | struct dirent
FILE: Game Trainers/common/include/FL/fl_ask.H
type Fl_Beep (line 40) | enum Fl_Beep {
function fl_message_font (line 103) | inline void fl_message_font(Fl_Font f, Fl_Fontsize s) {
function fl_message_position (line 118) | inline void fl_message_position(Fl_Widget &widget) {
FILE: Game Trainers/common/include/FL/fl_casts.H
function fl_char (line 23) | inline char fl_char(void *v) { return (char)(fl_intptr_t)v; }
function fl_int (line 24) | inline int fl_int(void *v) { return (int)(fl_intptr_t)v; }
function fl_long (line 25) | inline long fl_long(void *v) { return (long)(fl_intptr_t)v; }
function fl_uchar (line 27) | inline unsigned char fl_uchar(void *v) { return (unsigned char)(fl_uin...
function fl_uint (line 28) | inline unsigned int fl_uint(void *v) { return (unsigned int)(fl_uint...
function fl_ulong (line 29) | inline unsigned long fl_ulong(void *v) { return (unsigned long)(fl_uin...
FILE: Game Trainers/common/include/FL/fl_draw.H
function fl_color (line 50) | inline void fl_color(Fl_Color c) {
function fl_color (line 54) | inline void fl_color(int c) {
function fl_color (line 67) | inline void fl_color(uchar r, uchar g, uchar b) {
function Fl_Color (line 74) | inline Fl_Color fl_color() {
function fl_push_clip (line 88) | inline void fl_push_clip(int x, int y, int w, int h) {
function fl_clip (line 99) | inline void fl_clip(int x, int y, int w, int h) {
function fl_push_no_clip (line 105) | inline void fl_push_no_clip() {
function fl_pop_clip (line 115) | inline void fl_pop_clip() {
function fl_not_clipped (line 132) | inline int fl_not_clipped(int x, int y, int w, int h) {
function fl_clip_box (line 178) | inline int fl_clip_box(int x, int y, int w, int h, int &X, int &Y, int &...
function fl_restore_clip (line 183) | inline void fl_restore_clip() {
function fl_clip_region (line 196) | inline void fl_clip_region(Fl_Region r) {
function Fl_Region (line 206) | inline Fl_Region fl_clip_region() {
function fl_point (line 215) | inline void fl_point(int x, int y) {
function fl_antialias (line 282) | inline void fl_antialias(int state) {
function fl_antialias (line 287) | inline int fl_antialias() {
function fl_rect (line 298) | inline void fl_rect(int x, int y, int w, int h) {
function fl_rounded_rect (line 307) | inline void fl_rounded_rect(int x, int y, int w, int h, int r) {
function fl_rect (line 316) | inline void fl_rect(Fl_Rect r) {
function fl_focus_rect (line 326) | inline void fl_focus_rect(int x, int y, int w, int h) {
function fl_rect (line 333) | inline void fl_rect(int x, int y, int w, int h, Fl_Color c) {
function fl_rectf (line 339) | inline void fl_rectf(int x, int y, int w, int h) {
function fl_rounded_rectf (line 347) | inline void fl_rounded_rectf(int x, int y, int w, int h, int r) {
function fl_rectf (line 354) | inline void fl_rectf(int x, int y, int w, int h, Fl_Color c) {
function fl_rectf (line 360) | inline void fl_rectf(Fl_Rect r) {
function fl_rectf (line 367) | inline void fl_rectf(Fl_Rect r, Fl_Color c) {
function fl_rectf (line 379) | inline void fl_rectf(int x, int y, int w, int h, uchar r, uchar g, uchar...
function fl_rectf (line 389) | inline void fl_rectf(Fl_Rect bb, uchar r, uchar g, uchar b) {
function fl_line (line 397) | inline void fl_line(int x, int y, int x1, int y1) {
function fl_line (line 403) | inline void fl_line(int x, int y, int x1, int y1, int x2, int y2) {
function fl_loop (line 411) | inline void fl_loop(int x, int y, int x1, int y1, int x2, int y2) {
function fl_loop (line 417) | inline void fl_loop(int x, int y, int x1, int y1, int x2, int y2, int x3...
function fl_polygon (line 425) | inline void fl_polygon(int x, int y, int x1, int y1, int x2, int y2) {
function fl_polygon (line 431) | inline void fl_polygon(int x, int y, int x1, int y1, int x2, int y2, int...
function fl_xyline (line 439) | inline void fl_xyline(int x, int y, int x1) {
function fl_xyline (line 445) | inline void fl_xyline(int x, int y, int x1, int y2) {
function fl_xyline (line 452) | inline void fl_xyline(int x, int y, int x1, int y2, int x3) {
function fl_yxline (line 460) | inline void fl_yxline(int x, int y, int y1) {
function fl_yxline (line 466) | inline void fl_yxline(int x, int y, int y1, int x2) {
function fl_yxline (line 473) | inline void fl_yxline(int x, int y, int y1, int x2, int y3) {
function fl_arc (line 503) | inline void fl_arc(int x, int y, int w, int h, double a1, double a2) {
function fl_pie (line 521) | inline void fl_pie(int x, int y, int w, int h, double a1, double a2) {
function fl_push_matrix (line 532) | inline void fl_push_matrix() {
function fl_pop_matrix (line 538) | inline void fl_pop_matrix() {
function fl_scale (line 545) | inline void fl_scale(double x, double y) {
function fl_scale (line 552) | inline void fl_scale(double x) {
function fl_translate (line 559) | inline void fl_translate(double x, double y) {
function fl_rotate (line 566) | inline void fl_rotate(double d) {
function fl_load_identity (line 572) | inline void fl_load_identity() {
function fl_load_matrix (line 579) | inline void fl_load_matrix(double a, double b, double c, double d, doubl...
function fl_mult_matrix (line 588) | inline void fl_mult_matrix(double a, double b, double c, double d, doubl...
function fl_begin_points (line 594) | inline void fl_begin_points() {
function fl_begin_line (line 600) | inline void fl_begin_line() {
function fl_begin_loop (line 606) | inline void fl_begin_loop() {
function fl_begin_polygon (line 612) | inline void fl_begin_polygon() {
function fl_vertex (line 619) | inline void fl_vertex(double x, double y) {
function fl_curve (line 630) | inline void fl_curve(double X0, double Y0, double X1, double Y1, double ...
function fl_arc (line 668) | inline void fl_arc(double x, double y, double r, double start, double en...
function fl_circle (line 683) | inline void fl_circle(double x, double y, double r) {
function fl_end_points (line 689) | inline void fl_end_points() {
function fl_end_line (line 695) | inline void fl_end_line() {
function fl_end_loop (line 701) | inline void fl_end_loop() {
function fl_end_polygon (line 707) | inline void fl_end_polygon() {
function fl_begin_complex_polygon (line 723) | inline void fl_begin_complex_polygon() {
function fl_gap (line 732) | inline void fl_gap() {
function fl_end_complex_polygon (line 738) | inline void fl_end_complex_polygon() {
function fl_transform_x (line 746) | inline double fl_transform_x(double x, double y) {
function fl_transform_y (line 753) | inline double fl_transform_y(double x, double y) {
function fl_transform_dx (line 760) | inline double fl_transform_dx(double x, double y) {
function fl_transform_dy (line 767) | inline double fl_transform_dy(double x, double y) {
function fl_transformed_vertex (line 774) | inline void fl_transformed_vertex(double xf, double yf) {
function fl_copy_offscreen (line 784) | inline void fl_copy_offscreen(int x, int y, int w, int h, Fl_Offscreen p...
function Fl_Font (line 811) | inline Fl_Font fl_font() {
function Fl_Fontsize (line 818) | inline Fl_Fontsize fl_size() {
function fl_height (line 827) | inline int fl_height() {
function fl_descent (line 835) | inline int fl_descent() {
function fl_width (line 846) | inline double fl_width(const char *txt, int n) {
function fl_width (line 855) | inline double fl_width(unsigned int c) {
function fl_text_extents (line 891) | inline void fl_text_extents(const char *t, int n, int &dx, int &dy, int ...
function fl_draw (line 956) | inline void fl_draw(const char *str, int n, int x, int y) {
function fl_draw (line 968) | inline void fl_draw(int angle, const char *str, int n, int x, int y) {
function fl_rtl_draw (line 974) | inline void fl_rtl_draw(const char *str, int n, int x, int y) {
function fl_can_do_alpha_blending (line 1145) | inline char fl_can_do_alpha_blending() {
function fl_draw_pixmap (line 1169) | inline int fl_draw_pixmap(/*const*/ char *const *data, int x, int y, Fl_...
FILE: Game Trainers/common/include/FL/fl_types.h
type uchar (line 30) | typedef unsigned char uchar;
type ulong (line 32) | typedef unsigned long ulong;
type Fl_Shortcut (line 55) | typedef unsigned int Fl_Shortcut;
FILE: Game Trainers/common/include/FL/fl_utf8.h
type stat (line 163) | struct stat
FILE: Game Trainers/common/include/FL/forms.H
type Fl_Widget (line 25) | typedef Fl_Widget FL_OBJECT;
type Fl_Window (line 26) | typedef Fl_Window FL_FORM;
type FL_Coord (line 151) | typedef int FL_Coord;
type FL_COLOR (line 152) | typedef int FL_COLOR;
function fl_finish (line 159) | inline void fl_finish() {}
function fl_add_io_callback (line 162) | inline void fl_add_io_callback(int fd, short w, FL_IO_CALLBACK cb, void*...
function fl_remove_io_callback (line 164) | inline void fl_remove_io_callback(int fd, short, FL_IO_CALLBACK) {
function fl_add_timeout (line 168) | inline void fl_add_timeout(long msec, void (*cb)(void*), void* v) {
function fl_remove_timeout (line 170) | inline void fl_remove_timeout(int) {}
function fl_set_idle_callback (line 173) | inline void fl_set_idle_callback(void (*cb)()) {Fl::set_idle(cb);}
function Fl_Widget (line 177) | inline Fl_Widget* fl_do_only_forms(void) {return fl_do_forms();}
function Fl_Widget (line 178) | inline Fl_Widget* fl_check_only_forms(void) {return fl_check_forms();}
function fl_freeze_object (line 181) | inline void fl_freeze_object(Fl_Widget*) {}
function fl_unfreeze_object (line 182) | inline void fl_unfreeze_object(Fl_Widget*) {}
function fl_freeze_form (line 183) | inline void fl_freeze_form(Fl_Window*) {}
function fl_unfreeze_form (line 184) | inline void fl_unfreeze_form(Fl_Window*) {}
function fl_freeze_all_forms (line 185) | inline void fl_freeze_all_forms() {}
function fl_unfreeze_all_forms (line 186) | inline void fl_unfreeze_all_forms() {}
function fl_set_focus_object (line 188) | inline void fl_set_focus_object(Fl_Window*, Fl_Widget* o) {Fl::focus(o);}
function fl_reset_focus_object (line 189) | inline void fl_reset_focus_object(Fl_Widget* o) {Fl::focus(o);}
function fl_set_object_boxtype (line 199) | inline void fl_set_object_boxtype(Fl_Widget* o, Fl_Boxtype a) {o->box(a);}
function fl_set_object_lsize (line 200) | inline void fl_set_object_lsize(Fl_Widget* o,int s) {o->labelsize(s);}
function fl_set_object_lstyle (line 203) | inline void fl_set_object_lstyle(Fl_Widget* o,int a) {
function fl_set_object_lcol (line 205) | inline void fl_set_object_lcol(Fl_Widget* o, Fl_Color a) {o->labelcolor(...
function fl_set_object_lalign (line 207) | inline void fl_set_object_lalign(Fl_Widget* o, Fl_Align a) {o->align(a);}
function fl_set_object_color (line 209) | inline void fl_set_object_color(Fl_Widget* o,Fl_Color a,Fl_Color b) {o->...
function fl_set_object_label (line 210) | inline void fl_set_object_label(Fl_Widget* o, const char* a) {o->label(a...
function fl_set_object_position (line 211) | inline void fl_set_object_position(Fl_Widget*o,int x,int y) {o->position...
function fl_set_object_size (line 212) | inline void fl_set_object_size(Fl_Widget* o, int w, int h) {o->size(w,h);}
function fl_set_object_geometry (line 213) | inline void fl_set_object_geometry(Fl_Widget* o,int x,int y,int w,int h)...
function fl_get_object_geometry (line 215) | inline void fl_get_object_geometry(Fl_Widget* o,int*x,int*y,int*w,int*h) {
function fl_get_object_position (line 217) | inline void fl_get_object_position(Fl_Widget* o,int*x,int*y) {
function fl_set_object_callback (line 221) | inline void fl_set_object_callback(Fl_Widget*o,Forms_CB c,long a) {o->ca...
function fl_call_object_callback (line 223) | inline void fl_call_object_callback(Fl_Widget* o) {o->do_callback();}
function fl_trigger_object (line 224) | inline void fl_trigger_object(Fl_Widget* o) {o->do_callback();}
function fl_set_object_return (line 225) | inline void fl_set_object_return(Fl_Widget* o, int v) {
function fl_redraw_object (line 228) | inline void fl_redraw_object(Fl_Widget* o) {o->redraw();}
function fl_show_object (line 229) | inline void fl_show_object(Fl_Widget* o) {o->show();}
function fl_hide_object (line 230) | inline void fl_hide_object(Fl_Widget* o) {o->hide();}
function fl_free_object (line 231) | inline void fl_free_object(Fl_Widget* x) {delete x;}
function fl_delete_object (line 232) | inline void fl_delete_object(Fl_Widget* o) {o->parent()->remove(*o);}
function fl_activate_object (line 233) | inline void fl_activate_object(Fl_Widget* o) {o->activate();}
function fl_deactivate_object (line 234) | inline void fl_deactivate_object(Fl_Widget* o) {o->deactivate();}
function fl_add_object (line 236) | inline void fl_add_object(Fl_Window* f, Fl_Widget* x) {f->add(x);}
function fl_insert_object (line 237) | inline void fl_insert_object(Fl_Widget* o, Fl_Widget* b) {b->parent()->i...
function Fl_Window (line 239) | inline Fl_Window* FL_ObjWin(Fl_Widget* o) {return o->window();}
function fl_get_border_width (line 245) | inline int fl_get_border_width() {return 3;}
function fl_set_border_width (line 246) | inline void fl_set_border_width(int) {}
function fl_set_object_dblbuffer (line 247) | inline void fl_set_object_dblbuffer(Fl_Widget*, int) {}
function fl_set_form_dblbuffer (line 248) | inline void fl_set_form_dblbuffer(Fl_Window*, int) {}
function fl_free_form (line 253) | inline void fl_free_form(Fl_Window* x) {delete x;}
function fl_redraw_form (line 254) | inline void fl_redraw_form(Fl_Window* f) {f->redraw();}
function Fl_Window (line 256) | inline Fl_Window* fl_bgn_form(Fl_Boxtype b,int w,int h) {
function fl_addto_form (line 262) | inline void fl_addto_form(Fl_Window* f) {f->begin();}
function Fl_Group (line 263) | inline Fl_Group* fl_bgn_group() {return new Fl_Group(0,0,0,0,0);}
function fl_end_group (line 264) | inline void fl_end_group() {Fl_Group::current()->forms_end();}
function fl_addto_group (line 265) | inline void fl_addto_group(Fl_Widget* o) {((Fl_Group* )o)->begin();}
function fl_scale_form (line 268) | inline void fl_scale_form(Fl_Window* f, double x, double y) {
function fl_set_form_position (line 270) | inline void fl_set_form_position(Fl_Window* f,int x,int y) {f->position(...
function fl_set_form_size (line 271) | inline void fl_set_form_size(Fl_Window* f, int w, int h) {f->size(w,h);}
function fl_set_form_geometry (line 272) | inline void fl_set_form_geometry(Fl_Window* f,int x,int y,int w,int h) {
function fl_adjust_form_size (line 275) | inline void fl_adjust_form_size(Fl_Window*) {}
function fl_set_form_hotspot (line 300) | inline void fl_set_form_hotspot(Fl_Window* w,int x,int y) {w->hotspot(x,...
function fl_set_form_hotobject (line 301) | inline void fl_set_form_hotobject(Fl_Window* w, Fl_Widget* o) {w->hotspo...
function fl_flip_yorigin (line 303) | inline void fl_flip_yorigin() {fl_flip = 1;}
function fl_show_form_window (line 306) | inline void fl_show_form_window(Fl_Window*) {}
function fl_raise_form (line 308) | inline void fl_raise_form(Fl_Window* f) {f->show();}
function fl_hide_form (line 310) | inline void fl_hide_form(Fl_Window* f) {f->hide();}
function fl_pop_form (line 311) | inline void fl_pop_form(Fl_Window* f) {f->show();}
function fl_activate_all_forms (line 314) | inline void fl_activate_all_forms() {}
function fl_deactivate_all_forms (line 315) | inline void fl_deactivate_all_forms() {fl_modal_next = 1;}
function fl_deactivate_form (line 316) | inline void fl_deactivate_form(Fl_Window*w) {w->deactivate();}
function fl_activate_form (line 317) | inline void fl_activate_form(Fl_Window*w) {w->activate();}
function fl_set_form_title (line 319) | inline void fl_set_form_title(Fl_Window* f, const char* s) {f->label(s);}
function fl_title_form (line 320) | inline void fl_title_form(Fl_Window* f, const char* s) {f->label(s);}
function fl_set_form_callback (line 323) | inline void fl_set_form_callback(Fl_Window* f,Forms_FormCB c) {f->callba...
function fl_init (line 326) | inline void fl_init() {}
function fl_form_is_visible (line 329) | inline int fl_form_is_visible(Fl_Window* f) {return f->visible();}
function fl_mouse_button (line 331) | inline int fl_mouse_button() {return Fl::event_button();}
function fl_drw_text (line 347) | inline void fl_drw_text(Fl_Align align, int x, int y, int w, int h,
function fl_drw_text_beside (line 356) | inline void fl_drw_text_beside(Fl_Align align, int x, int y, int w, int h,
function fl_set_font_name (line 364) | inline void fl_set_font_name(Fl_Font n,const char* s) {Fl::set_font(n,s);}
function fl_mapcolor (line 366) | inline void fl_mapcolor(Fl_Color c, uchar r, uchar g, uchar b) {Fl::set_...
function Fl_Widget (line 374) | inline Fl_Widget* fl_add_new(Fl_Widget* p) {return p;}
function Fl_Widget (line 375) | inline Fl_Widget* fl_add_new(uchar t,Fl_Widget* p) {p->type(t); return p;}
function fl_set_bitmap_data (line 390) | inline void fl_set_bitmap_data(Fl_Widget* o, int w, int h, const uchar* ...
function fl_set_pixmap_data (line 397) | inline void fl_set_pixmap_data(Fl_Widget* o, char*const* b) {
function fl_set_pixmap_align (line 401) | inline void fl_set_pixmap_align(Fl_Widget* o,Fl_Align a,int,int) {o->ali...
function fl_clear_browser (line 410) | inline void fl_clear_browser(Fl_Widget* o) {
function fl_add_browser_line (line 412) | inline void fl_add_browser_line(Fl_Widget* o, const char* s) {
function fl_addto_browser (line 414) | inline void fl_addto_browser(Fl_Widget* o, const char* s) {
function fl_insert_browser_line (line 418) | inline void fl_insert_browser_line(Fl_Widget* o, int n, const char* s) {
function fl_delete_browser_line (line 420) | inline void fl_delete_browser_line(Fl_Widget* o, int n) {
function fl_replace_browser_line (line 422) | inline void fl_replace_browser_line(Fl_Widget* o, int n, const char* s) {
function fl_load_browser (line 426) | inline int fl_load_browser(Fl_Widget* o, const char* f) {
function fl_select_browser_line (line 428) | inline void fl_select_browser_line(Fl_Widget* o, int n) {
function fl_deselect_browser_line (line 430) | inline void fl_deselect_browser_line(Fl_Widget* o, int n) {
function fl_deselect_browser (line 432) | inline void fl_deselect_browser(Fl_Widget* o) {
function fl_isselected_browser_line (line 434) | inline int fl_isselected_browser_line(Fl_Widget* o, int n) {
function fl_get_browser_topline (line 436) | inline int fl_get_browser_topline(Fl_Widget* o) {
function fl_get_browser (line 438) | inline int fl_get_browser(Fl_Widget* o) {
function fl_get_browser_maxline (line 440) | inline int fl_get_browser_maxline(Fl_Widget* o) {
function fl_set_browser_topline (line 443) | inline void fl_set_browser_topline(Fl_Widget* o, int n) {
function fl_set_browser_fontsize (line 445) | inline void fl_set_browser_fontsize(Fl_Widget* o, int s) {
function fl_set_browser_fontstyle (line 447) | inline void fl_set_browser_fontstyle(Fl_Widget* o, Fl_Font s) {
function fl_set_browser_specialkey (line 449) | inline void fl_set_browser_specialkey(Fl_Widget* o, char c) {
function fl_setdisplayed_browser_line (line 460) | inline void fl_setdisplayed_browser_line(Fl_Widget* o, int n, int i) {
function fl_isdisplayed_browser_line (line 462) | inline int fl_isdisplayed_browser_line(Fl_Widget* o, int n) {
function fl_get_button (line 476) | inline int fl_get_button(Fl_Widget* b) {return ((Fl_Button*)b)->value();}
function fl_set_button (line 477) | inline void fl_set_button(Fl_Widget* b, int v) {((Fl_Button*)b)->value(v);}
function fl_get_button_numb (line 478) | inline int fl_get_button_numb(Fl_Widget*) {return Fl::event_button();}
function Fl_Widget (line 493) | inline Fl_Widget* fl_add_bitmapbutton(int t,int x,int y,int w,int h,cons...
function fl_set_bitmapbutton_data (line 494) | inline void fl_set_bitmapbutton_data(Fl_Widget* o,int a,int b,uchar* c) {
function Fl_Widget (line 497) | inline Fl_Widget* fl_add_pixmapbutton(int t,int x,int y,int w,int h,cons...
function fl_set_pixmapbutton_data (line 498) | inline void fl_set_pixmapbutton_data(Fl_Widget* o, const char*const* c) {
function fl_clear_chart (line 506) | inline void fl_clear_chart(Fl_Widget* o) {
function fl_add_chart_value (line 508) | inline void fl_add_chart_value(Fl_Widget* o,double v,const char* s,uchar...
function fl_insert_chart_value (line 510) | inline void fl_insert_chart_value(Fl_Widget* o, int i, double v, const c...
function fl_replace_chart_value (line 512) | inline void fl_replace_chart_value(Fl_Widget* o, int i, double v, const ...
function fl_set_chart_bounds (line 514) | inline void fl_set_chart_bounds(Fl_Widget* o, double a, double b) {
function fl_set_chart_maxnumb (line 516) | inline void fl_set_chart_maxnumb(Fl_Widget* o, int v) {
function fl_set_chart_autosize (line 518) | inline void fl_set_chart_autosize(Fl_Widget* o, int v) {
function fl_set_chart_lstyle (line 520) | inline void fl_set_chart_lstyle(Fl_Widget* o, Fl_Font v) {
function fl_set_chart_lsize (line 522) | inline void fl_set_chart_lsize(Fl_Widget* o, int v) {
function fl_set_chart_lcolor (line 524) | inline void fl_set_chart_lcolor(Fl_Widget* o, Fl_Color v) {
function fl_clear_choice (line 535) | inline void fl_clear_choice(Fl_Widget* o) {
function fl_addto_choice (line 537) | inline void fl_addto_choice(Fl_Widget* o, const char* s) {
function fl_replace_choice (line 539) | inline void fl_replace_choice(Fl_Widget* o, int i, const char* s) {
function fl_delete_choice (line 541) | inline void fl_delete_choice(Fl_Widget* o, int i) {
function fl_set_choice (line 543) | inline void fl_set_choice(Fl_Widget* o, int i) {
function fl_get_choice (line 546) | inline int fl_get_choice(Fl_Widget* o) {
function fl_set_choice_fontsize (line 552) | inline void fl_set_choice_fontsize(Fl_Widget* o, int x) {
function fl_set_choice_fontstyle (line 554) | inline void fl_set_choice_fontstyle(Fl_Widget* o, Fl_Font x) {
function fl_get_clock (line 561) | inline void fl_get_clock(Fl_Widget* o, int* h, int* m, int* s) {
function fl_set_counter_value (line 569) | inline void fl_set_counter_value(Fl_Widget* o, double v) {
function fl_set_counter_bounds (line 571) | inline void fl_set_counter_bounds(Fl_Widget* o, double a, double b) {
function fl_set_counter_step (line 573) | inline void fl_set_counter_step(Fl_Widget* o, double a, double b) {
function fl_set_counter_precision (line 575) | inline void fl_set_counter_precision(Fl_Widget* o, int v) {
function fl_set_counter_return (line 577) | inline void fl_set_counter_return(Fl_Widget* o, int v) {
function fl_get_counter_value (line 579) | inline double fl_get_counter_value(Fl_Widget* o) {
function fl_get_counter_bounds (line 581) | inline void fl_get_counter_bounds(Fl_Widget* o, float* a, float* b) {
function fl_set_cursor (line 588) | inline void fl_set_cursor(Fl_Window* w, Fl_Cursor c) {w->cursor(c);}
function fl_set_dial_value (line 598) | inline void fl_set_dial_value(Fl_Widget* o, double v) {
function fl_get_dial_value (line 600) | inline double fl_get_dial_value(Fl_Widget* o) {
function fl_set_dial_bounds (line 602) | inline void fl_set_dial_bounds(Fl_Widget* o, double a, double b) {
function fl_get_dial_bounds (line 604) | inline void fl_get_dial_bounds(Fl_Widget* o, float* a, float* b) {
function fl_set_dial_return (line 608) | inline void fl_set_dial_return(Fl_Widget* o, int i) {
function fl_set_dial_angles (line 610) | inline void fl_set_dial_angles(Fl_Widget* o, int a, int b) {
function fl_set_dial_step (line 615) | inline void fl_set_dial_step(Fl_Widget* o, double v) {
function Fl_Widget (line 620) | inline Fl_Widget* fl_add_frame(Fl_Boxtype i,int x,int y,int w,int h,cons...
function Fl_Widget (line 624) | inline Fl_Widget* fl_add_labelframe(Fl_Boxtype i,int x,int y,int w,int h...
function Fl_Free (line 631) | inline Fl_Free*
function fl_set_goodies_font (line 656) | inline void fl_set_goodies_font(Fl_Font a, Fl_Fontsize b) {fl_message_fo...
function fl_show_choices (line 658) | inline int fl_show_choices(const char* c,int n,const char* b1,const char...
function do_matching (line 665) | inline int do_matching(char* a, const char* b) {return fl_filename_match...
function fl_set_input (line 676) | inline void fl_set_input(Fl_Widget* o, const char* v) {
function fl_set_input_return (line 678) | inline void fl_set_input_return(Fl_Widget* o, int x) {
function fl_set_input_color (line 680) | inline void fl_set_input_color(Fl_Widget* o, Fl_Color a, Fl_Color b) {
function fl_set_input_cursorpos (line 685) | inline void fl_set_input_cursorpos(Fl_Widget* o, int x, int /*y*/) {
function fl_get_input_cursorpos (line 698) | inline int fl_get_input_cursorpos(Fl_Widget* o, int*x, int*y) {
function fl_clear_menu (line 712) | inline void fl_clear_menu(Fl_Widget* o) {
function fl_set_menu (line 714) | inline void fl_set_menu(Fl_Widget* o, const char* s) {
function fl_addto_menu (line 716) | inline void fl_addto_menu(Fl_Widget* o, const char* s) {
function fl_replace_menu_item (line 718) | inline void fl_replace_menu_item(Fl_Widget* o, int i, const char* s) {
function fl_delete_menu_item (line 720) | inline void fl_delete_menu_item(Fl_Widget* o, int i) {
function fl_set_menu_item_shortcut (line 722) | inline void fl_set_menu_item_shortcut(Fl_Widget* o, int i, const char* s) {
function fl_set_menu_item_mode (line 724) | inline void fl_set_menu_item_mode(Fl_Widget* o, int i, long x) {
function fl_show_menu_symbol (line 726) | inline void fl_show_menu_symbol(Fl_Widget*, int ) {
function fl_get_menu (line 729) | inline int fl_get_menu(Fl_Widget* o) {
function fl_get_menu_maxitems (line 733) | inline int fl_get_menu_maxitems(Fl_Widget* o) {
function fl_get_menu_item_mode (line 735) | inline int fl_get_menu_item_mode(Fl_Widget* o, int i) {
function fl_set_positioner_xvalue (line 743) | inline void fl_set_positioner_xvalue(Fl_Widget* o, double v) {
function fl_get_positioner_xvalue (line 745) | inline double fl_get_positioner_xvalue(Fl_Widget* o) {
function fl_set_positioner_xbounds (line 747) | inline void fl_set_positioner_xbounds(Fl_Widget* o, double a, double b) {
function fl_get_positioner_xbounds (line 749) | inline void fl_get_positioner_xbounds(Fl_Widget* o, float* a, float* b) {
function fl_set_positioner_yvalue (line 753) | inline void fl_set_positioner_yvalue(Fl_Widget* o, double v) {
function fl_get_positioner_yvalue (line 755) | inline double fl_get_positioner_yvalue(Fl_Widget* o) {
function fl_set_positioner_ybounds (line 757) | inline void fl_set_positioner_ybounds(Fl_Widget* o, double a, double b) {
function fl_get_positioner_ybounds (line 759) | inline void fl_get_positioner_ybounds(Fl_Widget* o, float* a, float* b) {
function fl_set_positioner_xstep (line 763) | inline void fl_set_positioner_xstep(Fl_Widget* o, double v) {
function fl_set_positioner_ystep (line 765) | inline void fl_set_positioner_ystep(Fl_Widget* o, double v) {
function fl_set_positioner_return (line 767) | inline void fl_set_positioner_return(Fl_Widget* o, int v) {
function fl_set_slider_value (line 777) | inline void fl_set_slider_value(Fl_Widget* o, double v) {
function fl_get_slider_value (line 779) | inline double fl_get_slider_value(Fl_Widget* o) {
function fl_set_slider_bounds (line 781) | inline void fl_set_slider_bounds(Fl_Widget* o, double a, double b) {
function fl_get_slider_bounds (line 783) | inline void fl_get_slider_bounds(Fl_Widget* o, float* a, float* b) {
function fl_set_slider_return (line 787) | inline void fl_set_slider_return(Fl_Widget* o, int i) {
function fl_set_slider_step (line 789) | inline void fl_set_slider_step(Fl_Widget* o, double v) {
function fl_set_slider_size (line 792) | inline void fl_set_slider_size(Fl_Widget* o, double v) {
function fl_set_slider_precision (line 798) | inline void fl_set_slider_precision(Fl_Widget* o, int i) {
function fl_set_timer (line 816) | inline void fl_set_timer(Fl_Widget* o, double v) {((Fl_Timer*)o)->value(...
function fl_get_timer (line 817) | inline double fl_get_timer(Fl_Widget* o) {return ((Fl_Timer*)o)->value();}
function fl_suspend_timer (line 818) | inline void fl_suspend_timer(Fl_Widget* o) {((Fl_Timer*)o)->suspended(1);}
function fl_resume_timer (line 819) | inline void fl_resume_timer(Fl_Widget* o) {((Fl_Timer*)o)->suspended(0);}
function fl_set_timer_countup (line 820) | inline void fl_set_timer_countup(Fl_Widget* o,char d) {((Fl_Timer*)o)->d...
function fl_double_click (line 828) | inline int fl_double_click() {return Fl::event_clicks();}
function fl_draw (line 829) | inline void fl_draw() {Fl::flush();}
FILE: Game Trainers/common/include/FL/gl.h
function gl_color (line 73) | inline void gl_color(int c) {gl_color((Fl_Color)c);}
FILE: Game Trainers/common/include/FL/gl2opengl.h
function clear (line 15) | inline void clear() {glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);}
function pushmatrix (line 29) | inline void pushmatrix() {glPushMatrix();}
function popmatrix (line 30) | inline void popmatrix() {glPopMatrix();}
function multmatrix (line 31) | inline void multmatrix(Matrix m) {glMultMatrixf((float *)m);}
function color (line 32) | inline void color(int n) {glIndexi(n);}
function rect (line 33) | inline void rect(int x,int y,int r,int t) {gl_rect(x,y,r-x,t-y);}
function rectf (line 34) | inline void rectf(int x,int y,int r,int t) {glRectf(x,y,r+1,t+1);}
function recti (line 35) | inline void recti(int x,int y,int r,int t) {gl_rect(x,y,r-x,t-y);}
function rectfi (line 36) | inline void rectfi(int x,int y,int r,int t) {glRecti(x,y,r+1,t+1);}
function rects (line 37) | inline void rects(int x,int y,int r,int t) {gl_rect(x,y,r-x,t-y);}
function rectfs (line 38) | inline void rectfs(int x,int y,int r,int t) {glRects(x,y,r+1,t+1);}
FILE: Game Trainers/common/include/FL/glut.H
function glutPostRedisplay (line 121) | inline void glutPostRedisplay() {
function glutGetWindow (line 129) | inline int glutGetWindow() {
function glutSetWindowTitle (line 135) | inline void glutSetWindowTitle(char *t) {
function glutSetIconTitle (line 139) | inline void glutSetIconTitle(char *t) {
function glutPositionWindow (line 143) | inline void glutPositionWindow(int x, int y) {
function glutReshapeWindow (line 147) | inline void glutReshapeWindow(int w, int h) {
function glutPopWindow (line 151) | inline void glutPopWindow() {
function glutPushWindow (line 155) | inline void glutPushWindow() { /* do nothing */ }
function glutIconifyWindow (line 157) | inline void glutIconifyWindow() {
function glutShowWindow (line 161) | inline void glutShowWindow() {
function glutHideWindow (line 165) | inline void glutHideWindow() {
function glutFullScreen (line 169) | inline void glutFullScreen() {
function glutSetCursor (line 173) | inline void glutSetCursor(Fl_Cursor cursor) {
function glutWarpPointer (line 202) | inline void glutWarpPointer(int, int) { /* do nothing */ }
function glutEstablishOverlay (line 204) | inline void glutEstablishOverlay() {
function glutRemoveOverlay (line 208) | inline void glutRemoveOverlay() {
function glutUseLayer (line 212) | inline void glutUseLayer(GLenum layer) {
function glutPostOverlayRedisplay (line 220) | inline void glutPostOverlayRedisplay() {
function glutShowOverlay (line 224) | inline void glutShowOverlay() {
function glutHideOverlay (line 228) | inline void glutHideOverlay() {
function glutGetMenu (line 236) | inline int glutGetMenu() {return glut_menu;}
function glutSetMenu (line 238) | inline void glutSetMenu(int m) {glut_menu = m;}
function glutAttachMenu (line 250) | inline void glutAttachMenu(int b) {
function glutDetachMenu (line 254) | inline void glutDetachMenu(int b) {
function glutDisplayFunc (line 258) | inline void glutDisplayFunc(void (*f)()) {
function glutReshapeFunc (line 262) | inline void glutReshapeFunc(void (*f)(int w, int h)) {
function glutKeyboardFunc (line 266) | inline void glutKeyboardFunc(void (*f)(uchar key, int x, int y)) {
function glutMouseFunc (line 270) | inline void glutMouseFunc(void (*f)(int b, int state, int x, int y)) {
function glutMotionFunc (line 280) | inline void glutMotionFunc(void (*f)(int x, int y)) {
function glutPassiveMotionFunc (line 284) | inline void glutPassiveMotionFunc(void (*f)(int x, int y)) {
function glutEntryFunc (line 288) | inline void glutEntryFunc(void (*f)(int s)) {
function glutVisibilityFunc (line 294) | inline void glutVisibilityFunc(void (*f)(int s)) {
function glutTimerFunc (line 301) | inline void glutTimerFunc(unsigned int msec, void (*f)(int), int value) {
function glutMenuStateFunc (line 305) | inline void glutMenuStateFunc(void (*f)(int state)) {
function glutMenuStatusFunc (line 308) | inline void glutMenuStatusFunc(void (*f)(int status, int x, int y)) {
function glutSpecialFunc (line 312) | inline void glutSpecialFunc(void (*f)(int key, int x, int y)) {
function glutOverlayDisplayFunc (line 353) | inline void glutOverlayDisplayFunc(void (*f)()) {
function glutGetModifiers (line 435) | inline int glutGetModifiers() {
type Fl_Glut_Bitmap_Font (line 475) | struct Fl_Glut_Bitmap_Font {Fl_Font font; Fl_Fontsize size;}
type Fl_Glut_StrokeVertex (line 498) | struct Fl_Glut_StrokeVertex {
type Fl_Glut_StrokeStrip (line 502) | struct Fl_Glut_StrokeStrip {
type Fl_Glut_StrokeChar (line 507) | struct Fl_Glut_StrokeChar {
type Fl_Glut_StrokeFont (line 513) | struct Fl_Glut_StrokeFont {
FILE: Game Trainers/common/include/FL/mac.H
type FLWindow (line 38) | typedef FLWindow *Window;
type class (line 40) | typedef class FLWindow *Window;
type NSInteger (line 109) | typedef long NSInteger;
type NSUInteger (line 110) | typedef unsigned long NSUInteger;
type NSInteger (line 112) | typedef int NSInteger;
type NSUInteger (line 113) | typedef unsigned int NSUInteger;
type CGImageAlphaInfo (line 118) | typedef CGImageAlphaInfo CGBitmapInfo;
type flCocoaRegion (line 121) | struct flCocoaRegion {
type CGFloat (line 128) | typedef double CGFloat;
type CGFloat (line 130) | typedef float CGFloat;
type CGContext (line 136) | struct CGContext
type Fl_Menu_Item (line 174) | struct Fl_Menu_Item
function class (line 176) | class Fl_Mac_App_Menu {
FILE: Game Trainers/common/include/FL/math.h
function rint (line 45) | inline double rint(double v) {return floor(v+.5);}
function copysign (line 46) | inline double copysign(double a, double b) {return b<0 ? -a : a;}
FILE: Game Trainers/common/include/FL/platform.H
function class (line 52) | class FL_EXPORT Fl_X {
function Window (line 68) | inline Window fl_xid(const Fl_Window* w) { Fl_X *xTemp = Fl_X::flx(w); r...
FILE: Game Trainers/common/include/FL/platform_types.h
type opaque (line 31) | typedef opaque fl_intptr_t;
type opaque (line 36) | typedef opaque fl_uintptr_t;
type opaque (line 46) | typedef opaque Fl_Offscreen;
type opaque (line 56) | struct opaque
type opaque (line 57) | typedef opaque FL_SOCKET;
type opaque (line 66) | struct opaque
type opaque (line 73) | typedef opaque Fl_Timestamp;
type fl_intptr_t (line 106) | typedef intptr_t fl_intptr_t;
type fl_uintptr_t (line 107) | typedef uintptr_t fl_uintptr_t;
type fl_intptr_t (line 111) | typedef long fl_intptr_t;
type fl_uintptr_t (line 112) | typedef unsigned long fl_uintptr_t;
type fl_uintptr_t (line 118) | typedef fl_uintptr_t Fl_Offscreen;
type dirent (line 122) | struct dirent {char d_name[1];}
type FL_SOCKET (line 128) | typedef unsigned __int64 FL_SOCKET;
type FL_SOCKET (line 130) | typedef int FL_SOCKET;
type Fl_Timestamp_t (line 142) | struct Fl_Timestamp_t {
type Fl_Timestamp (line 147) | typedef struct Fl_Timestamp_t Fl_Timestamp;
FILE: Game Trainers/common/include/FL/wayland.H
type cairo_t (line 27) | typedef struct _cairo cairo_t;
type wld_window (line 32) | struct wld_window
type wld_window (line 36) | struct wld_window
type wld_window (line 58) | struct wld_window
FILE: Game Trainers/common/include/FL/win32.H
type HWND (line 45) | typedef HWND Window;
type HGLRC__ (line 47) | struct HGLRC__
function FL_EXPORT (line 74) | extern FL_EXPORT struct Fl_XMap {
function COLORREF (line 80) | inline COLORREF fl_RGB() {return fl_current_xmap->rgb;}
function HPEN (line 81) | inline HPEN fl_pen() {return fl_current_xmap->pen;}
FILE: Game Trainers/common/include/FL/x11.H
type __GLXcontextRec (line 61) | struct __GLXcontextRec
type cairo_t (line 77) | typedef struct _cairo cairo_t;
FILE: Game Trainers/common/include/FLTKUtils.h
type TimeoutData (line 29) | struct TimeoutData
type ChangeLanguageData (line 36) | struct ChangeLanguageData
type ApplyData (line 43) | struct ApplyData
type ToggleData (line 52) | struct ToggleData
type WidgetPair (line 61) | struct WidgetPair
type InfoCallbackData (line 68) | struct InfoCallbackData
function load_translations (line 107) | void load_translations(const char *resource_name)
function change_language (line 202) | void change_language(const std::string &lang, Fl_Group *group)
function check_process_status (line 376) | void check_process_status(void *data)
function class (line 422) | class ItemTable : public Fl_Table
function setItems (line 584) | void setItems(const std::vector<std::vector<std::string>> &item_list)
function info_callback (line 595) | void info_callback(Fl_Widget *widget, void *data)
function Fl_Button (line 676) | Fl_Button *create_info_button(
function Fl_Input (line 882) | Fl_Input *place_indented_input_widget(
FILE: Game Trainers/common/include/Il2CppBase.h
function class (line 6) | class Il2CppBase : public TrainerBase
FILE: Game Trainers/common/include/MinHook.h
type MH_STATUS (line 38) | typedef enum MH_STATUS
FILE: Game Trainers/common/include/MonoBase.h
function class (line 11) | class MonoBase : public TrainerBase
FILE: Game Trainers/common/include/MonoBridge.cpp
type ParamValue (line 27) | struct ParamValue
type Type (line 29) | enum Type
type FunctionPointers (line 43) | struct FunctionPointers
type LoadAssemblyParams (line 49) | struct LoadAssemblyParams
type InvokeMethodParams (line 54) | struct InvokeMethodParams
type SharedMemoryHeader (line 63) | struct SharedMemoryHeader
function SendData (line 80) | __declspec(dllexport) void SendData(const char *message)
function Log (line 132) | void Log(const char *message)
function LogToFile (line 138) | void LogToFile(const char *message)
function SendResponse (line 150) | __declspec(dllexport) void SendResponse(const char *message)
function InitializeMono (line 202) | void InitializeMono()
function LoadAssembly (line 228) | void LoadAssembly(const char *path)
function DWORD (line 250) | __declspec(dllexport) DWORD WINAPI LoadAssemblyThread(LPVOID lpParam)
function DWORD (line 257) | __declspec(dllexport) DWORD WINAPI InvokeMethodThread(LPVOID lpParam)
function DWORD (line 368) | __declspec(dllexport) DWORD WINAPI GetFunctionPointersThread(LPVOID lpPa...
function BOOL (line 376) | BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID ...
FILE: Game Trainers/common/include/TrainerBase.h
type HookInfo (line 16) | struct HookInfo
type PatternByte (line 33) | struct PatternByte
type PointerToggleInfo (line 42) | struct PointerToggleInfo
function class (line 60) | class TrainerBase
function disableNamedPointerToggle (line 178) | inline bool disableNamedPointerToggle(const std::string &name)
function disableAllPointerToggles (line 199) | inline void disableAllPointerToggles()
function findPatternWild (line 410) | inline uintptr_t findPatternWild(const wchar_t *moduleName, const std::v...
FILE: Game Trainers/common/include/il2cpp/hook.h
function load (line 6) | struct HOOK {
FILE: Game Trainers/common/include/il2cpp/il2cpp.cpp
type IL2CPP (line 4) | namespace IL2CPP {
type API (line 8) | namespace API {
function Initialize (line 14) | bool Initialize(MEMORY memory)
function Attach (line 32) | void Attach() {
function Il2CppImage (line 38) | Il2CppImage* ASSEMBLY::Image() {
function NAMESPACE (line 42) | NAMESPACE* ASSEMBLY::Namespace(const char* namespace_name) {
function ASSEMBLY (line 46) | ASSEMBLY* ASSEMBLY::List(size_t* size) {
function CLASS (line 57) | CLASS* NAMESPACE::Class(const char* class_name) {
function TYPE (line 63) | TYPE* CLASS::Type(const char* field_name) {
function METHOD (line 67) | METHOD* CLASS::Method(const char* method_name, int args_count) {
function FIELD (line 71) | FIELD* CLASS::Field(const char* field_name) {
function Il2CppImage (line 87) | const Il2CppImage* CLASS::Image() {
function TYPE (line 97) | TYPE* FIELD::Type() {
function OBJECT (line 113) | OBJECT* FIELD::GetObject(OBJECT* obj) {
function ARRAY (line 117) | ARRAY* FIELD::GetArray(OBJECT* obj) {
function STRING (line 121) | STRING* FIELD::GetString(OBJECT* obj) {
function OBJECT (line 125) | OBJECT* FIELD::GetStaticObject() {
function ARRAY (line 129) | ARRAY* FIELD::GetStaticArray() {
function STRING (line 133) | STRING* FIELD::GetStaticString() {
function CLASS (line 145) | CLASS* TYPE::Class() {
function FIELD (line 155) | FIELD* OBJECT::Field(const char* field_name) {
function OBJECT (line 159) | OBJECT* OBJECT::GetObject(const char* field_name) {
function ARRAY (line 163) | ARRAY* OBJECT::GetArray(const char* field_name) {
function STRING (line 167) | STRING* OBJECT::GetString(const char* field_name) {
function CLASS (line 171) | CLASS* OBJECT::Class() {
function TYPE (line 175) | TYPE* OBJECT::Type(const char* field_name) {
function OBJECT (line 189) | OBJECT* ARRAY::GetObject(size_t id) {
function STRING (line 193) | STRING* ARRAY::GetString(size_t id) {
function wchar_t (line 202) | const wchar_t* STRING::WChars() {
function ASSEMBLY (line 206) | ASSEMBLY* Assembly(const char* assembly_name) {
function STRING (line 210) | STRING* String(const char* str){
function CLASS (line 214) | CLASS* Class(const char* assembly_name, const char* namespace_name, co...
function FIELD (line 218) | FIELD* Field(const char* assembly_name, const char* namespace_name, co...
function METHOD (line 222) | METHOD* Method(const char* assembly_name, const char* namespace_name, ...
FILE: Game Trainers/common/include/il2cpp/il2cpp.h
function namespace (line 18) | namespace IL2CPP
FILE: Game Trainers/common/include/il2cpp/il2cpp_types.h
type Il2CppClass (line 157) | typedef struct Il2CppClass Il2CppClass;
type Il2CppType (line 158) | typedef struct Il2CppType Il2CppType;
type EventInfo (line 159) | typedef struct EventInfo EventInfo;
type MethodInfo (line 160) | typedef struct MethodInfo MethodInfo;
type FieldInfo (line 161) | typedef struct FieldInfo FieldInfo;
type PropertyInfo (line 162) | typedef struct PropertyInfo PropertyInfo;
type Il2CppAssembly (line 163) | typedef struct Il2CppAssembly Il2CppAssembly;
type Il2CppArray (line 164) | typedef struct Il2CppArray Il2CppArray;
type Il2CppDelegate (line 165) | typedef struct Il2CppDelegate Il2CppDelegate;
type Il2CppDomain (line 166) | typedef struct Il2CppDomain Il2CppDomain;
type Il2CppImage (line 167) | typedef struct Il2CppImage Il2CppImage;
type Il2CppException (line 168) | typedef struct Il2CppException Il2CppException;
type Il2CppProfiler (line 169) | typedef struct Il2CppProfiler Il2CppProfiler;
type Il2CppObject (line 170) | typedef struct Il2CppObject Il2CppObject;
type Il2CppReflectionMethod (line 171) | typedef struct Il2CppReflectionMethod Il2CppReflectionMethod;
type Il2CppReflectionType (line 172) | typedef struct Il2CppReflectionType Il2CppReflectionType;
type Il2CppString (line 173) | typedef struct Il2CppString Il2CppString;
type Il2CppThread (line 174) | typedef struct Il2CppThread Il2CppThread;
type Il2CppAsyncResult (line 175) | typedef struct Il2CppAsyncResult Il2CppAsyncResult;
type Il2CppManagedMemorySnapshot (line 176) | typedef struct Il2CppManagedMemorySnapshot Il2CppManagedMemorySnapshot;
type Il2CppCustomAttrInfo (line 177) | typedef struct Il2CppCustomAttrInfo Il2CppCustomAttrInfo;
type Il2CppProfileFlags (line 178) | typedef enum
type Il2CppProfileFileIOKind (line 203) | typedef enum
type Il2CppGCEvent (line 208) | typedef enum
type Il2CppStat (line 221) | typedef enum
type Il2CppRuntimeUnhandledExceptionPolicy (line 232) | typedef enum
type Il2CppStackFrameInfo (line 237) | typedef struct Il2CppStackFrameInfo
type Il2CppMethodDebugInfo (line 242) | typedef struct Il2CppMethodDebugInfo
type Il2CppMemoryCallbacks (line 248) | typedef struct
type Il2CppDebuggerTransport (line 258) | typedef struct
type Il2CppChar (line 268) | typedef uint16_t Il2CppChar;
type Il2CppNativeChar (line 269) | typedef char Il2CppNativeChar;
type Il2CppNativeChar (line 280) | typedef const Il2CppNativeChar* (*Il2CppSetFindPlugInCallback)(const Il2...
type Il2CppManagedMemorySnapshot (line 283) | typedef struct Il2CppManagedMemorySnapshot Il2CppManagedMemorySnapshot;
type il2cpp_array_size_t (line 284) | typedef uintptr_t il2cpp_array_size_t;
type Il2CppMethodSlot (line 286) | typedef uint32_t Il2CppMethodSlot;
type il2cpp_hresult_t (line 289) | typedef int32_t il2cpp_hresult_t;
type Il2CppMetadataField (line 290) | typedef struct Il2CppMetadataField
type Il2CppMetadataTypeFlags (line 297) | typedef enum Il2CppMetadataTypeFlags
type Il2CppMetadataType (line 304) | typedef struct Il2CppMetadataType
type Il2CppMetadataSnapshot (line 317) | typedef struct Il2CppMetadataSnapshot
type Il2CppManagedMemorySection (line 322) | typedef struct Il2CppManagedMemorySection
type Il2CppManagedHeap (line 328) | typedef struct Il2CppManagedHeap
type Il2CppStacks (line 333) | typedef struct Il2CppStacks
type NativeObject (line 338) | typedef struct NativeObject
type Il2CppGCHandles (line 347) | typedef struct Il2CppGCHandles
type Il2CppRuntimeInformation (line 352) | typedef struct Il2CppRuntimeInformation
type Il2CppManagedMemorySnapshot (line 361) | typedef struct Il2CppManagedMemorySnapshot
type Il2CppTypeEnum (line 370) | typedef enum Il2CppTypeEnum
type Il2CppTokenType (line 409) | typedef enum
type TypeIndex (line 434) | typedef int32_t TypeIndex;
type TypeDefinitionIndex (line 435) | typedef int32_t TypeDefinitionIndex;
type FieldIndex (line 436) | typedef int32_t FieldIndex;
type DefaultValueIndex (line 437) | typedef int32_t DefaultValueIndex;
type DefaultValueDataIndex (line 438) | typedef int32_t DefaultValueDataIndex;
type CustomAttributeIndex (line 439) | typedef int32_t CustomAttributeIndex;
type ParameterIndex (line 440) | typedef int32_t ParameterIndex;
type MethodIndex (line 441) | typedef int32_t MethodIndex;
type GenericMethodIndex (line 442) | typedef int32_t GenericMethodIndex;
type PropertyIndex (line 443) | typedef int32_t PropertyIndex;
type EventIndex (line 444) | typedef int32_t EventIndex;
type GenericContainerIndex (line 445) | typedef int32_t GenericContainerIndex;
type GenericParameterIndex (line 446) | typedef int32_t GenericParameterIndex;
type GenericParameterConstraintIndex (line 447) | typedef int16_t GenericParameterConstraintIndex;
type NestedTypeIndex (line 448) | typedef int32_t NestedTypeIndex;
type InterfacesIndex (line 449) | typedef int32_t InterfacesIndex;
type VTableIndex (line 450) | typedef int32_t VTableIndex;
type InterfaceOffsetIndex (line 451) | typedef int32_t InterfaceOffsetIndex;
type RGCTXIndex (line 452) | typedef int32_t RGCTXIndex;
type StringIndex (line 453) | typedef int32_t StringIndex;
type StringLiteralIndex (line 454) | typedef int32_t StringLiteralIndex;
type GenericInstIndex (line 455) | typedef int32_t GenericInstIndex;
type ImageIndex (line 456) | typedef int32_t ImageIndex;
type AssemblyIndex (line 457) | typedef int32_t AssemblyIndex;
type InteropDataIndex (line 458) | typedef int32_t InteropDataIndex;
type EncodedMethodIndex (line 472) | typedef uint32_t EncodedMethodIndex;
type Il2CppMetadataUsage (line 473) | typedef enum Il2CppMetadataUsage
type Il2CppImage (line 483) | typedef struct Il2CppImage Il2CppImage;
type Il2CppType (line 484) | typedef struct Il2CppType Il2CppType;
type Il2CppTypeDefinitionMetadata (line 485) | typedef struct Il2CppTypeDefinitionMetadata Il2CppTypeDefinitionMetadata;
type Il2CppRGCTXDefinitionData (line 486) | typedef union Il2CppRGCTXDefinitionData
type Il2CppRGCTXDataType (line 492) | typedef enum Il2CppRGCTXDataType
type Il2CppRGCTXDefinition (line 500) | typedef struct Il2CppRGCTXDefinition
type Il2CppInterfaceOffsetPair (line 505) | typedef struct Il2CppInterfaceOffsetPair
type Il2CppTypeDefinition (line 510) | typedef struct Il2CppTypeDefinition
type Il2CppFieldDefinition (line 540) | typedef struct Il2CppFieldDefinition
type Il2CppFieldDefaultValue (line 546) | typedef struct Il2CppFieldDefaultValue
type Il2CppFieldMarshaledSize (line 552) | typedef struct Il2CppFieldMarshaledSize
type Il2CppFieldRef (line 558) | typedef struct Il2CppFieldRef
type Il2CppParameterDefinition (line 563) | typedef struct Il2CppParameterDefinition
type Il2CppParameterDefaultValue (line 569) | typedef struct Il2CppParameterDefaultValue
type Il2CppMethodDefinition (line 575) | typedef struct Il2CppMethodDefinition
type Il2CppEventDefinition (line 588) | typedef struct Il2CppEventDefinition
type Il2CppPropertyDefinition (line 597) | typedef struct Il2CppPropertyDefinition
type Il2CppMethodSpec (line 605) | typedef struct Il2CppMethodSpec
type Il2CppStringLiteral (line 611) | typedef struct Il2CppStringLiteral
type Il2CppGenericMethodIndices (line 616) | typedef struct
type Il2CppGenericMethodFunctionsDefinitions (line 622) | typedef struct Il2CppGenericMethodFunctionsDefinitions
type Il2CppAssemblyNameDefinition (line 628) | typedef struct Il2CppAssemblyNameDefinition
type Il2CppImageDefinition (line 642) | typedef struct Il2CppImageDefinition
type Il2CppAssemblyDefinition (line 655) | typedef struct Il2CppAssemblyDefinition
type Il2CppMetadataUsageList (line 663) | typedef struct Il2CppMetadataUsageList
type Il2CppMetadataUsagePair (line 668) | typedef struct Il2CppMetadataUsagePair
type Il2CppCustomAttributeTypeRange (line 673) | typedef struct Il2CppCustomAttributeTypeRange
type Il2CppRange (line 679) | typedef struct Il2CppRange
type Il2CppWindowsRuntimeTypeNamePair (line 684) | typedef struct Il2CppWindowsRuntimeTypeNamePair
type Il2CppGlobalMetadataHeader (line 690) | typedef struct Il2CppGlobalMetadataHeader
type Il2CppClass (line 760) | typedef struct Il2CppClass Il2CppClass;
type MethodInfo (line 761) | typedef struct MethodInfo MethodInfo;
type Il2CppType (line 762) | typedef struct Il2CppType Il2CppType;
type Il2CppArrayType (line 763) | typedef struct Il2CppArrayType
type Il2CppGenericInst (line 772) | typedef struct Il2CppGenericInst
type Il2CppGenericContext (line 777) | typedef struct Il2CppGenericContext
type Il2CppGenericParameter (line 782) | typedef struct Il2CppGenericParameter
type Il2CppGenericContainer (line 791) | typedef struct Il2CppGenericContainer
type Il2CppGenericClass (line 798) | typedef struct Il2CppGenericClass
type Il2CppGenericMethod (line 804) | typedef struct Il2CppGenericMethod
type Il2CppType (line 809) | typedef struct Il2CppType
type Il2CppCallConvention (line 826) | typedef enum Il2CppCallConvention
type Il2CppCharSet (line 835) | typedef enum Il2CppCharSet
type Il2CppHString__ (line 841) | typedef struct Il2CppHString__
type Il2CppHString__ (line 845) | typedef Il2CppHString__* Il2CppHString;
type Il2CppHStringHeader (line 846) | typedef struct Il2CppHStringHeader
type Il2CppGuid (line 854) | typedef struct Il2CppGuid
type Il2CppSafeArrayBound (line 861) | typedef struct Il2CppSafeArrayBound
type Il2CppSafeArray (line 866) | typedef struct Il2CppSafeArray
type Il2CppWin32Decimal (line 875) | typedef struct Il2CppWin32Decimal
type IL2CPP_VARIANT_BOOL (line 898) | typedef int16_t IL2CPP_VARIANT_BOOL;
type Il2CppVarType (line 899) | typedef enum Il2CppVarType
type Il2CppVariant (line 954) | typedef struct Il2CppVariant Il2CppVariant;
type Il2CppIUnknown (line 955) | typedef struct Il2CppIUnknown Il2CppIUnknown;
type Il2CppVariant (line 956) | typedef struct Il2CppVariant
type Il2CppFileTime (line 1021) | typedef struct Il2CppFileTime
type Il2CppStatStg (line 1026) | typedef struct Il2CppStatStg
type Il2CppWindowsRuntimeTypeKind (line 1040) | typedef enum Il2CppWindowsRuntimeTypeKind
type Il2CppWindowsRuntimeTypeName (line 1046) | typedef struct Il2CppWindowsRuntimeTypeName
type Il2CppIUnknown (line 1054) | struct Il2CppIUnknown
type Il2CppInteropData (line 1055) | typedef struct Il2CppInteropData
type Il2CppClass (line 1065) | typedef struct Il2CppClass Il2CppClass;
type Il2CppGuid (line 1066) | typedef struct Il2CppGuid Il2CppGuid;
type Il2CppImage (line 1067) | typedef struct Il2CppImage Il2CppImage;
type Il2CppAppDomain (line 1068) | typedef struct Il2CppAppDomain Il2CppAppDomain;
type Il2CppAppDomainSetup (line 1069) | typedef struct Il2CppAppDomainSetup Il2CppAppDomainSetup;
type Il2CppDelegate (line 1070) | typedef struct Il2CppDelegate Il2CppDelegate;
type Il2CppAppContext (line 1071) | typedef struct Il2CppAppContext Il2CppAppContext;
type Il2CppNameToTypeDefinitionIndexHashTable (line 1072) | typedef struct Il2CppNameToTypeDefinitionIndexHashTable Il2CppNameToType...
type Il2CppCodeGenModule (line 1073) | typedef struct Il2CppCodeGenModule Il2CppCodeGenModule;
type VirtualInvokeData (line 1074) | typedef struct VirtualInvokeData
type Il2CppTypeNameFormat (line 1079) | typedef enum Il2CppTypeNameFormat
type Il2CppDefaults (line 1086) | typedef struct Il2CppDefaults
type Il2CppClass (line 1188) | typedef struct Il2CppClass Il2CppClass;
type MethodInfo (line 1189) | typedef struct MethodInfo MethodInfo;
type FieldInfo (line 1190) | typedef struct FieldInfo FieldInfo;
type Il2CppObject (line 1191) | typedef struct Il2CppObject Il2CppObject;
type MemberInfo (line 1192) | typedef struct MemberInfo MemberInfo;
type CustomAttributesCache (line 1193) | typedef struct CustomAttributesCache
type FieldInfo (line 1199) | typedef struct FieldInfo
type PropertyInfo (line 1207) | typedef struct PropertyInfo
type EventInfo (line 1216) | typedef struct EventInfo
type ParameterInfo (line 1226) | typedef struct ParameterInfo
type MethodVariableKind (line 1234) | typedef enum MethodVariableKind
type SequencePointKind (line 1240) | typedef enum SequencePointKind
type Il2CppMethodExecutionContextInfo (line 1245) | typedef struct Il2CppMethodExecutionContextInfo
type Il2CppMethodExecutionContextInfoIndex (line 1251) | typedef struct Il2CppMethodExecutionContextInfoIndex
type Il2CppMethodScope (line 1256) | typedef struct Il2CppMethodScope
type Il2CppMethodHeaderInfo (line 1261) | typedef struct Il2CppMethodHeaderInfo
type Il2CppSequencePointSourceFile (line 1267) | typedef struct Il2CppSequencePointSourceFile
type Il2CppTypeSourceFilePair (line 1272) | typedef struct Il2CppTypeSourceFilePair
type Il2CppSequencePoint (line 1277) | typedef struct Il2CppSequencePoint
type Il2CppCatchPoint (line 1288) | typedef struct Il2CppCatchPoint
type Il2CppDebuggerMetadataRegistration (line 1296) | typedef struct Il2CppDebuggerMetadataRegistration
type Il2CppRGCTXData (line 1311) | typedef union Il2CppRGCTXData
type MethodInfo (line 1318) | typedef struct MethodInfo
type Il2CppRuntimeInterfaceOffsetPair (line 1346) | typedef struct Il2CppRuntimeInterfaceOffsetPair
type Il2CppClass (line 1351) | typedef struct Il2CppClass
type Il2CppTypeDefinitionSizes (line 1427) | typedef struct Il2CppTypeDefinitionSizes
type Il2CppDomain (line 1434) | typedef struct Il2CppDomain
type Il2CppAssemblyName (line 1444) | typedef struct Il2CppAssemblyName
type Il2CppImage (line 1458) | typedef struct Il2CppImage
type Il2CppAssembly (line 1475) | typedef struct Il2CppAssembly
type Il2CppCodeGenOptions (line 1483) | typedef struct Il2CppCodeGenOptions
type Il2CppTokenIndexPair (line 1488) | typedef struct Il2CppTokenIndexPair
type Il2CppTokenRangePair (line 1493) | typedef struct Il2CppTokenRangePair
type Il2CppTokenIndexMethodTuple (line 1498) | typedef struct Il2CppTokenIndexMethodTuple
type Il2CppTokenAdjustorThunkPair (line 1505) | typedef struct Il2CppTokenAdjustorThunkPair
type Il2CppWindowsRuntimeFactoryTableEntry (line 1510) | typedef struct Il2CppWindowsRuntimeFactoryTableEntry
type Il2CppCodeGenModule (line 1515) | typedef struct Il2CppCodeGenModule
type Il2CppCodeRegistration (line 1531) | typedef struct Il2CppCodeRegistration
type Il2CppMetadataRegistration (line 1551) | typedef struct Il2CppMetadataRegistration
type Il2CppPerfCounters (line 1570) | typedef struct Il2CppPerfCounters
type Il2CppClass (line 1637) | typedef struct Il2CppClass Il2CppClass;
type MethodInfo (line 1638) | typedef struct MethodInfo MethodInfo;
type PropertyInfo (line 1639) | typedef struct PropertyInfo PropertyInfo;
type FieldInfo (line 1640) | typedef struct FieldInfo FieldInfo;
type EventInfo (line 1641) | typedef struct EventInfo EventInfo;
type Il2CppType (line 1642) | typedef struct Il2CppType Il2CppType;
type Il2CppAssembly (line 1643) | typedef struct Il2CppAssembly Il2CppAssembly;
type Il2CppException (line 1644) | typedef struct Il2CppException Il2CppException;
type Il2CppImage (line 1645) | typedef struct Il2CppImage Il2CppImage;
type Il2CppDomain (line 1646) | typedef struct Il2CppDomain Il2CppDomain;
type Il2CppString (line 1647) | typedef struct Il2CppString Il2CppString;
type Il2CppReflectionMethod (line 1648) | typedef struct Il2CppReflectionMethod Il2CppReflectionMethod;
type Il2CppAsyncCall (line 1649) | typedef struct Il2CppAsyncCall Il2CppAsyncCall;
type Il2CppIUnknown (line 1650) | typedef struct Il2CppIUnknown Il2CppIUnknown;
type Il2CppWaitHandle (line 1651) | typedef struct Il2CppWaitHandle Il2CppWaitHandle;
type MonitorData (line 1652) | typedef struct MonitorData MonitorData;
type Il2CppReflectionAssembly (line 1653) | typedef struct Il2CppReflectionAssembly Il2CppReflectionAssembly;
type Il2CppClass (line 1654) | typedef Il2CppClass Il2CppVTable;
type Il2CppObject (line 1655) | typedef struct Il2CppObject
type il2cpp_array_lower_bound_t (line 1664) | typedef int32_t il2cpp_array_lower_bound_t;
type Il2CppArrayBounds (line 1665) | typedef struct Il2CppArrayBounds
type Il2CppArray (line 1670) | typedef struct Il2CppArray
type Il2CppArraySize (line 1676) | typedef struct Il2CppArraySize
type Il2CppString (line 1683) | typedef struct Il2CppString
type Il2CppReflectionType (line 1689) | typedef struct Il2CppReflectionType
type Il2CppReflectionRuntimeType (line 1694) | typedef struct Il2CppReflectionRuntimeType
type Il2CppReflectionMonoType (line 1701) | typedef struct Il2CppReflectionMonoType
type Il2CppReflectionEvent (line 1705) | typedef struct Il2CppReflectionEvent
type Il2CppReflectionMonoEvent (line 1710) | typedef struct Il2CppReflectionMonoEvent
type Il2CppReflectionMonoEventInfo (line 1716) | typedef struct Il2CppReflectionMonoEventInfo
type Il2CppReflectionField (line 1727) | typedef struct Il2CppReflectionField
type Il2CppReflectionProperty (line 1736) | typedef struct Il2CppReflectionProperty
type Il2CppReflectionMethod (line 1742) | typedef struct Il2CppReflectionMethod
type Il2CppReflectionGenericMethod (line 1749) | typedef struct Il2CppReflectionGenericMethod
type Il2CppMethodInfo (line 1753) | typedef struct Il2CppMethodInfo
type Il2CppPropertyInfo (line 1761) | typedef struct Il2CppPropertyInfo
type Il2CppReflectionParameter (line 1770) | typedef struct Il2CppReflectionParameter
type Il2CppReflectionModule (line 1781) | typedef struct Il2CppReflectionModule
type Il2CppReflectionAssemblyName (line 1792) | typedef struct Il2CppReflectionAssemblyName
type Il2CppReflectionAssembly (line 1809) | typedef struct Il2CppReflectionAssembly
type Il2CppReflectionMarshal (line 1823) | typedef struct Il2CppReflectionMarshal
type Il2CppReflectionPointer (line 1836) | typedef struct Il2CppReflectionPointer
type Il2CppInternalThread (line 1842) | typedef struct Il2CppInternalThread
type Il2CppIOSelectorJob (line 1885) | typedef struct Il2CppIOSelectorJob
type Il2CppCallType (line 1892) | typedef enum
type Il2CppMethodMessage (line 1899) | typedef struct Il2CppMethodMessage
type Il2CppAppDomainSetup (line 1912) | typedef struct Il2CppAppDomainSetup
type Il2CppThread (line 1938) | typedef struct Il2CppThread
type Il2CppException (line 1950) | typedef struct Il2CppException
type Il2CppSystemException (line 1969) | typedef struct Il2CppSystemException
type Il2CppArgumentException (line 1973) | typedef struct Il2CppArgumentException
type Il2CppTypedRef (line 1978) | typedef struct Il2CppTypedRef
type Il2CppDelegate (line 1984) | typedef struct Il2CppDelegate
type Il2CppMulticastDelegate (line 1999) | typedef struct Il2CppMulticastDelegate
type Il2CppMarshalByRefObject (line 2004) | typedef struct Il2CppMarshalByRefObject
type Il2CppAppDomain (line 2009) | typedef struct Il2CppAppDomain
type Il2CppStackFrame (line 2014) | typedef struct Il2CppStackFrame
type Il2CppDateTimeFormatInfo (line 2027) | typedef struct Il2CppDateTimeFormatInfo
type Il2CppNumberFormatInfo (line 2081) | typedef struct Il2CppNumberFormatInfo
type Il2CppCultureData (line 2119) | typedef struct Il2CppCultureData
type Il2CppCalendarData (line 2130) | typedef struct Il2CppCalendarData
type Il2CppCultureInfo (line 2149) | typedef struct Il2CppCultureInfo
type Il2CppRegionInfo (line 2180) | typedef struct Il2CppRegionInfo
type Il2CppSafeHandle (line 2194) | typedef struct Il2CppSafeHandle
type Il2CppStringBuilder (line 2202) | typedef struct Il2CppStringBuilder Il2CppStringBuilder;
type Il2CppStringBuilder (line 2203) | typedef struct Il2CppStringBuilder
type Il2CppSocketAddress (line 2212) | typedef struct Il2CppSocketAddress
type Il2CppSortKey (line 2220) | typedef struct Il2CppSortKey
type Il2CppErrorWrapper (line 2228) | typedef struct Il2CppErrorWrapper
type Il2CppAsyncResult (line 2233) | typedef struct Il2CppAsyncResult
type Il2CppAsyncCall (line 2248) | typedef struct Il2CppAsyncCall
type Il2CppExceptionWrapper (line 2258) | typedef struct Il2CppExceptionWrapper Il2CppExceptionWrapper;
type Il2CppExceptionWrapper (line 2259) | typedef struct Il2CppExceptionWrapper
type Il2CppIOAsyncResult (line 2263) | typedef struct Il2CppIOAsyncResult
type Il2CppSocketAsyncResult (line 2272) | typedef struct Il2CppSocketAsyncResult
type Il2CppResourceLocation (line 2294) | typedef enum Il2CppResourceLocation
type Il2CppManifestResourceInfo (line 2300) | typedef struct Il2CppManifestResourceInfo
type Il2CppAppContext (line 2307) | typedef struct Il2CppAppContext
type Il2CppDecimal (line 2314) | typedef struct Il2CppDecimal
type Il2CppDouble (line 2337) | typedef struct Il2CppDouble
type Il2CppDouble_double (line 2344) | typedef union Il2CppDouble_double
type Il2CppDecimalCompareResult (line 2349) | typedef enum Il2CppDecimalCompareResult
type Il2CppSingle (line 2355) | typedef struct Il2CppSingle
type Il2CppSingle_float (line 2361) | typedef union Il2CppSingle_float
FILE: Game Trainers/common/include/il2cpp/memory.h
function class (line 5) | class MEMORY
FILE: Game Trainers/common/include/il2cpp/unity.cpp
type Unity (line 3) | namespace Unity {
function Initialize (line 13) | bool Initialize(MEMORY memory) {
FILE: Game Trainers/common/include/il2cpp/unity.h
type vec3 (line 8) | struct vec3
type Rect (line 9) | struct Rect
type GUIContent (line 10) | struct GUIContent
type GUIStyle (line 11) | struct GUIStyle
function namespace (line 22) | namespace Unity
FILE: Game Trainers/common/include/il2cpp/vec.h
type Vector2 (line 7) | struct Vector2 {
type Vector3 (line 16) | struct Vector3
function Length (line 26) | float Length() {
function Length2D (line 30) | float Length2D() {
function Vector2 (line 34) | Vector2 DeltaAngle(Vector3 target) {
FILE: Game Trainers/common/include/nlohmann/adl_serializer.hpp
function from_json (line 27) | static auto from_json(BasicJsonType && j, TargetType& val) noexcept(
function from_json (line 37) | static auto from_json(BasicJsonType && j) noexcept(
function to_json (line 47) | static auto to_json(BasicJsonType& j, TargetType && val) noexcept(
FILE: Game Trainers/common/include/nlohmann/byte_container_with_subtype.hpp
function set_subtype (line 70) | void set_subtype(subtype_type subtype_) noexcept
function subtype_type (line 78) | constexpr subtype_type subtype() const noexcept
function has_subtype (line 85) | constexpr bool has_subtype() const noexcept
function clear_subtype (line 92) | void clear_subtype() noexcept
FILE: Game Trainers/common/include/nlohmann/detail/conversions/from_json.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 35) | NLOHMANN_JSON_NAMESPACE_BEGIN
FILE: Game Trainers/common/include/nlohmann/detail/conversions/to_chars.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 21) | NLOHMANN_JSON_NAMESPACE_BEGIN
FILE: Game Trainers/common/include/nlohmann/detail/conversions/to_json.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 31) | NLOHMANN_JSON_NAMESPACE_BEGIN
FILE: Game Trainers/common/include/nlohmann/detail/exceptions.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 40) | NLOHMANN_JSON_NAMESPACE_BEGIN
class parse_error (line 148) | class parse_error : public exception
method parse_error (line 161) | static parse_error create(int id_, const position_t& pos, const std::s...
method parse_error (line 169) | static parse_error create(int id_, std::size_t byte_, const std::strin...
method parse_error (line 189) | parse_error(int id_, std::size_t byte_, const char* what_arg)
method position_string (line 192) | static std::string position_string(const position_t& pos)
class invalid_iterator (line 201) | class invalid_iterator : public exception
method invalid_iterator (line 205) | static invalid_iterator create(int id_, const std::string& what_arg, B...
method JSON_HEDLEY_NON_NULL (line 212) | JSON_HEDLEY_NON_NULL(3)
class type_error (line 219) | class type_error : public exception
method type_error (line 223) | static type_error create(int id_, const std::string& what_arg, BasicJs...
method JSON_HEDLEY_NON_NULL (line 230) | JSON_HEDLEY_NON_NULL(3)
class out_of_range (line 236) | class out_of_range : public exception
method out_of_range (line 240) | static out_of_range create(int id_, const std::string& what_arg, Basic...
method JSON_HEDLEY_NON_NULL (line 247) | JSON_HEDLEY_NON_NULL(3)
class other_error (line 253) | class other_error : public exception
method other_error (line 257) | static other_error create(int id_, const std::string& what_arg, BasicJ...
method JSON_HEDLEY_NON_NULL (line 264) | JSON_HEDLEY_NON_NULL(3)
FILE: Game Trainers/common/include/nlohmann/detail/hash.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 18) | NLOHMANN_JSON_NAMESPACE_BEGIN
FILE: Game Trainers/common/include/nlohmann/detail/input/binary_reader.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 37) | NLOHMANN_JSON_NAMESPACE_BEGIN
FILE: Game Trainers/common/include/nlohmann/detail/input/input_adapters.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 31) | NLOHMANN_JSON_NAMESPACE_BEGIN
FILE: Game Trainers/common/include/nlohmann/detail/input/json_sax.hpp
class json_sax_dom_parser (line 167) | class json_sax_dom_parser
method json_sax_dom_parser (line 182) | explicit json_sax_dom_parser(BasicJsonType& r, const bool allow_except...
method json_sax_dom_parser (line 187) | json_sax_dom_parser(const json_sax_dom_parser&) = delete;
method json_sax_dom_parser (line 188) | json_sax_dom_parser(json_sax_dom_parser&&) = default;
method json_sax_dom_parser (line 189) | json_sax_dom_parser& operator=(const json_sax_dom_parser&) = delete;
method json_sax_dom_parser (line 190) | json_sax_dom_parser& operator=(json_sax_dom_parser&&) = default;
method null (line 193) | bool null()
method boolean (line 199) | bool boolean(bool val)
method number_integer (line 205) | bool number_integer(number_integer_t val)
method number_unsigned (line 211) | bool number_unsigned(number_unsigned_t val)
method number_float (line 217) | bool number_float(number_float_t val, const string_t& /*unused*/)
method string (line 223) | bool string(string_t& val)
method binary (line 229) | bool binary(binary_t& val)
method start_object (line 235) | bool start_object(std::size_t len)
method key (line 258) | bool key(string_t& val)
method end_object (line 268) | bool end_object()
method start_array (line 286) | bool start_array(std::size_t len)
method end_array (line 307) | bool end_array()
method parse_error (line 326) | bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
method is_errored (line 338) | constexpr bool is_errored() const
method handle_diagnostic_positions_for_json_value (line 346) | void handle_diagnostic_positions_for_json_value(BasicJsonType& v)
method JSON_HEDLEY_RETURNS_NON_NULL (line 420) | JSON_HEDLEY_RETURNS_NON_NULL
class json_sax_dom_callback_parser (line 473) | class json_sax_dom_callback_parser
method json_sax_dom_callback_parser (line 485) | json_sax_dom_callback_parser(BasicJsonType& r,
method json_sax_dom_callback_parser (line 495) | json_sax_dom_callback_parser(const json_sax_dom_callback_parser&) = de...
method json_sax_dom_callback_parser (line 496) | json_sax_dom_callback_parser(json_sax_dom_callback_parser&&) = default;
method json_sax_dom_callback_parser (line 497) | json_sax_dom_callback_parser& operator=(const json_sax_dom_callback_pa...
method json_sax_dom_callback_parser (line 498) | json_sax_dom_callback_parser& operator=(json_sax_dom_callback_parser&&...
method null (line 501) | bool null()
method boolean (line 507) | bool boolean(bool val)
method number_integer (line 513) | bool number_integer(number_integer_t val)
method number_unsigned (line 519) | bool number_unsigned(number_unsigned_t val)
method number_float (line 525) | bool number_float(number_float_t val, const string_t& /*unused*/)
method string (line 531) | bool string(string_t& val)
method binary (line 537) | bool binary(binary_t& val)
method start_object (line 543) | bool start_object(std::size_t len)
method key (line 575) | bool key(string_t& val)
method end_object (line 592) | bool end_object()
method start_array (line 642) | bool start_array(std::size_t len)
method end_array (line 674) | bool end_array()
method parse_error (line 721) | bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
method is_errored (line 733) | constexpr bool is_errored() const
method handle_diagnostic_positions_for_json_value (line 741) | void handle_diagnostic_positions_for_json_value(BasicJsonType& v)
method handle_value (line 820) | std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool ski...
class json_sax_acceptor (line 910) | class json_sax_acceptor
method null (line 919) | bool null()
method boolean (line 924) | bool boolean(bool /*unused*/)
method number_integer (line 929) | bool number_integer(number_integer_t /*unused*/)
method number_unsigned (line 934) | bool number_unsigned(number_unsigned_t /*unused*/)
method number_float (line 939) | bool number_float(number_float_t /*unused*/, const string_t& /*unused*/)
method string (line 944) | bool string(string_t& /*unused*/)
method binary (line 949) | bool binary(binary_t& /*unused*/)
method start_object (line 954) | bool start_object(std::size_t /*unused*/ = detail::unknown_size())
method key (line 959) | bool key(string_t& /*unused*/)
method end_object (line 964) | bool end_object()
method start_array (line 969) | bool start_array(std::size_t /*unused*/ = detail::unknown_size())
method end_array (line 974) | bool end_array()
method parse_error (line 979) | bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/...
FILE: Game Trainers/common/include/nlohmann/detail/input/lexer.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 26) | NLOHMANN_JSON_NAMESPACE_BEGIN
function reset (line 1323) | void reset() noexcept
function char_int_type (line 1341) | char_int_type get()
function unget (line 1378) | void unget()
function add (line 1405) | void add(char_int_type c)
function number_unsigned_t (line 1422) | constexpr number_unsigned_t get_number_unsigned() const noexcept
function number_float_t (line 1428) | constexpr number_float_t get_number_float() const noexcept
function string_t (line 1434) | string_t& get_string()
function position_t (line 1449) | constexpr position_t get_position() const noexcept
function get_token_string (line 1457) | std::string get_token_string() const
function JSON_HEDLEY_RETURNS_NON_NULL (line 1481) | JSON_HEDLEY_RETURNS_NON_NULL
function skip_bom (line 1495) | bool skip_bom()
function skip_whitespace (line 1509) | void skip_whitespace()
function token_type (line 1518) | token_type scan()
FILE: Game Trainers/common/include/nlohmann/detail/input/parser.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 27) | NLOHMANN_JSON_NAMESPACE_BEGIN
FILE: Game Trainers/common/include/nlohmann/detail/input/position_t.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 15) | NLOHMANN_JSON_NAMESPACE_BEGIN
FILE: Game Trainers/common/include/nlohmann/detail/iterators/internal_iterator.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 14) | NLOHMANN_JSON_NAMESPACE_BEGIN
FILE: Game Trainers/common/include/nlohmann/detail/iterators/iter_impl.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 22) | NLOHMANN_JSON_NAMESPACE_BEGIN
function pointer (line 324) | pointer operator->() const
function iter_impl (line 366) | iter_impl operator++(int)& // NOLINT(cert-dcl21-cpp)
function iter_impl (line 377) | iter_impl& operator++()
function iter_impl (line 417) | iter_impl operator--(int)& // NOLINT(cert-dcl21-cpp)
function iter_impl (line 428) | iter_impl& operator--()
function iter_impl (line 585) | iter_impl& operator+=(difference_type i)
function iter_impl (line 622) | iter_impl& operator-=(difference_type i)
function iter_impl (line 631) | iter_impl operator+(difference_type i) const
function friend (line 642) | friend iter_impl operator+(difference_type i, const iter_impl& it)
function iter_impl (line 653) | iter_impl operator-(difference_type i) const
function difference_type (line 664) | difference_type operator-(const iter_impl& other) const
function reference (line 693) | reference operator[](difference_type n) const
function reference (line 747) | reference value() const
FILE: Game Trainers/common/include/nlohmann/detail/iterators/iteration_proxy.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 25) | NLOHMANN_JSON_NAMESPACE_BEGIN
function NLOHMANN_JSON_NAMESPACE_END (line 200) | NLOHMANN_JSON_NAMESPACE_END
FILE: Game Trainers/common/include/nlohmann/detail/iterators/iterator_traits.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 17) | NLOHMANN_JSON_NAMESPACE_BEGIN
FILE: Game Trainers/common/include/nlohmann/detail/iterators/json_reverse_iterator.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 17) | NLOHMANN_JSON_NAMESPACE_BEGIN
FILE: Game Trainers/common/include/nlohmann/detail/iterators/primitive_iterator.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 16) | NLOHMANN_JSON_NAMESPACE_BEGIN
FILE: Game Trainers/common/include/nlohmann/detail/json_custom_base_class.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 15) | NLOHMANN_JSON_NAMESPACE_BEGIN
FILE: Game Trainers/common/include/nlohmann/detail/json_pointer.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 30) | NLOHMANN_JSON_NAMESPACE_BEGIN
function NLOHMANN_BASIC_JSON_TPL_DECLARATION (line 50) | NLOHMANN_BASIC_JSON_TPL_DECLARATION
function json_pointer (line 62) | explicit json_pointer(const string_t& s = "")
function string_t (line 68) | string_t to_string() const
function friend (line 89) | friend std::ostream& operator<<(std::ostream& o, const json_pointer& ptr)
function json_pointer (line 98) | json_pointer& operator/=(const json_pointer& ptr)
function json_pointer (line 108) | json_pointer& operator/=(string_t token)
function json_pointer (line 116) | json_pointer& operator/=(std::size_t array_idx)
function friend (line 123) | friend json_pointer operator/(const json_pointer& lhs,
function friend (line 131) | friend json_pointer operator/(const json_pointer& lhs, string_t token) /...
function friend (line 138) | friend json_pointer operator/(const json_pointer& lhs, std::size_t array...
function json_pointer (line 145) | json_pointer parent_pointer() const
function pop_back (line 159) | void pop_back()
function string_t (line 171) | const string_t& back() const
function push_back (line 183) | void push_back(const string_t& token)
function push_back (line 190) | void push_back(string_t&& token)
function empty (line 197) | bool empty() const noexcept
function BasicJsonType (line 274) | BasicJsonType& get_and_create(BasicJsonType& j) const
function BasicJsonType (line 354) | BasicJsonType& get_unchecked(BasicJsonType* ptr) const
function BasicJsonType (line 422) | BasicJsonType& get_checked(BasicJsonType* ptr) const
function BasicJsonType (line 480) | const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const
function BasicJsonType (line 529) | const BasicJsonType& get_checked(const BasicJsonType* ptr) const
function contains (line 578) | bool contains(const BasicJsonType* ptr) const
function split (line 666) | static std::vector<string_t> split(const string_t& reference_string)
function BasicJsonType (line 806) | static BasicJsonType
function convert (line 835) | json_pointer<string_t> convert() const&
function convert (line 842) | json_pointer<string_t> convert()&&
FILE: Game Trainers/common/include/nlohmann/detail/json_ref.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 17) | NLOHMANN_JSON_NAMESPACE_BEGIN
FILE: Game Trainers/common/include/nlohmann/detail/macro_scope.hpp
function from_json (line 231) | inline void from_json(const BasicJsonType& j, ENUM_TYPE& e) ...
type would_call_std_ (line 518) | struct would_call_std_
FILE: Game Trainers/common/include/nlohmann/detail/meta/cpp_future.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 19) | NLOHMANN_JSON_NAMESPACE_BEGIN
FILE: Game Trainers/common/include/nlohmann/detail/meta/detected.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 15) | NLOHMANN_JSON_NAMESPACE_BEGIN
FILE: Game Trainers/common/include/nlohmann/detail/meta/identity_tag.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 13) | NLOHMANN_JSON_NAMESPACE_BEGIN
FILE: Game Trainers/common/include/nlohmann/detail/meta/is_sax.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 19) | NLOHMANN_JSON_NAMESPACE_BEGIN
FILE: Game Trainers/common/include/nlohmann/detail/meta/std_fs.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 15) | NLOHMANN_JSON_NAMESPACE_BEGIN
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 23) | NLOHMANN_JSON_NAMESPACE_BEGIN
FILE: Game Trainers/common/include/nlohmann/detail/meta/type_traits.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 25) | NLOHMANN_JSON_NAMESPACE_BEGIN
FILE: Game Trainers/common/include/nlohmann/detail/meta/void_t.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 13) | NLOHMANN_JSON_NAMESPACE_BEGIN
FILE: Game Trainers/common/include/nlohmann/detail/output/binary_writer.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 27) | NLOHMANN_JSON_NAMESPACE_BEGIN
FILE: Game Trainers/common/include/nlohmann/detail/output/output_adapters.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 25) | NLOHMANN_JSON_NAMESPACE_BEGIN
FILE: Game Trainers/common/include/nlohmann/detail/output/serializer.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 34) | NLOHMANN_JSON_NAMESPACE_BEGIN
function hex_bytes (line 677) | static std::string hex_bytes(std::uint8_t byte)
function is_negative_number (line 688) | bool is_negative_number(NumberType x)
function is_negative_number (line 694) | bool is_negative_number(NumberType /*unused*/)
function dump_integer (line 714) | void dump_integer(NumberType x)
function dump_float (line 799) | void dump_float(number_float_t x)
function dump_float (line 820) | void dump_float(number_float_t x, std::true_type /*is_ieee_single_or_dou...
function dump_float (line 828) | void dump_float(number_float_t x, std::false_type /*is_ieee_single_or_do...
function decode (line 900) | static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, co...
function number_unsigned_t (line 940) | number_unsigned_t remove_sign(number_unsigned_t x)
function number_unsigned_t (line 955) | number_unsigned_t remove_sign(number_integer_t x) noexcept
FILE: Game Trainers/common/include/nlohmann/detail/string_concat.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 18) | NLOHMANN_JSON_NAMESPACE_BEGIN
FILE: Game Trainers/common/include/nlohmann/detail/string_escape.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 13) | NLOHMANN_JSON_NAMESPACE_BEGIN
FILE: Game Trainers/common/include/nlohmann/detail/string_utils.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 16) | NLOHMANN_JSON_NAMESPACE_BEGIN
FILE: Game Trainers/common/include/nlohmann/detail/value_t.hpp
type value_t (line 53) | enum class value_t : std::uint8_t
FILE: Game Trainers/common/include/nlohmann/json.hpp
function NLOHMANN_JSON_NAMESPACE_BEGIN (line 77) | NLOHMANN_JSON_NAMESPACE_BEGIN
function set_parents (line 706) | void set_parents()
function iterator (line 743) | iterator set_parents(iterator it, typename iterator::difference_type cou...
function reference (line 756) | reference set_parent(reference j, std::size_t old_capacity = detail::unk...
function basic_json (line 818) | basic_json(const value_t v)
function basic_json (line 826) | basic_json(std::nullptr_t = nullptr) noexcept // NOLINT(bugprone-excepti...
function basic_json (line 838) | basic_json(CompatibleType && val) noexcept(noexcept( // NOLINT(bugprone-...
function basic_json (line 910) | basic_json(initializer_list_t init,
function JSON_HEDLEY_WARN_UNUSED_RESULT (line 968) | JSON_HEDLEY_WARN_UNUSED_RESULT
function JSON_HEDLEY_WARN_UNUSED_RESULT (line 979) | JSON_HEDLEY_WARN_UNUSED_RESULT
function JSON_HEDLEY_WARN_UNUSED_RESULT (line 990) | JSON_HEDLEY_WARN_UNUSED_RESULT
function JSON_HEDLEY_WARN_UNUSED_RESULT (line 1001) | JSON_HEDLEY_WARN_UNUSED_RESULT
function JSON_HEDLEY_WARN_UNUSED_RESULT (line 1012) | JSON_HEDLEY_WARN_UNUSED_RESULT
function JSON_HEDLEY_WARN_UNUSED_RESULT (line 1020) | JSON_HEDLEY_WARN_UNUSED_RESULT
function basic_json (line 1028) | basic_json(size_type cnt, const basic_json& val):
function basic_json (line 1040) | basic_json(InputIT first, InputIT last) // NOLINT(performance-unnecessar...
function basic_json (line 1149) | basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {}
function basic_json (line 1153) | basic_json(const basic_json& other)
function basic_json (line 1226) | basic_json(basic_json&& other) noexcept
function basic_json (line 1252) | basic_json& operator=(basic_json other) noexcept (
function value_t (line 1321) | constexpr value_t type() const noexcept
function is_primitive (line 1328) | constexpr bool is_primitive() const noexcept
function is_structured (line 1335) | constexpr bool is_structured() const noexcept
function is_null (line 1342) | constexpr bool is_null() const noexcept
function is_boolean (line 1349) | constexpr bool is_boolean() const noexcept
function is_number (line 1356) | constexpr bool is_number() const noexcept
function is_number_integer (line 1363) | constexpr bool is_number_integer() const noexcept
function is_number_unsigned (line 1370) | constexpr bool is_number_unsigned() const noexcept
function is_number_float (line 1377) | constexpr bool is_number_float() const noexcept
function is_object (line 1384) | constexpr bool is_object() const noexcept
function is_array (line 1391) | constexpr bool is_array() const noexcept
function is_string (line 1398) | constexpr bool is_string() const noexcept
function is_binary (line 1405) | constexpr bool is_binary() const noexcept
function is_discarded (line 1412) | constexpr bool is_discarded() const noexcept
function object_t (line 1443) | object_t* get_impl_ptr(object_t* /*unused*/) noexcept
function object_t (line 1449) | constexpr const object_t* get_impl_ptr(const object_t* /*unused*/) const...
function array_t (line 1455) | array_t* get_impl_ptr(array_t* /*unused*/) noexcept
function array_t (line 1461) | constexpr const array_t* get_impl_ptr(const array_t* /*unused*/) const n...
function string_t (line 1467) | string_t* get_impl_ptr(string_t* /*unused*/) noexcept
function string_t (line 1473) | constexpr const string_t* get_impl_ptr(const string_t* /*unused*/) const...
function boolean_t (line 1479) | boolean_t* get_impl_ptr(boolean_t* /*unused*/) noexcept
function boolean_t (line 1485) | constexpr const boolean_t* get_impl_ptr(const boolean_t* /*unused*/) con...
function number_integer_t (line 1491) | number_integer_t* get_impl_ptr(number_integer_t* /*unused*/) noexcept
function number_integer_t (line 1497) | constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /...
function number_unsigned_t (line 1503) | number_unsigned_t* get_impl_ptr(number_unsigned_t* /*unused*/) noexcept
function number_unsigned_t (line 1509) | constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t*...
function number_float_t (line 1515) | number_float_t* get_impl_ptr(number_float_t* /*unused*/) noexcept
function number_float_t (line 1521) | constexpr const number_float_t* get_impl_ptr(const number_float_t* /*unu...
function binary_t (line 1527) | binary_t* get_impl_ptr(binary_t* /*unused*/) noexcept
function binary_t (line 1533) | constexpr const binary_t* get_impl_ptr(const binary_t* /*unused*/) const...
function ReferenceType (line 1550) | static ReferenceType get_ref_impl(ThisType& obj)
function get_ptr (line 1583) | constexpr auto get_ptr() const noexcept -> decltype(std::declval<const b...
function ValueType (line 1675) | ValueType get_impl(detail::priority_tag<1> /*unused*/) const noexcept(no...
function BasicJsonType (line 1700) | BasicJsonType get_impl(detail::priority_tag<2> /*unused*/) const
function basic_json (line 1723) | basic_json get_impl(detail::priority_tag<3> /*unused*/) const
function get_impl (line 1736) | constexpr auto get_impl(detail::priority_tag<4> /*unused*/) const noexcept
function get (line 1812) | auto get() noexcept -> decltype(std::declval<basic_json_t&>().template g...
function ValueType (line 1825) | ValueType & get_to(ValueType& v) const noexcept(noexcept(
function ValueType (line 1838) | ValueType & get_to(ValueType& v) const
function Array (line 1849) | Array get_to(T (&v)[N]) const // NOLINT(cppcoreguidelines-avoid-c-arrays...
function ReferenceType (line 1861) | ReferenceType get_ref()
function ReferenceType (line 1872) | ReferenceType get_ref() const
function binary_t (line 1931) | binary_t& get_binary()
function binary_t (line 1943) | const binary_t& get_binary() const
function reference (line 1965) | reference at(size_type idx)
function const_reference (line 1988) | const_reference at(size_type idx) const
function reference (line 2011) | reference at(const typename object_t::key_type& key)
function reference (line 2031) | reference at(KeyType && key)
function const_reference (line 2049) | const_reference at(const typename object_t::key_type& key) const
function const_reference (line 2069) | const_reference at(KeyType && key) const
function reference (line 2087) | reference operator[](size_type idx)
function const_reference (line 2133) | const_reference operator[](size_type idx) const
function reference (line 2146) | reference operator[](typename object_t::key_type key) // NOLINT(performa...
function const_reference (line 2168) | const_reference operator[](const typename object_t::key_type& key) const
function reference (line 2184) | reference operator[](T* key)
function const_reference (line 2190) | const_reference operator[](T* key) const
function reference (line 2199) | reference operator[](KeyType && key)
function const_reference (line 2223) | const_reference operator[](KeyType && key) const
class ValueType (line 2249) | class ValueType
function ReturnType (line 2278) | ReturnType value(const typename object_t::key_type& key, ValueType && de...
function ValueType (line 2304) | ValueType value(KeyType && key, const ValueType& default_value) const
function ReturnType (line 2331) | ReturnType value(KeyType && key, ValueType && default_value) const
function ValueType (line 2354) | ValueType value(const json_pointer& ptr, const ValueType& default_value)...
function ReturnType (line 2379) | ReturnType value(const json_pointer& ptr, ValueType && default_value) const
function ValueType (line 2403) | ValueType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, cons...
function ReturnType (line 2414) | ReturnType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, Val...
function reference (line 2421) | reference front()
function const_reference (line 2428) | const_reference front() const
function reference (line 2435) | reference back()
function const_reference (line 2444) | const_reference back() const
function IteratorType (line 2456) | IteratorType erase(IteratorType pos) // NOLINT(performance-unnecessary-v...
function IteratorType (line 2526) | IteratorType erase(IteratorType first, IteratorType last) // NOLINT(perf...
function erase_internal (line 2594) | private:
function size_type (line 2610) | size_type erase_internal(KeyType && key)
function size_type (line 2642) | size_type erase(KeyType && key)
function erase (line 2649) | void erase(const size_type idx)
function iterator (line 2678) | iterator find(const typename object_t::key_type& key)
function const_iterator (line 2692) | const_iterator find(const typename object_t::key_type& key) const
function iterator (line 2708) | iterator find(KeyType && key)
function const_iterator (line 2724) | const_iterator find(KeyType && key) const
function size_type (line 2738) | size_type count(const typename object_t::key_type& key) const
function size_type (line 2748) | size_type count(KeyType && key) const
function contains (line 2756) | bool contains(const typename object_t::key_type& key) const
function contains (line 2765) | bool contains(KeyType && key) const
function contains (line 2772) | bool contains(const json_pointer& ptr) const
function contains (line 2779) | bool contains(const typename ::nlohmann::json_pointer<BasicJsonType>& pt...
function iterator (line 2795) | iterator begin() noexcept
function const_iterator (line 2804) | const_iterator begin() const noexcept
function const_iterator (line 2811) | const_iterator cbegin() const noexcept
function iterator (line 2820) | iterator end() noexcept
function const_iterator (line 2829) | const_iterator end() const noexcept
function const_iterator (line 2836) | const_iterator cend() const noexcept
function reverse_iterator (line 2845) | reverse_iterator rbegin() noexcept
function const_reverse_iterator (line 2852) | const_reverse_iterator rbegin() const noexcept
function reverse_iterator (line 2859) | reverse_iterator rend() noexcept
function const_reverse_iterator (line 2866) | const_reverse_iterator rend() const noexcept
function const_reverse_iterator (line 2873) | const_reverse_iterator crbegin() const noexcept
function const_reverse_iterator (line 2880) | const_reverse_iterator crend() const noexcept
function iterator_wrapper (line 2892) | static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept
function iterator_wrapper (line 2903) | static iteration_proxy<const_iterator> iterator_wrapper(const_reference ...
function items (line 2910) | iteration_proxy<iterator> items() noexcept
function items (line 2917) | iteration_proxy<const_iterator> items() const noexcept
function empty (line 2933) | bool empty() const noexcept
function size_type (line 2972) | size_type size() const noexcept
function size_type (line 3011) | size_type max_size() const noexcept
function clear (line 3054) | void clear() noexcept
function push_back (line 3115) | void push_back(basic_json&& val)
function reference (line 3140) | reference operator+=(basic_json&& val)
function push_back (line 3148) | void push_back(const basic_json& val)
function reference (line 3172) | reference operator+=(const basic_json& val)
function push_back (line 3180) | void push_back(const typename object_t::value_type& val)
function reference (line 3203) | reference operator+=(const typename object_t::value_type& val)
function push_back (line 3211) | void push_back(initializer_list_t init)
function reference (line 3227) | reference operator+=(initializer_list_t init)
function reference (line 3236) | reference emplace_back(Args&& ... args)
function emplace (line 3261) | std::pair<iterator, bool> emplace(Args&& ... args)
function iterator (line 3293) | iterator insert_iterator(const_iterator pos, Args&& ... args) // NOLINT(...
function iterator (line 3312) | iterator insert(const_iterator pos, const basic_json& val) // NOLINT(per...
function iterator (line 3332) | iterator insert(const_iterator pos, basic_json&& val) // NOLINT(performa...
function iterator (line 3339) | iterator insert(const_iterator pos, size_type cnt, const basic_json& val...
function iterator (line 3359) | iterator insert(const_iterator pos, const_iterator first, const_iterator...
function iterator (line 3390) | iterator insert(const_iterator pos, initializer_list_t ilist) // NOLINT(...
function insert (line 3410) | void insert(const_iterator first, const_iterator last) // NOLINT(perform...
function update (line 3436) | void update(const_reference j, bool merge_objects = false)
function update (line 3443) | void update(const_iterator first, const_iterator last, bool merge_object...
function swap (line 3490) | void swap(reference other) noexcept (
function friend (line 3507) | friend void swap(reference left, reference right) noexcept (
function swap (line 3519) | void swap(array_t& other) // NOLINT(bugprone-exception-escape,cppcoregui...
function swap (line 3535) | void swap(object_t& other) // NOLINT(bugprone-exception-escape,cppcoregu...
function swap (line 3551) | void swap(string_t& other) // NOLINT(bugprone-exception-escape,cppcoregu...
function swap (line 3567) | void swap(binary_t& other) // NOLINT(bugprone-exception-escape,cppcoregu...
function swap (line 3583) | void swap(typename binary_t::container_type& other) // NOLINT(bugprone-e...
function else (line 3672) | else if(compares_unordered(lhs, rhs))\
function compares_unordered (line 3701) | bool compares_unordered(const_reference rhs, bool inverse = false) const...
function friend (line 3814) | friend bool operator==(const_reference lhs, const_reference rhs) noexcept
function friend (line 3846) | friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
function friend (line 3903) | friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
function friend (line 3932) | friend bool operator>(const_reference lhs, const_reference rhs) noexcept
function friend (line 3962) | friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
function friend (line 4003) | friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
function JSON_HEDLEY_WARN_UNUSED_RESULT (line 4042) | JSON_HEDLEY_WARN_UNUSED_RESULT
function JSON_HEDLEY_WARN_UNUSED_RESULT (line 4056) | JSON_HEDLEY_WARN_UNUSED_RESULT
function basic_json (line 4070) | static basic_json parse(detail::span_input_adapter&& i,
function accept (line 4083) | static bool accept(InputType&& i,
function accept (line 4092) | static bool accept(IteratorType first, IteratorType last,
function accept (line 4100) | static bool accept(detail::span_input_adapter&& i,
function sax_parse (line 4110) | static bool sax_parse(InputType&& i, SAX* sax,
function sax_parse (line 4125) | static bool sax_parse(IteratorType first, IteratorType last, SAX* sax,
function sax_parse (line 4144) | static bool sax_parse(detail::span_input_adapter&& i, SAX* sax,
function JSON_HEDLEY_RETURNS_NON_NULL (line 4185) | JSON_HEDLEY_RETURNS_NON_NULL
type data (line 4217) | struct data
method data (line 4225) | data(const value_t v)
method data (line 4230) | data(size_type cnt, const basic_json& val)
method data (line 4236) | data() noexcept = default;
method data (line 4237) | data(data&&) noexcept = default;
method data (line 4238) | data(const data&) noexcept = delete;
method data (line 4239) | data& operator=(data&&) noexcept = delete;
method data (line 4240) | data& operator=(const data&) noexcept = delete;
function end_pos (line 4266) | constexpr std::size_t end_pos() const noexcept
function to_cbor (line 4291) | static void to_cbor(const basic_json& j, detail::output_adapter<std::uin...
function to_cbor (line 4298) | static void to_cbor(const basic_json& j, detail::output_adapter<char> o)
function to_msgpack (line 4305) | static std::vector<std::uint8_t> to_msgpack(const basic_json& j)
function to_msgpack (line 4314) | static void to_msgpack(const basic_json& j, detail::output_adapter<std::...
function to_msgpack (line 4321) | static void to_msgpack(const basic_json& j, detail::output_adapter<char> o)
function to_ubjson (line 4328) | static std::vector<std::uint8_t> to_ubjson(const basic_json& j,
function to_ubjson (line 4339) | static void to_ubjson(const basic_json& j, detail::output_adapter<std::u...
function to_ubjson (line 4347) | static void to_ubjson(const basic_json& j, detail::output_adapter<char> o,
function to_bjdata (line 4355) | static std::vector<std::uint8_t> to_bjdata(const basic_json& j,
function to_bjdata (line 4367) | static void to_bjdata(const basic_json& j, detail::output_adapter<std::u...
function to_bjdata (line 4376) | static void to_bjdata(const basic_json& j, detail::output_adapter<char> o,
function to_bson (line 4385) | static std::vector<std::uint8_t> to_bson(const basic_json& j)
function to_bson (line 4394) | static void to_bson(const basic_json& j, detail::output_adapter<std::uin...
function to_bson (line 4401) | static void to_bson(const basic_json& j, detail::output_adapter<char> o)
function JSON_HEDLEY_WARN_UNUSED_RESULT (line 4409) | JSON_HEDLEY_WARN_UNUSED_RESULT
function JSON_HEDLEY_WARN_UNUSED_RESULT (line 4425) | JSON_HEDLEY_WARN_UNUSED_RESULT
function basic_json (line 4441) | static basic_json from_cbor(const T* ptr, std::size_t len,
function basic_json (line 4451) | static basic_json from_cbor(detail::span_input_adapter&& i,
function JSON_HEDLEY_WARN_UNUSED_RESULT (line 4467) | JSON_HEDLEY_WARN_UNUSED_RESULT
function JSON_HEDLEY_WARN_UNUSED_RESULT (line 4482) | JSON_HEDLEY_WARN_UNUSED_RESULT
function basic_json (line 4497) | static basic_json from_msgpack(const T* ptr, std::size_t len,
function basic_json (line 4506) | static basic_json from_msgpack(detail::span_input_adapter&& i,
function JSON_HEDLEY_WARN_UNUSED_RESULT (line 4521) | JSON_HEDLEY_WARN_UNUSED_RESULT
function JSON_HEDLEY_WARN_UNUSED_RESULT (line 4536) | JSON_HEDLEY_WARN_UNUSED_RESULT
function basic_json (line 4551) | static basic_json from_ubjson(const T* ptr, std::size_t len,
function basic_json (line 4560) | static basic_json from_ubjson(detail::span_input_adapter&& i,
function JSON_HEDLEY_WARN_UNUSED_RESULT (line 4575) | JSON_HEDLEY_WARN_UNUSED_RESULT
function JSON_HEDLEY_WARN_UNUSED_RESULT (line 4590) | JSON_HEDLEY_WARN_UNUSED_RESULT
function JSON_HEDLEY_WARN_UNUSED_RESULT (line 4605) | JSON_HEDLEY_WARN_UNUSED_RESULT
function JSON_HEDLEY_WARN_UNUSED_RESULT (line 4620) | JSON_HEDLEY_WARN_UNUSED_RESULT
function basic_json (line 4635) | static basic_json from_bson(const T* ptr, std::size_t len,
function basic_json (line 4644) | static basic_json from_bson(detail::span_input_adapter&& i,
function reference (line 4666) | reference operator[](const json_pointer& ptr)
function reference (line 4673) | reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr)
function const_reference (line 4680) | const_reference operator[](const json_pointer& ptr) const
function const_reference (line 4687) | const_reference operator[](const ::nlohmann::json_pointer<BasicJsonType>...
function reference (line 4694) | reference at(const json_pointer& ptr)
function reference (line 4701) | reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr)
function const_reference (line 4708) | const_reference at(const json_pointer& ptr) const
function const_reference (line 4715) | const_reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr) c...
function basic_json (line 4722) | basic_json flatten() const
function basic_json (line 4731) | basic_json unflatten() const
function patch_inplace (line 4747) | void patch_inplace(const basic_json& json_patch)
function basic_json (line 5018) | basic_json patch(const basic_json& json_patch) const
function JSON_HEDLEY_WARN_UNUSED_RESULT (line 5027) | JSON_HEDLEY_WARN_UNUSED_RESULT
function merge_patch (line 5170) | void merge_patch(const basic_json& apply_patch)
function NLOHMANN_BASIC_JSON_TPL_DECLARATION (line 5201) | NLOHMANN_BASIC_JSON_TPL_DECLARATION
function NLOHMANN_JSON_NAMESPACE_END (line 5238) | NLOHMANN_JSON_NAMESPACE_END
FILE: Game Trainers/common/include/nlohmann/json_fwd.hpp
class json_pointer (line 56) | class json_pointer
type ordered_map (line 67) | struct ordered_map
FILE: Game Trainers/common/include/nlohmann/ordered_map.hpp
function ordered_map (line 46) | ordered_map() noexcept(noexcept(Container())) : Container{} {}
function ordered_map (line 47) | explicit ordered_map(const Allocator& alloc) noexcept(noexcept(Container...
function ordered_map (line 49) | ordered_map(It first, It last, const Allocator& alloc = Allocator())
function ordered_map (line 51) | ordered_map(std::initializer_list<value_type> init, const Allocator& all...
function emplace (line 54) | std::pair<iterator, bool> emplace(const key_type& key, T&& t)
function emplace (line 69) | std::pair<iterator, bool> emplace(KeyType && key, T && t)
function T (line 82) | T& operator[](const key_type& key)
function T (line 89) | T & operator[](KeyType && key)
function T (line 94) | const T& operator[](const key_type& key) const
function T (line 101) | const T & operator[](KeyType && key) const
function T (line 106) | T& at(const key_type& key)
function T (line 121) | T & at(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
function T (line 134) | const T& at(const key_type& key) const
function T (line 149) | const T & at(KeyType && key) const // NOLINT(cppcoreguidelines-missing-s...
function size_type (line 162) | size_type erase(const key_type& key)
function size_type (line 183) | size_type erase(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-...
function iterator (line 202) | iterator erase(iterator pos)
function iterator (line 207) | iterator erase(iterator first, iterator last)
function size_type (line 260) | size_type count(const key_type& key) const
function size_type (line 274) | size_type count(KeyType && key) const // NOLINT(cppcoreguidelines-missin...
function iterator (line 286) | iterator find(const key_type& key)
function iterator (line 300) | iterator find(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-fo...
function const_iterator (line 312) | const_iterator find(const key_type& key) const
function insert (line 324) | std::pair<iterator, bool> insert( value_type&& value )
function insert (line 329) | std::pair<iterator, bool> insert( const value_type& value )
function insert (line 347) | void insert(InputIt first, InputIt last)
FILE: Game Trainers/documents/trainer_template.h
function class (line 19) | class Trainer : public TrainerBase // Or MonoBase if it's a Unity game
FILE: Game Trainers/scripts/font_processor.py
function extract_text_from_file (line 10) | def extract_text_from_file(file_path):
function extract_text_from_json (line 28) | def extract_text_from_json(data):
function extract_strings_from_py (line 40) | def extract_strings_from_py(file_path):
function extract_strings_from_rs (line 49) | def extract_strings_from_rs(file_path):
function get_unique_characters (line 61) | def get_unique_characters(files):
function subset_font (line 70) | def subset_font(font_path, characters, output_path):
function main (line 83) | def main():
FILE: Game Trainers/trainers/Arrow a Row Trainer/main.cpp
function apply_callback (line 11) | void apply_callback(Fl_Widget *widget, void *data)
function toggle_callback (line 45) | void toggle_callback(Fl_Widget *widget, void *data)
function main_window_close_callback (line 211) | static void main_window_close_callback(Fl_Widget *w, void *)
function main (line 220) | int main(int argc, char **argv)
FILE: Game Trainers/trainers/Arrow a Row Trainer/trainer.h
function class (line 6) | class Trainer : public TrainerBase
function setArrowSpeed (line 226) | inline bool setArrowSpeed(float newVal)
function setArrowDistance (line 287) | inline bool setArrowDistance(float newVal)
function setArrowCount (line 348) | inline bool setArrowCount(int newVal)
function setSwordDamage (line 410) | inline bool setSwordDamage(float newVal)
function setSwordCoolDown (line 472) | inline bool setSwordCoolDown(float newVal)
function setSwordSpeed (line 533) | inline bool setSwordSpeed(float newVal)
function setSwordDistance (line 593) | inline bool setSwordDistance(float newVal)
FILE: Game Trainers/trainers/DREDGE Trainer/GCMInjection.cs
class MainThreadDispatcher (line 11) | public class MainThreadDispatcher : MonoBehaviour
method Awake (line 16) | private void Awake()
method Update (line 27) | private void Update()
method Enqueue (line 38) | public static void Enqueue(Action action)
class GCMInjection (line 50) | public static class GCMInjection
method SendData (line 52) | [DllImport("MonoBridge.dll")]
method SendResponse (line 55) | [DllImport("MonoBridge.dll")]
method Log (line 58) | private static void Log(string message)
method Initialize (line 64) | public static void Initialize()
method SpawnItem (line 70) | public static void SpawnItem(int index)
method AddFunds (line 91) | public static void AddFunds(float amount)
method RepairAll (line 100) | public static void RepairAll()
method RestockAll (line 109) | public static void RestockAll()
method ClearWeather (line 121) | public static void ClearWeather()
method FreezeTime (line 130) | public static void FreezeTime(bool freeze)
method GetItemList (line 138) | public static void GetItemList()
FILE: Game Trainers/trainers/DREDGE Trainer/main.cpp
function apply_callback (line 15) | void apply_callback(Fl_Widget *widget, void *data)
function toggle_callback (line 70) | void toggle_callback(Fl_Widget *widget, void *data)
type InfoCallbackDataOld (line 149) | struct InfoCallbackDataOld
class ItemTableOld (line 155) | class ItemTableOld : public Fl_Table
method draw_cell (line 163) | void draw_cell(TableContext context, int row, int col, int x, int y, i...
method find_cell_at (line 204) | bool find_cell_at(int mouse_x, int mouse_y, int &row, int &col)
method handle (line 263) | int handle(int event) override
method ItemTableOld (line 309) | ItemTableOld(int x, int y, int w, int h, Fl_Input *inp, const char *l ...
method setItems (line 322) | void setItems(const std::vector<std::pair<int, std::string>> &item_list)
function info_callback_old (line 331) | void info_callback_old(Fl_Widget *widget, void *data)
function main_window_close_callback (line 394) | static void main_window_close_callback(Fl_Widget *w, void *)
function main (line 408) | int main(int argc, char **argv)
FILE: Game Trainers/trainers/DREDGE Trainer/trainer.h
function class (line 6) | class Trainer : public MonoBase
function spawnItem (line 175) | bool spawnItem(int itemIndex)
function addFunds (line 184) | bool addFunds(float amount)
function repairAll (line 193) | bool repairAll()
function restockAll (line 202) | bool restockAll()
function clearWeather (line 211) | bool clearWeather()
function freezeTime (line 220) | bool freezeTime(bool freeze)
FILE: Game Trainers/trainers/Feeding Frenzy 2_Shipwreck Showdown Trainer/main.cpp
function apply_callback (line 11) | void apply_callback(Fl_Widget *widget, void *data)
function toggle_callback (line 50) | void toggle_callback(Fl_Widget *widget, void *data)
function main_window_close_callback (line 96) | static void main_window_close_callback(Fl_Widget *w, void *)
function main (line 105) | int main(int argc, char **argv)
FILE: Game Trainers/trainers/Feeding Frenzy 2_Shipwreck Showdown Trainer/trainer.h
function setGrowth (line 21) | inline bool setGrowth(int newVal)
FILE: Game Trainers/trainers/Headbangers_Rhythm Royale Trainer/main.cpp
function apply_callback (line 11) | void apply_callback(Fl_Widget *widget, void *data)
function toggle_callback (line 43) | void toggle_callback(Fl_Widget *widget, void *data)
function main_window_close_callback (line 110) | static void main_window_close_callback(Fl_Widget *w, void *)
function main (line 119) | int main(int argc, char **argv)
FILE: Game Trainers/trainers/Headbangers_Rhythm Royale Trainer/trainer.h
function class (line 6) | class Trainer : public TrainerBase
FILE: Game Trainers/trainers/Heavy Weapon Trainer/main.cpp
function apply_callback (line 11) | void apply_callback(Fl_Widget *widget, void *data)
function toggle_callback (line 48) | void toggle_callback(Fl_Widget *widget, void *data)
function main_window_close_callback (line 181) | static void main_window_close_callback(Fl_Widget *w, void *)
function main (line 190) | int main(int argc, char **argv)
FILE: Game Trainers/trainers/Heavy Weapon Trainer/trainer.h
function setThunderStrike (line 62) | inline bool setThunderStrike(int newVal)
FILE: Game Trainers/trainers/Inotia 4 Trainer/main.cpp
function apply_callback (line 20) | void apply_callback(Fl_Widget *widget, void *data)
function toggle_callback (line 67) | void toggle_callback(Fl_Widget *widget, void *data)
function main_window_close_callback (line 161) | static void main_window_close_callback(Fl_Widget *w, void *)
function main (line 170) | int main(int argc, char **argv)
FILE: Game Trainers/trainers/Inotia 4 Trainer/trainer.h
function setExp (line 27) | inline bool setExp(int newVal)
function setStatPoints (line 97) | inline bool setStatPoints(int newVal)
function setSkillPoints (line 144) | inline bool setSkillPoints(int newVal)
function unlockAllMercenarySlots (line 209) | inline bool unlockAllMercenarySlots()
FILE: Game Trainers/trainers/Just Shapes & Beats Trainer/IL2CPP.cpp
type BeatPointsCommand (line 47) | struct BeatPointsCommand
function HandleAddBeatPoints (line 65) | void HandleAddBeatPoints()
function HandleFinishLevel (line 118) | void HandleFinishLevel()
function IsPlayerActor (line 153) | bool IsPlayerActor(void *actorPtr)
function Detour_LifeComponent_Damage (line 174) | void Detour_LifeComponent_Damage(void *instance, float amount)
function Detour_HeroCollision_OnCollision (line 193) | void Detour_HeroCollision_OnCollision(void *instance)
function HookGodMode (line 207) | bool HookGodMode(NAMESPACE *ns, MEMORY &memory)
function Detour_Update (line 242) | void Detour_Update(void *instance)
function InitializeIL2CPP (line 267) | bool InitializeIL2CPP()
function DWORD (line 332) | __declspec(dllexport) DWORD WINAPI GodMode(LPVOID lpParam)
function DWORD (line 343) | __declspec(dllexport) DWORD WINAPI AddBeatPoints(LPVOID lpParam)
function DWORD (line 355) | __declspec(dllexport) DWORD WINAPI FinishLevel(LPVOID lpParam)
function DWORD (line 369) | DWORD WINAPI MainThread(HMODULE hModule)
function BOOL (line 378) | BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID ...
FILE: Game Trainers/trainers/Just Shapes & Beats Trainer/main.cpp
function apply_callback (line 12) | void apply_callback(Fl_Widget *widget, void *data)
function toggle_callback (line 48) | void toggle_callback(Fl_Widget *widget, void *data)
function main_window_close_callback (line 87) | static void main_window_close_callback(Fl_Widget *w, void *)
function main (line 96) | int main(int argc, char **argv)
FILE: Game Trainers/trainers/Just Shapes & Beats Trainer/trainer.h
function class (line 6) | class Trainer : public Il2CppBase
FILE: Game Trainers/trainers/Oil Rush Trainer/main.cpp
function apply_callback (line 12) | void apply_callback(Fl_Widget *widget, void *data)
function toggle_callback (line 39) | void toggle_callback(Fl_Widget *widget, void *data)
function main_window_close_callback (line 78) | static void main_window_close_callback(Fl_Widget *w, void *)
function main (line 87) | int main(int argc, char **argv)
FILE: Game Trainers/trainers/Oil Rush Trainer/trainer.h
function toggleOil (line 23) | inline bool toggleOil(bool active, int value)
function toggleAbility (line 29) | inline bool toggleAbility(bool active, int value)
function emit_je (line 83) | auto emit_je = [&](std::vector<size_t> &jump_list)
function emit_jne (line 90) | auto emit_jne = [&](std::vector<size_t> &jump_list)
FILE: Game Trainers/trainers/Outland Trainer/main.cpp
function apply_callback (line 12) | void apply_callback(Fl_Widget *widget, void *data)
function toggle_callback (line 39) | void toggle_callback(Fl_Widget *widget, void *data)
function main_window_close_callback (line 92) | static void main_window_close_callback(Fl_Widget *w, void *)
function main (line 101) | int main(int argc, char **argv)
FILE: Game Trainers/trainers/Outland Trainer/trainer.h
function setCoins (line 27) | inline bool setCoins(int newVal)
FILE: Game Trainers/trainers/Plants vs. Zombies_GOTY Edition Trainer/main.cpp
function apply_callback (line 11) | void apply_callback(Fl_Widget *widget, void *data)
function toggle_callback (line 43) | void toggle_callback(Fl_Widget *widget, void *data)
function main_window_close_callback (line 143) | static void main_window_close_callback(Fl_Widget *w, void *)
function main (line 152) | int main(int argc, char **argv)
FILE: Game Trainers/trainers/Plants vs. Zombies_GOTY Edition Trainer/trainer.h
function setBugSpray (line 21) | inline bool setBugSpray(int newVal)
FILE: Game Trainers/trainers/Plants vs. Zombies_Replanted Trainer/IL2CPP.cpp
type ZenGardenPlantCommand (line 45) | struct ZenGardenPlantCommand
type PlantArgs (line 52) | struct PlantArgs
type SpawnZombieArgs (line 58) | struct SpawnZombieArgs
type ZombieCommand (line 65) | struct ZombieCommand
function HandlePlantSpawn (line 81) | void HandlePlantSpawn(void *boardInstance)
function HandleInstantWin (line 149) | void HandleInstantWin(void *boardInstance)
function HandleZombieSpawn (line 165) | void HandleZombieSpawn(void *boardInstance)
function HandleFullScreenJalapeno (line 205) | void HandleFullScreenJalapeno(void *boardInstance)
function Detour_UpdateGame (line 232) | void Detour_UpdateGame(void *instance)
function InitializeIL2CPP (line 265) | bool InitializeIL2CPP()
function SendResponse (line 319) | __declspec(dllexport) void SendResponse(const char *message)
function GetPlantList (line 379) | __declspec(dllexport) void GetPlantList()
function GetZombieList (line 421) | __declspec(dllexport) void GetZombieList()
function DWORD (line 463) | __declspec(dllexport) DWORD WINAPI InstantCompleteLevel(LPVOID lpParam)
function DWORD (line 473) | __declspec(dllexport) DWORD WINAPI SpawnZombie(LPVOID lpParam)
function DWORD (line 488) | __declspec(dllexport) DWORD WINAPI FullScreenJalapeno(LPVOID lpParam)
function DWORD (line 498) | __declspec(dllexport) DWORD WINAPI AddPlantToGarden(LPVOID lpParam)
function DWORD (line 512) | DWORD WINAPI MainThread(HMODULE hModule)
function BOOL (line 521) | BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID ...
FILE: Game Trainers/trainers/Plants vs. Zombies_Replanted Trainer/main.cpp
function apply_callback (line 18) | void apply_callback(Fl_Widget *widget, void *data)
function toggle_callback (line 81) | void toggle_callback(Fl_Widget *widget, void *data)
function main_window_close_callback (line 162) | static void main_window_close_callback(Fl_Widget *w, void *)
function main (line 181) | int main(int argc, char **argv)
FILE: Game Trainers/trainers/Plants vs. Zombies_Replanted Trainer/trainer.h
function class (line 6) | class Trainer : public Il2CppBase
function setFertilizerAndBugSpray (line 108) | inline bool setFertilizerAndBugSpray(int newVal)
function setChocolate (line 231) | inline bool setChocolate(int newVal)
function setTreeFood (line 316) | inline bool setTreeFood(int newVal)
function setCoin (line 400) | inline bool setCoin(int newVal)
function instantCompleteLevel (line 466) | bool instantCompleteLevel()
function fullScreenJalapeno (line 500) | bool fullScreenJalapeno()
FILE: Game Trainers/trainers/PvZ2 Gardendless Trainer/main.cpp
type LaunchData (line 17) | struct LaunchData
function apply_callback (line 28) | void apply_callback(Fl_Widget *widget, void *data)
function toggle_callback (line 66) | void toggle_callback(Fl_Widget *widget, void *data) {}
function browse_callback (line 71) | static void browse_callback(Fl_Widget *widget, void *data)
function launch_callback (line 108) | static void launch_callback(Fl_Widget *widget, void *data)
function check_process_status_wrapper (line 129) | static void check_process_status_wrapper(void *data)
function main_window_close_callback (line 141) | static void main_window_close_callback(Fl_Widget *w, void *)
function main (line 151) | int main(int argc, char **argv)
FILE: Game Trainers/trainers/PvZ2 Gardendless Trainer/trainer.h
function class (line 8) | class Trainer : public CDPBase
FILE: Game Trainers/trainers/Wizard of Legend 2 Trainer/main.cpp
function apply_callback (line 11) | void apply_callback(Fl_Widget *widget, void *data)
function toggle_callback (line 46) | void toggle_callback(Fl_Widget *widget, void *data)
function main_window_close_callback (line 147) | static void main_window_close_callback(Fl_Widget *w, void *)
function main (line 156) | int main(int argc, char **argv)
FILE: Game Trainers/trainers/Wizard of Legend 2 Trainer/trainer.h
function setArcaneChromo (line 45) | inline bool setArcaneChromo(int newVal)
FILE: src/scripts/config.py
function resource_path (line 18) | def resource_path(relative_path):
function apply_settings (line 43) | def apply_settings(settings):
function load_settings (line 48) | def load_settings():
function get_translator (line 121) | def get_translator():
function is_chinese (line 137) | def is_chinese(text):
function sort_trainers_key (line 144) | def sort_trainers_key(name):
function sort_trainers_key_ignore_prefix (line 150) | def sort_trainers_key_ignore_prefix(name):
function ensure_trainer_download_path_is_valid (line 159) | def ensure_trainer_download_path_is_valid():
function findWeModInstallPath (line 168) | def findWeModInstallPath():
function findCEInstallPath (line 175) | def findCEInstallPath():
FILE: src/scripts/main.py
class GameCheatsManager (line 31) | class GameCheatsManager(QMainWindow):
method __init__ (line 33) | def __init__(self):
method closeEvent (line 283) | def closeEvent(self, event):
method show_announcement (line 288) | def show_announcement(self, data):
method start_update (line 293) | def start_update(self, version):
method send_notification (line 306) | def send_notification(self, success, latest_version=0):
method init_settings (line 338) | def init_settings(self):
method on_enter_press (line 354) | def on_enter_press(self):
method on_download_start (line 359) | def on_download_start(self, item):
method disable_download_widgets (line 364) | def disable_download_widgets(self):
method enable_download_widgets (line 368) | def enable_download_widgets(self):
method disable_all_widgets (line 372) | def disable_all_widgets(self):
method enable_all_widgets (line 379) | def enable_all_widgets(self):
method update_list (line 386) | def update_list(self):
method show_cheats (line 397) | def show_cheats(self):
method cleanup_launch_junctions (line 449) | def cleanup_launch_junctions(self):
method get_ascii_launch_path (line 462) | def get_ascii_launch_path(self, original_exe_path):
method is_cheat_engine_available (line 514) | def is_cheat_engine_available(self, ext):
method prompt_cheat_engine_install (line 543) | def prompt_cheat_engine_install(self):
method launch_trainer (line 566) | def launch_trainer(self):
method delete_trainer (line 599) | def delete_trainer(self):
method findWidgetInStatusBar (line 638) | def findWidgetInStatusBar(self, statusbar, widgetName):
method change_path (line 644) | def change_path(self):
method download_display (line 673) | def download_display(self, keyword):
method fetch_trainer_translations (line 684) | def fetch_trainer_translations(self):
method fetch_gcm_data (line 693) | def fetch_gcm_data(self):
method fetch_fling_data (line 702) | def fetch_fling_data(self):
method fetch_xiaoxing_data (line 711) | def fetch_xiaoxing_data(self):
method fetch_ct_data (line 720) | def fetch_ct_data(self):
method update_trainers (line 729) | def update_trainers(self, auto_check=False):
method fetch_trainer_search_data (line 739) | def fetch_trainer_search_data(self):
method on_main_interval (line 748) | def on_main_interval(self):
method download_trainers (line 762) | def download_trainers(self, index):
method on_trainer_update (line 765) | def on_trainer_update(self, update_entry):
method enqueue_download (line 768) | def enqueue_download(self, index, trainers, trainerDownloadPath, updat...
method start_next_download (line 773) | def start_next_download(self):
method on_message (line 791) | def on_message(self, message, type=None):
method format_size (line 846) | def format_size(num_bytes):
method on_download_progress (line 853) | def on_download_progress(self, downloaded, total):
method on_message_box (line 867) | def on_message_box(self, type, title, text):
method on_migration_error (line 873) | def on_migration_error(self, error_message):
method on_migration_finished (line 879) | def on_migration_finished(self, new_path):
method on_display_finished (line 888) | def on_display_finished(self, status):
method on_download_finished (line 898) | def on_download_finished(self, status):
method on_status_load (line 906) | def on_status_load(self, widgetName, message):
method on_status_update (line 910) | def on_status_update(self, widgetName, newMessage, state):
method on_interval_finished (line 914) | def on_interval_finished(self, widgetName):
method open_settings (line 935) | def open_settings(self):
method import_files (line 943) | def import_files(self):
method open_trainer_directory (line 978) | def open_trainer_directory(self):
method add_whitelist (line 981) | def add_whitelist(self):
method open_about (line 1007) | def open_about(self):
method open_trainer_management (line 1015) | def open_trainer_management(self):
method open_trainer_upload (line 1023) | def open_trainer_upload(self):
method browse_all_trainers (line 1031) | def browse_all_trainers(self):
FILE: src/scripts/threads/download_base_thread.py
class DownloadBaseThread (line 21) | class DownloadBaseThread(QThread):
method __init__ (line 33) | def __init__(self, parent=None):
method get_webpage_content (line 38) | def get_webpage_content(self, url, verify=True, use_cloudScraper=False):
method request_download (line 58) | def request_download(self, url, download_path, verify=True, use_cloudS...
method find_download_fname (line 91) | def find_download_fname(response):
method get_signed_download_url (line 108) | def get_signed_download_url(file_path_on_s3):
method get_signed_upload_url (line 137) | def get_signed_upload_url(file_path_on_s3, metadata_json):
method is_internet_connected (line 164) | def is_internet_connected(urls=None, timeout=5):
method arabic_to_roman (line 184) | def arabic_to_roman(num):
method sanitize (line 203) | def sanitize(self, text):
method symbol_replacement (line 209) | def symbol_replacement(text):
method find_best_trainer_match (line 212) | def find_best_trainer_match(self, target_name, target_language, thresh...
method translate_trainer (line 246) | def translate_trainer(self, trainer):
method save_html_content (line 314) | def save_html_content(content, file_name, overwrite=True):
method load_html_content (line 321) | def load_html_content(file_name):
method load_json_content (line 333) | def load_json_content(file_name, from_database=True):
FILE: src/scripts/threads/download_display_thread.py
class DownloadDisplayThread (line 13) | class DownloadDisplayThread(DownloadBaseThread):
method __init__ (line 14) | def __init__(self, keyword, parent=None):
method run (line 19) | def run(self):
method translate_keyword (line 111) | def translate_keyword(self, keyword):
method keyword_match (line 133) | def keyword_match(self, keywordList, targetString):
method search_from_fling_archive (line 143) | def search_from_fling_archive(self, keywordList):
method search_from_fling_main (line 216) | def search_from_fling_main(self, keywordList):
method search_from_xiaoxing (line 282) | def search_from_xiaoxing(self, keywordList):
method search_from_ct (line 319) | def search_from_ct(self, keywordList):
method search_from_gcm (line 360) | def search_from_gcm(self, keywordList):
FILE: src/scripts/threads/download_trainers_thread.py
class DownloadTrainersThread (line 14) | class DownloadTrainersThread(DownloadBaseThread):
method __init__ (line 15) | def __init__(self, index, trainers, trainerDownloadPath, update_entry,...
method run (line 24) | def run(self):
method modify_fling_settings (line 103) | def modify_fling_settings(self, removeBgMusic):
method remove_bgMusic (line 143) | def remove_bgMusic(self, source_exe, resource_type_list):
method download_fling (line 178) | def download_fling(self, selected_trainer):
method download_xiaoxing (line 322) | def download_xiaoxing(self, selected_trainer):
method handle_xiaoxing_special_cases (line 375) | def handle_xiaoxing_special_cases(self, selected_trainer, extractedCon...
method handle_multi_version_archive (line 412) | def handle_multi_version_archive(self, extractedContentPath, trainerNa...
method process_pattern_to_hex_and_mask (line 439) | def process_pattern_to_hex_and_mask(self, pattern_str):
method unlock_xiaoxing (line 452) | def unlock_xiaoxing(self, selected_trainer):
method download_default (line 525) | def download_default(self, selected_trainer):
FILE: src/scripts/threads/other_threads.py
class AnnouncementFetchWorker (line 16) | class AnnouncementFetchWorker(QThread):
method run (line 20) | def run(self):
class VersionFetchWorker (line 48) | class VersionFetchWorker(QThread):
method __init__ (line 52) | def __init__(self, app_name, parent=None):
method run (line 56) | def run(self):
class PathChangeThread (line 86) | class PathChangeThread(QThread):
method __init__ (line 90) | def __init__(self, source_path, destination_path, parent=None):
method run (line 95) | def run(self):
class FetchGCMSite (line 114) | class FetchGCMSite(DownloadBaseThread):
method __init__ (line 119) | def __init__(self, parent=None):
method run (line 122) | def run(self):
class FetchFlingSite (line 138) | class FetchFlingSite(DownloadBaseThread):
method __init__ (line 143) | def __init__(self, parent=None):
method run (line 146) | def run(self):
class FetchXiaoXingSite (line 194) | class FetchXiaoXingSite(DownloadBaseThread):
method __init__ (line 199) | def __init__(self, parent=None):
method run (line 202) | def run(self):
class FetchCTSite (line 218) | class FetchCTSite(DownloadBaseThread):
method __init__ (line 223) | def __init__(self, parent=None):
method run (line 226) | def run(self):
class FetchTrainerTranslations (line 242) | class FetchTrainerTranslations(DownloadBaseThread):
method __init__ (line 247) | def __init__(self, parent=None):
method run (line 250) | def run(self):
class TrainerUploadWorker (line 266) | class TrainerUploadWorker(QThread):
method __init__ (line 270) | def __init__(self, file_path, trainer_name, contact_info, trainer_sour...
method stop (line 279) | def stop(self):
method run (line 282) | def run(self):
class WeModCustomization (line 344) | class WeModCustomization(QThread):
method __init__ (line 351) | def __init__(self, weModVersions, weModInstallPath, selectedWeModVersi...
method run (line 359) | def run(self):
method is_program_running (line 471) | def is_program_running(self, program_name):
method apply_patch (line 480) | def apply_patch(self, file_path, pattern, replacement):
method replace_hex_in_file (line 491) | def replace_hex_in_file(self, input_file, output_file, search_hex, rep...
method patch (line 498) | def patch(self, enable_dev=False):
FILE: src/scripts/threads/update_trainers_thread.py
class UpdateTrainers (line 12) | class UpdateTrainers(DownloadBaseThread):
method __init__ (line 18) | def __init__(self, trainers, auto_check, parent=None):
method check_trainer_update (line 23) | def check_trainer_update(self, trainer_path):
method run (line 81) | def run(self):
FILE: src/scripts/widgets/custom_dialogs.py
class AnnouncementDialog (line 14) | class AnnouncementDialog(QDialog):
method __init__ (line 15) | def __init__(self, announcement_data, parent=None):
method _mark_seen (line 67) | def _mark_seen(self):
method accept (line 71) | def accept(self):
method closeEvent (line 75) | def closeEvent(self, event):
class CopyRightWarning (line 80) | class CopyRightWarning(QDialog):
method __init__ (line 81) | def __init__(self, parent=None):
method closeEvent (line 144) | def closeEvent(self, event):
class SettingsDialog (line 151) | class SettingsDialog(QDialog):
method __init__ (line 152) | def __init__(self, parent=None):
method find_settings_key (line 230) | def find_settings_key(value, dict):
method add_or_remove_startup (line 234) | def add_or_remove_startup(app_name, path_to_exe, add=True):
method apply_settings_page (line 247) | def apply_settings_page(self):
class AboutDialog (line 295) | class AboutDialog(QDialog):
method __init__ (line 296) | def __init__(self, parent=None):
method start_version_fetch (line 405) | def start_version_fetch(self):
method update_version_labels (line 411) | def update_version_labels(self, latest_version):
method handle_version_load_failure (line 422) | def handle_version_load_failure(self):
class TrainerUploadDialog (line 428) | class TrainerUploadDialog(QDialog):
method __init__ (line 429) | def __init__(self, parent=None):
method browse_file (line 552) | def browse_file(self):
method start_upload (line 565) | def start_upload(self):
method update_progress (line 593) | def update_progress(self, percent):
method handle_upload_finished (line 596) | def handle_upload_finished(self, success, message):
method closeEvent (line 606) | def closeEvent(self, event):
method set_ui_locked (line 612) | def set_ui_locked(self, locked):
FILE: src/scripts/widgets/custom_widgets.py
class LargerActionIconStyle (line 9) | class LargerActionIconStyle(QProxyStyle):
method pixelMetric (line 10) | def pixelMetric(self, metric, option=None, widget=None):
class ToastNotification (line 16) | class ToastNotification(QWidget):
method __init__ (line 19) | def __init__(self, title, message, notification_type="info"):
method apply_theme (line 145) | def apply_theme(self, theme):
method show_notification (line 199) | def show_notification(self):
method on_accept (line 223) | def on_accept(self):
class CustomButton (line 228) | class CustomButton(QPushButton):
method __init__ (line 229) | def __init__(self, text, parent=None):
method setEnabled (line 234) | def setEnabled(self, enabled):
method setDisabled (line 245) | def setDisabled(self, disabled):
method enterEvent (line 256) | def enterEvent(self, event):
method leaveEvent (line 262) | def leaveEvent(self, event):
method hideEvent (line 267) | def hideEvent(self, event):
class StatusMessageWidget (line 274) | class StatusMessageWidget(QWidget):
method __init__ (line 275) | def __init__(self, widgetName, message):
method update_loading_animation (line 294) | def update_loading_animation(self):
method update_message (line 299) | def update_message(self, newMessage, state="load"):
class MultilingualListWidget (line 313) | class MultilingualListWidget(QListWidget):
method __init__ (line 314) | def __init__(self):
method addItem (line 320) | def addItem(self, item):
method is_chinese_simplified (line 335) | def is_chinese_simplified(text):
method is_chinese_traditional (line 339) | def is_chinese_traditional(text):
class AlertWidget (line 343) | class AlertWidget(QWidget):
method __init__ (line 344) | def __init__(self, parent, message, alert_type):
method init_ui (line 358) | def init_ui(self):
method enforce_alert_limit (line 382) | def enforce_alert_limit(self):
method move_to_top_right (line 389) | def move_to_top_right(self):
method close (line 398) | def close(self):
method paintEvent (line 411) | def paintEvent(self, event):
FILE: src/scripts/widgets/trainer_management.py
class TrainerManagementDialog (line 14) | class TrainerManagementDialog(QDialog):
method __init__ (line 15) | def __init__(self, parent=None):
method closeEvent (line 40) | def closeEvent(self, event):
method find_settings_key (line 72) | def find_settings_key(value, dict):
method show_alert (line 78) | def show_alert(self, message, alert_type):
method moveEvent (line 86) | def moveEvent(self, event):
method createGCMTab (line 91) | def createGCMTab(self):
method createFlingTab (line 136) | def createFlingTab(self):
method createXiaoXingTab (line 195) | def createXiaoXingTab(self):
method createCETab (line 248) | def createCETab(self):
method createWemodTab (line 354) | def createWemodTab(self):
method createCevoTab (line 458) | def createCevoTab(self):
method selectWeModPath (line 536) | def selectWeModPath(self):
method resetWemodPath (line 545) | def resetWemodPath(self):
method selectCEPath (line 551) | def selectCEPath(self):
method resetCEPath (line 560) | def resetCEPath(self):
method checkCEInstallStatus (line 566) | def checkCEInstallStatus(self):
method findWeModVersions (line 577) | def findWeModVersions(self, weModPath):
method on_finished (line 603) | def on_finished(self):
method applyWeModCustomization (line 608) | def applyWeModCustomization(self):
method applyCheatEngineCustomization (line 620) | def applyCheatEngineCustomization(self):
method selectCevoPath (line 653) | def selectCevoPath(self):
method checkCevoInstallStatus (line 662) | def checkCevoInstallStatus(self):
method applyCevoCustomization (line 678) | def applyCevoCustomization(self):
Condensed preview — 358 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (3,892K chars).
[
{
"path": ".github/workflows/Release to server.yml",
"chars": 2608,
"preview": "name: Release to Server\n\non:\n release:\n types: [published]\n\njobs:\n deploy-installer:\n runs-on: ubuntu-latest\n "
},
{
"path": ".gitignore",
"chars": 127,
"preview": "__pycache__\nsecret_config.py\n.venv\n.vscode\n.DS_Store\n*.mo\ndist/\ncompile.ps1\nutility.py\nResourceHacker.ini\nelevate.manife"
},
{
"path": "Game Trainers/.gitignore",
"chars": 237,
"preview": "build/\n.vscode/\nbin/\nobj/\n.venv/\n*.sln\n*.ps1\nMonoBridge.dll\nGCMInjection.dll\nIL2CPP.dll\ntrainers/**/*.ttf\nprocess_user_t"
},
{
"path": "Game Trainers/CMakeLists.txt",
"chars": 1846,
"preview": "cmake_minimum_required(VERSION 3.15)\n\nproject(GameTrainers LANGUAGES CXX)\n\nset(CMAKE_CXX_STANDARD 20)\nset(CMAKE_CXX_STAN"
},
{
"path": "Game Trainers/common/CMakeLists.txt",
"chars": 1947,
"preview": "add_library(Common INTERFACE)\n\n# Set include directories for Common\ntarget_include_directories(Common INTERFACE\n $<BU"
},
{
"path": "Game Trainers/common/assets/elevate.xml",
"chars": 412,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersi"
},
{
"path": "Game Trainers/common/include/CDPBase.h",
"chars": 18040,
"preview": "// CDPBase.h\n// Base class for trainers targeting web-based desktop games (Tauri/WebView2, Electron, CEF, NW.js).\n// Com"
},
{
"path": "Game Trainers/common/include/FL/Enumerations.H",
"chars": 60834,
"preview": "//\n// Enumerations for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2025 by Bill Spitzak and others.\n//\n// This "
},
{
"path": "Game Trainers/common/include/FL/Fl.H",
"chars": 65205,
"preview": "//\n// Main header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2024 by Bill Spitzak and others.\n//\n// T"
},
{
"path": "Game Trainers/common/include/FL/Fl_Adjuster.H",
"chars": 2065,
"preview": "//\n// Adjuster widget header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and othe"
},
{
"path": "Game Trainers/common/include/FL/Fl_Anim_GIF_Image.H",
"chars": 5498,
"preview": "//\n// Fl_Anim_GIF_Image class header for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 2016-2023 by Christian Grabner "
},
{
"path": "Game Trainers/common/include/FL/Fl_BMP_Image.H",
"chars": 1005,
"preview": "//\n// BMP image header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2022 by Bill Spitzak and others.\n//"
},
{
"path": "Game Trainers/common/include/FL/Fl_Bitmap.H",
"chars": 2358,
"preview": "//\n// Bitmap header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2017 by Bill Spitzak and others.\n//\n//"
},
{
"path": "Game Trainers/common/include/FL/Fl_Box.H",
"chars": 2358,
"preview": "//\n// Box header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2025 by Bill Spitzak and others.\n//\n// Th"
},
{
"path": "Game Trainers/common/include/FL/Fl_Browser.H",
"chars": 12736,
"preview": "//\n// Browser header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2023 by Bill Spitzak and others.\n//\n/"
},
{
"path": "Game Trainers/common/include/FL/Fl_Browser_.H",
"chars": 16147,
"preview": "//\n// Common browser header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2016 by Bill Spitzak and other"
},
{
"path": "Game Trainers/common/include/FL/Fl_Button.H",
"chars": 6091,
"preview": "//\n// Button header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2014 by Bill Spitzak and others.\n//\n//"
},
{
"path": "Game Trainers/common/include/FL/Fl_Cairo.H",
"chars": 3530,
"preview": "//\n// Main Cairo support header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2023 by Bill Spitzak and o"
},
{
"path": "Game Trainers/common/include/FL/Fl_Cairo_Window.H",
"chars": 4530,
"preview": "//\n// Fl_Cairo_Window header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2023 by Bill Spitzak and othe"
},
{
"path": "Game Trainers/common/include/FL/Fl_Chart.H",
"chars": 6219,
"preview": "//\n// Fl_Chart widget header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2023 by Bill Spitzak and othe"
},
{
"path": "Game Trainers/common/include/FL/Fl_Check_Browser.H",
"chars": 3556,
"preview": "//\n// Fl_Check_Browser header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2020 by Bill Spitzak and oth"
},
{
"path": "Game Trainers/common/include/FL/Fl_Check_Button.H",
"chars": 799,
"preview": "//\n// Check button header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2014 by Bill Spitzak and others."
},
{
"path": "Game Trainers/common/include/FL/Fl_Choice.H",
"chars": 4094,
"preview": "//\n// Choice header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2024 by Bill Spitzak and others.\n//\n//"
},
{
"path": "Game Trainers/common/include/FL/Fl_Clock.H",
"chars": 4911,
"preview": "//\n// Clock header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2017 by Bill Spitzak and others.\n//\n// "
},
{
"path": "Game Trainers/common/include/FL/Fl_Color_Chooser.H",
"chars": 5877,
"preview": "//\n// Color chooser header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2019 by Bill Spitzak and others"
},
{
"path": "Game Trainers/common/include/FL/Fl_Copy_Surface.H",
"chars": 4071,
"preview": "//\n// Copy-to-clipboard code for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2023 by Bill Spitzak and others.\n/"
},
{
"path": "Game Trainers/common/include/FL/Fl_Counter.H",
"chars": 2985,
"preview": "//\n// Counter header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2022 by Bill Spitzak and others.\n//\n/"
},
{
"path": "Game Trainers/common/include/FL/Fl_Device.H",
"chars": 5890,
"preview": "//\n// Definition of classes Fl_Surface_Device, Fl_Display_Device\n// for the Fast Light Tool Kit (FLTK).\n//\n// Copyright "
},
{
"path": "Game Trainers/common/include/FL/Fl_Dial.H",
"chars": 2372,
"preview": "//\n// Dial header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2022 by Bill Spitzak and others.\n//\n// T"
},
{
"path": "Game Trainers/common/include/FL/Fl_Double_Window.H",
"chars": 1506,
"preview": "//\n// Double-buffered window header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak a"
},
{
"path": "Game Trainers/common/include/FL/Fl_Export.H",
"chars": 942,
"preview": "/*\n * Windows DLL export .\n *\n * Copyright 1998-2018 by Bill Spitzak and others.\n *\n * This library is free software. Di"
},
{
"path": "Game Trainers/common/include/FL/Fl_File_Browser.H",
"chars": 2939,
"preview": "//\n// FileBrowser definitions.\n//\n// Copyright 1999-2010 by Michael Sweet.\n//\n// This library is free software. Distribu"
},
{
"path": "Game Trainers/common/include/FL/Fl_File_Chooser.H",
"chars": 8150,
"preview": "//\n// Fl_File_Chooser dialog for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2024 by Bill Spitzak and others.\n/"
},
{
"path": "Game Trainers/common/include/FL/Fl_File_Icon.H",
"chars": 4949,
"preview": "//\n// Fl_File_Icon definitions.\n//\n// Copyright 1999-2010 by Michael Sweet.\n//\n// This library is free software. Distrib"
},
{
"path": "Game Trainers/common/include/FL/Fl_File_Input.H",
"chars": 3164,
"preview": "//\n// File_Input header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2022 by Bill Spitzak and others.\n/"
},
{
"path": "Game Trainers/common/include/FL/Fl_Fill_Dial.H",
"chars": 834,
"preview": "//\n// Filled dial header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and others.\n"
},
{
"path": "Game Trainers/common/include/FL/Fl_Fill_Slider.H",
"chars": 895,
"preview": "//\n// Filled slider header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and others"
},
{
"path": "Game Trainers/common/include/FL/Fl_Flex.H",
"chars": 11525,
"preview": "//\n// Fl_Flex widget header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 2020 by Karsten Pedersen\n// Copyrig"
},
{
"path": "Game Trainers/common/include/FL/Fl_Float_Input.H",
"chars": 1154,
"preview": "//\n// Floating point input header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2011 by Bill Spitzak and"
},
{
"path": "Game Trainers/common/include/FL/Fl_FormsBitmap.H",
"chars": 1072,
"preview": "//\n// Forms bitmap header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and others."
},
{
"path": "Game Trainers/common/include/FL/Fl_FormsPixmap.H",
"chars": 1166,
"preview": "//\n// Forms pixmap header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and others."
},
{
"path": "Game Trainers/common/include/FL/Fl_Free.H",
"chars": 2624,
"preview": "//\n// Forms free header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and others.\n/"
},
{
"path": "Game Trainers/common/include/FL/Fl_GIF_Image.H",
"chars": 3095,
"preview": "//\n// GIF image header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2024 by Bill Spitzak and others.\n//"
},
{
"path": "Game Trainers/common/include/FL/Fl_Gl_Window.H",
"chars": 10043,
"preview": "//\n// OpenGL header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2023 by Bill Spitzak and others.\n//\n//"
},
{
"path": "Game Trainers/common/include/FL/Fl_Graphics_Driver.H",
"chars": 26779,
"preview": "//\n// Declaration of classes Fl_Graphics_Driver, Fl_Scalable_Graphics_Driver,\n// and Fl_Font_Descriptor for the Fast Lig"
},
{
"path": "Game Trainers/common/include/FL/Fl_Grid.H",
"chars": 13048,
"preview": "//\n// Fl_Grid widget header for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 2021-2022 by Albrecht Schlosser.\n// Copy"
},
{
"path": "Game Trainers/common/include/FL/Fl_Group.H",
"chars": 8877,
"preview": "//\n// Group header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2022 by Bill Spitzak and others.\n//\n// "
},
{
"path": "Game Trainers/common/include/FL/Fl_Help_Dialog.H",
"chars": 2629,
"preview": "//\n// Fl_Help_Dialog dialog for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2021 by Bill Spitzak and others.\n//"
},
{
"path": "Game Trainers/common/include/FL/Fl_Help_View.H",
"chars": 14906,
"preview": "//\n// Help Viewer widget definitions.\n//\n// Copyright 1997-2010 by Easy Software Products.\n// Image support by Matthias "
},
{
"path": "Game Trainers/common/include/FL/Fl_Hold_Browser.H",
"chars": 1649,
"preview": "//\n// Hold browser header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and others."
},
{
"path": "Game Trainers/common/include/FL/Fl_Hor_Fill_Slider.H",
"chars": 764,
"preview": "//\n// Horizontal fill slider header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak a"
},
{
"path": "Game Trainers/common/include/FL/Fl_Hor_Nice_Slider.H",
"chars": 1027,
"preview": "//\n// Horizontal \"nice\" slider header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak"
},
{
"path": "Game Trainers/common/include/FL/Fl_Hor_Slider.H",
"chars": 896,
"preview": "//\n// Horizontal slider header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2011 by Bill Spitzak and ot"
},
{
"path": "Game Trainers/common/include/FL/Fl_Hor_Value_Slider.H",
"chars": 782,
"preview": "//\n// Horizontal value slider header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak "
},
{
"path": "Game Trainers/common/include/FL/Fl_ICO_Image.H",
"chars": 1816,
"preview": "//\n// ICO image header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 2022-2023 by Bill Spitzak and others.\n//"
},
{
"path": "Game Trainers/common/include/FL/Fl_Image.H",
"chars": 14583,
"preview": "//\n// Image header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2022 by Bill Spitzak and others.\n//\n// "
},
{
"path": "Game Trainers/common/include/FL/Fl_Image_Surface.H",
"chars": 4447,
"preview": "//\n// Draw-to-image code for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2016 by Bill Spitzak and others.\n//\n//"
},
{
"path": "Game Trainers/common/include/FL/Fl_Input.H",
"chars": 8517,
"preview": "//\n// Input header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2023 by Bill Spitzak and others.\n//\n// "
},
{
"path": "Game Trainers/common/include/FL/Fl_Input_.H",
"chars": 18084,
"preview": "//\n// Input base class header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2015 by Bill Spitzak and oth"
},
{
"path": "Game Trainers/common/include/FL/Fl_Input_Choice.H",
"chars": 6969,
"preview": "//\n// An input/chooser widget.\n// ______________ ____\n// | || __ |\n// | inp"
},
{
"path": "Game Trainers/common/include/FL/Fl_Int_Input.H",
"chars": 1089,
"preview": "//\n// Integer input header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and others"
},
{
"path": "Game Trainers/common/include/FL/Fl_JPEG_Image.H",
"chars": 1138,
"preview": "//\n// JPEG image header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and others.\n/"
},
{
"path": "Game Trainers/common/include/FL/Fl_Light_Button.H",
"chars": 1329,
"preview": "//\n// Lighted button header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2022 by Bill Spitzak and other"
},
{
"path": "Game Trainers/common/include/FL/Fl_Line_Dial.H",
"chars": 720,
"preview": "//\n// Line dial header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and others.\n//"
},
{
"path": "Game Trainers/common/include/FL/Fl_Menu.H",
"chars": 563,
"preview": "//\n// Old menu header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and others.\n//\n"
},
{
"path": "Game Trainers/common/include/FL/Fl_Menu_.H",
"chars": 10356,
"preview": "//\n// Menu base class header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2024 by Bill Spitzak and othe"
},
{
"path": "Game Trainers/common/include/FL/Fl_Menu_Bar.H",
"chars": 3460,
"preview": "//\n// Menu bar header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2017 by Bill Spitzak and others.\n//\n"
},
{
"path": "Game Trainers/common/include/FL/Fl_Menu_Button.H",
"chars": 2985,
"preview": "//\n// Menu button header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2022 by Bill Spitzak and others.\n"
},
{
"path": "Game Trainers/common/include/FL/Fl_Menu_Item.H",
"chars": 21411,
"preview": "//\n// Menu item header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2024 by Bill Spitzak and others.\n//"
},
{
"path": "Game Trainers/common/include/FL/Fl_Menu_Window.H",
"chars": 1226,
"preview": "//\n// Menu window header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and others.\n"
},
{
"path": "Game Trainers/common/include/FL/Fl_Multi_Browser.H",
"chars": 1817,
"preview": "//\n// Multi browser header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and others"
},
{
"path": "Game Trainers/common/include/FL/Fl_Multi_Label.H",
"chars": 4334,
"preview": "//\n// Multi-label header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2023 by Bill Spitzak and others.\n"
},
{
"path": "Game Trainers/common/include/FL/Fl_Multiline_Input.H",
"chars": 1750,
"preview": "//\n// Multiline input header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2011 by Bill Spitzak and othe"
},
{
"path": "Game Trainers/common/include/FL/Fl_Multiline_Output.H",
"chars": 1893,
"preview": "//\n// Multi line output header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2011 by Bill Spitzak and ot"
},
{
"path": "Game Trainers/common/include/FL/Fl_Native_File_Chooser.H",
"chars": 11098,
"preview": "//\n// FLTK native OS file chooser widget\n//\n// Copyright 2004 Greg Ercolano.\n// Copyright 2005-2024 by Bill Spitzak and "
},
{
"path": "Game Trainers/common/include/FL/Fl_Nice_Slider.H",
"chars": 735,
"preview": "//\n// \"Nice\" slider header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and others"
},
{
"path": "Game Trainers/common/include/FL/Fl_Object.H",
"chars": 642,
"preview": "//\n// Old Fl_Object header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and others"
},
{
"path": "Game Trainers/common/include/FL/Fl_Output.H",
"chars": 1811,
"preview": "//\n// Output header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2022 by Bill Spitzak and others.\n//\n//"
},
{
"path": "Game Trainers/common/include/FL/Fl_Overlay_Window.H",
"chars": 2650,
"preview": "//\n// Overlay window header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and other"
},
{
"path": "Game Trainers/common/include/FL/Fl_PDF_File_Surface.H",
"chars": 4178,
"preview": "//\n// Declaration of class Fl_PDF_File_Surface for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 2024 by Bill Spitzak "
},
{
"path": "Game Trainers/common/include/FL/Fl_PNG_Image.H",
"chars": 1569,
"preview": "//\n// PNG image header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2023 by Bill Spitzak and others.\n//"
},
{
"path": "Game Trainers/common/include/FL/Fl_PNM_Image.H",
"chars": 929,
"preview": "//\n// PNM image header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and others.\n//"
},
{
"path": "Game Trainers/common/include/FL/Fl_Pack.H",
"chars": 3254,
"preview": "//\n// Pack header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2020 by Bill Spitzak and others.\n//\n// T"
},
{
"path": "Game Trainers/common/include/FL/Fl_Paged_Device.H",
"chars": 4024,
"preview": "//\n// Printing support for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 2010-2024 by Bill Spitzak and others.\n//\n// T"
},
{
"path": "Game Trainers/common/include/FL/Fl_Pixmap.H",
"chars": 2717,
"preview": "//\n// Pixmap header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2017 by Bill Spitzak and others.\n//\n//"
},
{
"path": "Game Trainers/common/include/FL/Fl_Plugin.H",
"chars": 2458,
"preview": "//\n// A Plugin system for FLTK, implemented in Fl_Preferences.cxx.\n//\n// Copyright 2002-2023 by Matthias Melcher.\n//\n// "
},
{
"path": "Game Trainers/common/include/FL/Fl_Positioner.H",
"chars": 2645,
"preview": "//\n// Positioner header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2022 by Bill Spitzak and others.\n/"
},
{
"path": "Game Trainers/common/include/FL/Fl_PostScript.H",
"chars": 11513,
"preview": "//\n// Support for graphics output to PostScript file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 2010-2020 by Bi"
},
{
"path": "Game Trainers/common/include/FL/Fl_Preferences.H",
"chars": 16856,
"preview": "//\n// Preferences implementation for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 2002-2023 by Matthias Melcher.\n//\n/"
},
{
"path": "Game Trainers/common/include/FL/Fl_Printer.H",
"chars": 5967,
"preview": "//\n// Printing support for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 2010-2016 by Bill Spitzak and others.\n//\n// T"
},
{
"path": "Game Trainers/common/include/FL/Fl_Progress.H",
"chars": 1563,
"preview": "//\n// Progress bar widget definitions.\n//\n// Copyright 2000-2010 by Michael Sweet.\n//\n// This library is free software. "
},
{
"path": "Game Trainers/common/include/FL/Fl_RGB_Image.H",
"chars": 582,
"preview": "//\n// RGB Image header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and others.\n//"
},
{
"path": "Game Trainers/common/include/FL/Fl_Radio_Button.H",
"chars": 738,
"preview": "//\n// Radio button header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2014 by Bill Spitzak and others."
},
{
"path": "Game Trainers/common/include/FL/Fl_Radio_Light_Button.H",
"chars": 786,
"preview": "//\n// Radio light button header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2014 by Bill Spitzak and o"
},
{
"path": "Game Trainers/common/include/FL/Fl_Radio_Round_Button.H",
"chars": 786,
"preview": "//\n// Radio round button header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2014 by Bill Spitzak and o"
},
{
"path": "Game Trainers/common/include/FL/Fl_Rect.H",
"chars": 4911,
"preview": "//\n// Fl_Rect header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2023 by Bill Spitzak and others.\n//\n/"
},
{
"path": "Game Trainers/common/include/FL/Fl_Repeat_Button.H",
"chars": 1342,
"preview": "//\n// Repeat button header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and others"
},
{
"path": "Game Trainers/common/include/FL/Fl_Return_Button.H",
"chars": 1317,
"preview": "//\n// Return button header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2022 by Bill Spitzak and others"
},
{
"path": "Game Trainers/common/include/FL/Fl_Roller.H",
"chars": 1200,
"preview": "//\n// Roller header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2023 by Bill Spitzak and others.\n//\n//"
},
{
"path": "Game Trainers/common/include/FL/Fl_Round_Button.H",
"chars": 1255,
"preview": "//\n// Round button header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2022 by Bill Spitzak and others."
},
{
"path": "Game Trainers/common/include/FL/Fl_Round_Clock.H",
"chars": 853,
"preview": "//\n// Round clock header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and others.\n"
},
{
"path": "Game Trainers/common/include/FL/Fl_SVG_File_Surface.H",
"chars": 3445,
"preview": "//\n// Declaration of Fl_SVG_File_Surface in the Fast Light Tool Kit (FLTK).\n//\n// Copyright 2020 by Bill Spitzak and oth"
},
{
"path": "Game Trainers/common/include/FL/Fl_SVG_Image.H",
"chars": 5988,
"preview": "//\n// SVG Image header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 2017-2022 by Bill Spitzak and others.\n//"
},
{
"path": "Game Trainers/common/include/FL/Fl_Scheme.H",
"chars": 1663,
"preview": "//\n// Scheme header for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 2022-2023 by Bill Spitzak and others.\n//\n// This"
},
{
"path": "Game Trainers/common/include/FL/Fl_Scheme_Choice.H",
"chars": 999,
"preview": "//\n// Scheme Choice header for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 2022-2023 by Bill Spitzak and others.\n//\n"
},
{
"path": "Game Trainers/common/include/FL/Fl_Scroll.H",
"chars": 8451,
"preview": "//\n// Fl_Scroll header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2022 by Bill Spitzak and others.\n//"
},
{
"path": "Game Trainers/common/include/FL/Fl_Scrollbar.H",
"chars": 3230,
"preview": "//\n// Scroll bar header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and others.\n/"
},
{
"path": "Game Trainers/common/include/FL/Fl_Secret_Input.H",
"chars": 1312,
"preview": "//\n// Secret input header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2011 by Bill Spitzak and others."
},
{
"path": "Game Trainers/common/include/FL/Fl_Select_Browser.H",
"chars": 1468,
"preview": "//\n// Select browser header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and other"
},
{
"path": "Game Trainers/common/include/FL/Fl_Shared_Image.H",
"chars": 7173,
"preview": "//\n// Shared image header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2024 by Bill Spitzak and others."
},
{
"path": "Game Trainers/common/include/FL/Fl_Shortcut_Button.H",
"chars": 1249,
"preview": "//\n// Shortcut Button header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2023 by Bill Spitzak and othe"
},
{
"path": "Game Trainers/common/include/FL/Fl_Simple_Counter.H",
"chars": 904,
"preview": "//\n// Simple counter header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2022 by Bill Spitzak and other"
},
{
"path": "Game Trainers/common/include/FL/Fl_Single_Window.H",
"chars": 1719,
"preview": "//\n// Single-buffered window header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2024 by Bill Spitzak a"
},
{
"path": "Game Trainers/common/include/FL/Fl_Slider.H",
"chars": 3136,
"preview": "//\n// Slider header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and others.\n//\n//"
},
{
"path": "Game Trainers/common/include/FL/Fl_Spinner.H",
"chars": 6519,
"preview": "//\n// Spinner widget for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2022 by Bill Spitzak and others.\n//\n// Thi"
},
{
"path": "Game Trainers/common/include/FL/Fl_Sys_Menu_Bar.H",
"chars": 6242,
"preview": "//\n// MacOS system menu bar header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2017 by Bill Spitzak an"
},
{
"path": "Game Trainers/common/include/FL/Fl_Table.H",
"chars": 36959,
"preview": "//\n// Fl_Table -- A table widget for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 2002 by Greg Ercolano.\n// Copyright"
},
{
"path": "Game Trainers/common/include/FL/Fl_Table_Row.H",
"chars": 5236,
"preview": "//\n\n#ifndef _FL_TABLE_ROW_H\n#define _FL_TABLE_ROW_H\n\n//\n// Fl_Table_Row -- A row oriented table widget for the Fast Ligh"
},
{
"path": "Game Trainers/common/include/FL/Fl_Tabs.H",
"chars": 13136,
"preview": "//\n// Tab header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2023 by Bill Spitzak and others.\n//\n// Th"
},
{
"path": "Game Trainers/common/include/FL/Fl_Terminal.H",
"chars": 55361,
"preview": "//\n// Fl_Terminal - A terminal widget for Fast Light Tool Kit (FLTK).\n//\n// Copyright 2022 by Greg Ercolano.\n// Copyrigh"
},
{
"path": "Game Trainers/common/include/FL/Fl_Text_Buffer.H",
"chars": 30164,
"preview": "//\n// Header file for Fl_Text_Buffer class.\n//\n// Copyright 2001-2023 by Bill Spitzak and others.\n// Original code Copyr"
},
{
"path": "Game Trainers/common/include/FL/Fl_Text_Display.H",
"chars": 24402,
"preview": "//\n// Header file for Fl_Text_Display class.\n//\n// Copyright 2001-2023 by Bill Spitzak and others.\n// Original code Copy"
},
{
"path": "Game Trainers/common/include/FL/Fl_Text_Editor.H",
"chars": 5391,
"preview": "//\n// Header file for Fl_Text_Editor class.\n//\n// Copyright 2001-2023 by Bill Spitzak and others.\n// Original code Copyr"
},
{
"path": "Game Trainers/common/include/FL/Fl_Tile.H",
"chars": 2720,
"preview": "//\n// Tile header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2023 by Bill Spitzak and others.\n//\n// T"
},
{
"path": "Game Trainers/common/include/FL/Fl_Tiled_Image.H",
"chars": 1531,
"preview": "//\n// Tiled image header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2015 by Bill Spitzak and others.\n"
},
{
"path": "Game Trainers/common/include/FL/Fl_Timer.H",
"chars": 2019,
"preview": "//\n// Timer header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and others.\n//\n// "
},
{
"path": "Game Trainers/common/include/FL/Fl_Toggle_Button.H",
"chars": 1278,
"preview": "//\n// Toggle button header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and others"
},
{
"path": "Game Trainers/common/include/FL/Fl_Toggle_Light_Button.H",
"chars": 651,
"preview": "//\n// Toggle light button header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and "
},
{
"path": "Game Trainers/common/include/FL/Fl_Toggle_Round_Button.H",
"chars": 651,
"preview": "//\n// Toggle round button header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and "
},
{
"path": "Game Trainers/common/include/FL/Fl_Tooltip.H",
"chars": 5432,
"preview": "//\n// Tooltip header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2011 by Bill Spitzak and others.\n//\n/"
},
{
"path": "Game Trainers/common/include/FL/Fl_Tree.H",
"chars": 20197,
"preview": "//\n\n#ifndef FL_TREE_H\n#define FL_TREE_H\n\n#include <FL/Fl.H>\n#include <FL/Fl_Group.H>\n#include <FL/Fl_Scrollbar.H>\n#inclu"
},
{
"path": "Game Trainers/common/include/FL/Fl_Tree_Item.H",
"chars": 17155,
"preview": "//\n\n#ifndef FL_TREE_ITEM_H\n#define FL_TREE_ITEM_H\n\n#include <FL/Fl.H>\n#include <FL/Fl_Widget.H>\n#include <FL/Fl_Image.H>"
},
{
"path": "Game Trainers/common/include/FL/Fl_Tree_Item_Array.H",
"chars": 3161,
"preview": "//\n\n#ifndef _FL_TREE_ITEM_ARRAY_H\n#define _FL_TREE_ITEM_ARRAY_H\n\n#include <FL/Fl.H>\n#include \"Fl_Export.H\"\n\nclass FL_EXP"
},
{
"path": "Game Trainers/common/include/FL/Fl_Tree_Prefs.H",
"chars": 16393,
"preview": "//\n\n#ifndef FL_TREE_PREFS_H\n#define FL_TREE_PREFS_H\n\n#include <FL/Fl.H> // needed for ABI version features (via Enu"
},
{
"path": "Game Trainers/common/include/FL/Fl_Valuator.H",
"chars": 5006,
"preview": "//\n// Valuator header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2022 by Bill Spitzak and others.\n//\n"
},
{
"path": "Game Trainers/common/include/FL/Fl_Value_Input.H",
"chars": 4625,
"preview": "//\n// Value input header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2022 by Bill Spitzak and others.\n"
},
{
"path": "Game Trainers/common/include/FL/Fl_Value_Output.H",
"chars": 2566,
"preview": "//\n// Value output header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2022 by Bill Spitzak and others."
},
{
"path": "Game Trainers/common/include/FL/Fl_Value_Slider.H",
"chars": 3220,
"preview": "//\n// Value Slider header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2022 by Bill Spitzak and others."
},
{
"path": "Game Trainers/common/include/FL/Fl_Widget.H",
"chars": 50506,
"preview": "//\n// Widget header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2024 by Bill Spitzak and others.\n//\n//"
},
{
"path": "Game Trainers/common/include/FL/Fl_Widget_Surface.H",
"chars": 1516,
"preview": "//\n// Drivers code for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2016 by Bill Spitzak and others.\n//\n// This "
},
{
"path": "Game Trainers/common/include/FL/Fl_Window.H",
"chars": 24294,
"preview": "//\n// Window header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2023 by Bill Spitzak and others.\n//\n//"
},
{
"path": "Game Trainers/common/include/FL/Fl_Wizard.H",
"chars": 1313,
"preview": "//\n// Fl_Wizard widget definitions.\n//\n// Copyright 1999-2010 by Easy Software Products.\n// Copyright 2011-2020 by Bill "
},
{
"path": "Game Trainers/common/include/FL/Fl_XBM_Image.H",
"chars": 830,
"preview": "//\n// XBM image header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and others.\n//"
},
{
"path": "Game Trainers/common/include/FL/Fl_XPM_Image.H",
"chars": 847,
"preview": "//\n// XPM image header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and others.\n//"
},
{
"path": "Game Trainers/common/include/FL/Makefile.in",
"chars": 1443,
"preview": "#\n# Header Makefile for the Fast Light Tool Kit (FLTK).\n#\n# Copyright 1998-2021 by Bill Spitzak and others.\n#\n# This lib"
},
{
"path": "Game Trainers/common/include/FL/README.Xcode",
"chars": 143,
"preview": "All FLTK header files are in the FL subdirectory of the fltk.framework.\nImage header files are located in \"fltk.framewor"
},
{
"path": "Game Trainers/common/include/FL/filename.H",
"chars": 5477,
"preview": "/*\n * Filename header file for the Fast Light Tool Kit (FLTK).\n *\n * Copyright 1998-2023 by Bill Spitzak and others.\n *\n"
},
{
"path": "Game Trainers/common/include/FL/fl_ask.H",
"chars": 4673,
"preview": "//\n// Standard dialog header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2022 by Bill Spitzak and othe"
},
{
"path": "Game Trainers/common/include/FL/fl_attr.h",
"chars": 5315,
"preview": "/*\n * Function attribute declarations for the Fast Light Tool Kit (FLTK).\n *\n * Copyright 1998-2024 by Bill Spitzak and "
},
{
"path": "Game Trainers/common/include/FL/fl_callback_macros.H",
"chars": 23557,
"preview": "/*\n * Macros for easy callbacks for the Fast Light Tool Kit (FLTK).\n *\n * Copyright 2023 by Bill Spitzak and others.\n *\n"
},
{
"path": "Game Trainers/common/include/FL/fl_casts.H",
"chars": 1600,
"preview": "//\n// Experimental inline \"cast functions\" for the Fast Light Toolkit (FLTK).\n// See also issue #109: \"VS2017 warnings w"
},
{
"path": "Game Trainers/common/include/FL/fl_config.h",
"chars": 1890,
"preview": "/* FL/fl_config.h. Generated from fl_config.cmake.in by CMake. */\n/*\n * Build configuration file for the Fast Light To"
},
{
"path": "Game Trainers/common/include/FL/fl_draw.H",
"chars": 43823,
"preview": "//\n// Portable drawing function header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2023 by Bill Spitza"
},
{
"path": "Game Trainers/common/include/FL/fl_message.H",
"chars": 574,
"preview": "//\n// Standard message header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2023 by Bill Spitzak and oth"
},
{
"path": "Game Trainers/common/include/FL/fl_show_colormap.H",
"chars": 1208,
"preview": "//\n// Colormap picker header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and othe"
},
{
"path": "Game Trainers/common/include/FL/fl_show_input.H",
"chars": 518,
"preview": "//\n// Standard input dialog header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak an"
},
{
"path": "Game Trainers/common/include/FL/fl_string_functions.h",
"chars": 1109,
"preview": "/*\n * Platform agnostic string portability functions for the Fast Light Tool Kit (FLTK).\n *\n * Copyright 2020-2022 by Bi"
},
{
"path": "Game Trainers/common/include/FL/fl_types.h",
"chars": 1943,
"preview": "/*\n * Simple \"C\"-style types for the Fast Light Tool Kit (FLTK).\n *\n * Copyright 1998-2020 by Bill Spitzak and others.\n "
},
{
"path": "Game Trainers/common/include/FL/fl_utf8.h",
"chars": 8244,
"preview": "/*\n * Author: Jean-Marc Lienher ( http://oksid.ch )\n * Copyright 2000-2010 by O'ksi'D.\n * Copyright 2016-2021 by Bill Sp"
},
{
"path": "Game Trainers/common/include/FL/forms.H",
"chars": 33939,
"preview": "//\n// Forms emulation header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2023 by Bill Spitzak and othe"
},
{
"path": "Game Trainers/common/include/FL/gl.h",
"chars": 3304,
"preview": "//\n// OpenGL header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2018 by Bill Spitzak and others.\n//\n//"
},
{
"path": "Game Trainers/common/include/FL/gl2opengl.h",
"chars": 1421,
"preview": "/* gl.h\n\n GL to OpenGL translator.\n If you include this, you might be able to port old GL programs.\n "
},
{
"path": "Game Trainers/common/include/FL/gl_draw.H",
"chars": 553,
"preview": "//\n// OpenGL header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and others.\n//\n//"
},
{
"path": "Game Trainers/common/include/FL/glu.h",
"chars": 1197,
"preview": "//\n// GLu header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2010 by Bill Spitzak and others.\n//\n// Yo"
},
{
"path": "Game Trainers/common/include/FL/glut.H",
"chars": 18771,
"preview": "//\n// GLUT emulation header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2023 by Bill Spitzak and other"
},
{
"path": "Game Trainers/common/include/FL/mac.H",
"chars": 6344,
"preview": "//\n// Mac header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2018 by Bill Spitzak and others.\n//\n// Th"
},
{
"path": "Game Trainers/common/include/FL/math.h",
"chars": 1507,
"preview": "//\n// Math header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2020 by Bill Spitzak and others.\n//\n// T"
},
{
"path": "Game Trainers/common/include/FL/names.h",
"chars": 3685,
"preview": "//\n// Event and other names header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2024 by Bill Spitzak an"
},
{
"path": "Game Trainers/common/include/FL/platform.H",
"chars": 2653,
"preview": "//\n// Platform header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2023 by Bill Spitzak and others.\n//\n"
},
{
"path": "Game Trainers/common/include/FL/platform_types.h",
"chars": 4742,
"preview": "/*\n * Copyright 2016-2023 by Bill Spitzak and others.\n *\n * This library is free software. Distribution and use rights a"
},
{
"path": "Game Trainers/common/include/FL/wayland.H",
"chars": 2211,
"preview": "//\n// Wayland/X11 hybrid platform header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2022 by Bill Spit"
},
{
"path": "Game Trainers/common/include/FL/win32.H",
"chars": 3310,
"preview": "//\n// Windows platform header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2022 by Bill Spitzak and oth"
},
{
"path": "Game Trainers/common/include/FL/x.H",
"chars": 876,
"preview": "//\n// *Deprecated* platform header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2018 by Bill Spitzak an"
},
{
"path": "Game Trainers/common/include/FL/x11.H",
"chars": 4440,
"preview": "//\n// X11 platform header file for the Fast Light Tool Kit (FLTK).\n//\n// Copyright 1998-2022 by Bill Spitzak and others."
},
{
"path": "Game Trainers/common/include/FLTKUtils.h",
"chars": 26960,
"preview": "#include <nlohmann/json.hpp>\n#include <fstream>\n#include <shlobj.h>\n#include <FL/Fl_Table.H>\n\nusing json = nlohmann::jso"
},
{
"path": "Game Trainers/common/include/Il2CppBase.h",
"chars": 15294,
"preview": "#pragma once\n\n#include \"TrainerBase.h\"\n#include <psapi.h>\n\nclass Il2CppBase : public TrainerBase\n{\npublic:\n HMODULE h"
},
{
"path": "Game Trainers/common/include/MinHook.h",
"chars": 7530,
"preview": "/*\n * MinHook - The Minimalistic API Hooking Library for x64/x86\n * Copyright (C) 2009-2017 Tsuda Kageyu.\n * All righ"
},
{
"path": "Game Trainers/common/include/MonoBase.h",
"chars": 25997,
"preview": "// MonoBase.h\n#pragma once\n\n#include <FL/Fl.H>\n#include \"TrainerBase.h\"\n#include <mutex>\n#include <shlwapi.h>\n#include <"
},
{
"path": "Game Trainers/common/include/MonoBridge.cpp",
"chars": 11120,
"preview": "#include <Windows.h>\n#include <mutex>\n#include <string>\n#include <vector>\n\n#define MONO_API extern \"C\" __declspec(dllimp"
},
{
"path": "Game Trainers/common/include/MonoBridge.def",
"chars": 115,
"preview": "LIBRARY MonoBridge\nEXPORTS\n GetFunctionPointersThread\n LoadAssemblyThread\n InvokeMethodThread\n SendData"
},
{
"path": "Game Trainers/common/include/TrainerBase.h",
"chars": 30573,
"preview": "// TrainerBase.h\n#pragma once\n\n#include <Windows.h>\n#include <TlHelp32.h>\n#include <any>\n#include <functional>\n#include "
},
{
"path": "Game Trainers/common/include/il2cpp/hook.h",
"chars": 1160,
"preview": "#pragma once\n#include <Windows.h>\n#include \"memory.h\"\n#include \"MinHook.h\"\n\nstruct HOOK {\n void* target_func;\n voi"
},
{
"path": "Game Trainers/common/include/il2cpp/il2cpp.cpp",
"chars": 5023,
"preview": "#include \"il2cpp.h\"\n\n\nnamespace IL2CPP {\n\n\tIl2CppDomain* domain;\n\n\tnamespace API {\n\t\t#define DO_API(r, n, p) IL2CPP_DECL"
},
{
"path": "Game Trainers/common/include/il2cpp/il2cpp.h",
"chars": 4542,
"preview": "#pragma once\n\n#include \"il2cpp_types.h\"\n\n#define IL2CPP_API_H \"il2cpp_api.h\"\n#define IL2CPP_TYPEDEF(r, n,"
},
{
"path": "Game Trainers/common/include/il2cpp/il2cpp_api.h",
"chars": 16478,
"preview": "#ifndef DO_API_NO_RETURN\n#define DO_API_NO_RETURN(r, n, p) DO_API(r,n,p)\n#endif\n\n\nDO_API(void, il2cpp_init, (const char*"
},
{
"path": "Game Trainers/common/include/il2cpp/il2cpp_types.h",
"chars": 71422,
"preview": "#include <stdint.h>\n\n#pragma once\n\n/*\n * Field Attributes (21.1.5).\n */\n\n#define FIELD_ATTRIBUTE_FIELD_ACCESS_MASK 0"
},
{
"path": "Game Trainers/common/include/il2cpp/memory.h",
"chars": 807,
"preview": "#pragma once\n#include <Windows.h>\n#include <vector>\n\nclass MEMORY\n{\npublic:\n // Find a DLL module base address\n vo"
},
{
"path": "Game Trainers/common/include/il2cpp/unity.cpp",
"chars": 1488,
"preview": "#include \"unity.h\"\n\nnamespace Unity {\n\n\tunity_GameObject_FindGameObjectsWithTag_t GameObject_FindGameObjectsWithTag;\n\tun"
},
{
"path": "Game Trainers/common/include/il2cpp/unity.h",
"chars": 1228,
"preview": "#pragma once\n\n#include \"memory.h\"\n#include \"il2cpp.h\"\n\n\n// Unity Types\nstruct vec3;\nstruct Rect;\nstruct GUIContent;\nstru"
},
{
"path": "Game Trainers/common/include/il2cpp/vec.h",
"chars": 1212,
"preview": "#pragma once\n\n#define _USE_MATH_DEFINES\n#include <math.h>\n#include <iostream>\n\nstruct Vector2 {\n\tfloat x; float y;\n\n\tVec"
},
{
"path": "Game Trainers/common/include/nlohmann/adl_serializer.hpp",
"chars": 2281,
"preview": "// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.11"
},
{
"path": "Game Trainers/common/include/nlohmann/byte_container_with_subtype.hpp",
"chars": 3535,
"preview": "// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.11"
},
{
"path": "Game Trainers/common/include/nlohmann/detail/abi_macros.hpp",
"chars": 4121,
"preview": "// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.11"
},
{
"path": "Game Trainers/common/include/nlohmann/detail/conversions/from_json.hpp",
"chars": 21050,
"preview": "// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.11"
},
{
"path": "Game Trainers/common/include/nlohmann/detail/conversions/to_chars.hpp",
"chars": 38578,
"preview": "// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.11"
},
{
"path": "Game Trainers/common/include/nlohmann/detail/conversions/to_json.hpp",
"chars": 16814,
"preview": "// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.11"
},
{
"path": "Game Trainers/common/include/nlohmann/detail/exceptions.hpp",
"chars": 9927,
"preview": "// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.11"
},
{
"path": "Game Trainers/common/include/nlohmann/detail/hash.hpp",
"chars": 4018,
"preview": "// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.11"
},
{
"path": "Game Trainers/common/include/nlohmann/detail/input/binary_reader.hpp",
"chars": 104715,
"preview": "// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.11"
},
{
"path": "Game Trainers/common/include/nlohmann/detail/input/input_adapters.hpp",
"chars": 19635,
"preview": "// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.11"
}
]
// ... and 158 more files (download for full content)
About this extraction
This page contains the full source code of the dyang886/Game-Cheats-Manager GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 358 files (3.5 MB), approximately 944.2k tokens, and a symbol index with 2261 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.