### Installation Bundle Configuration

Source: https://github.com/domferr/linux-powertoys/blob/main/linux/CMakeLists.txt

Configures the installation process to create a relocatable bundle. It sets the install prefix and ensures a clean build bundle directory.

```cmake
# === Installation ===
# By default, "installing" just makes a relocatable bundle in the build
# directory.
set(BUILD_BUNDLE_DIR "${PROJECT_BINARY_DIR}/bundle")
if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
  set(CMAKE_INSTALL_PREFIX "${BUILD_BUNDLE_DIR}" CACHE PATH "..." FORCE)
endif()

# Start with a clean build bundle directory every time.
install(CODE "
  file(REMOVE_RECURSE \"${BUILD_BUNDLE_DIR}/\")
  " COMPONENT Runtime)

set(INSTALL_BUNDLE_DATA_DIR "${CMAKE_INSTALL_PREFIX}/data")
set(INSTALL_BUNDLE_LIB_DIR "${CMAKE_INSTALL_PREFIX}/lib")
```

--------------------------------

### Install Executable and Data Files

Source: https://github.com/domferr/linux-powertoys/blob/main/linux/CMakeLists.txt

Installs the application executable, ICU data file, Flutter library, and bundled plugin libraries into the designated bundle directories. This prepares the application for deployment.

```cmake
install(TARGETS ${BINARY_NAME} RUNTIME DESTINATION "${CMAKE_INSTALL_PREFIX}"
  COMPONENT Runtime)

install(FILES "${FLUTTER_ICU_DATA_FILE}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}"
  COMPONENT Runtime)

install(FILES "${FLUTTER_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
  COMPONENT Runtime)

foreach(bundled_library ${PLUGIN_BUNDLED_LIBRARIES})
  install(FILES "${bundled_library}"
    DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
    COMPONENT Runtime)
endforeach(bundled_library)
```

--------------------------------

### Install Flutter Assets

Source: https://github.com/domferr/linux-powertoys/blob/main/linux/CMakeLists.txt

Removes existing Flutter assets and installs new ones. Use this to manage application assets during the build process.

```cmake
set(FLUTTER_ASSET_DIR_NAME "flutter_assets")
install(
  CODE "
  file(REMOVE_RECURSE \"${INSTALL_BUNDLE_DATA_DIR}/${FLUTTER_ASSET_DIR_NAME}\")
  " COMPONENT Runtime)
install(DIRECTORY "${PROJECT_BUILD_DIR}/${FLUTTER_ASSET_DIR_NAME}"
  DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" COMPONENT Runtime)
```

--------------------------------

### Library Installation Path

Source: https://github.com/domferr/linux-powertoys/blob/main/linux/CMakeLists.txt

Sets the runtime path for bundled libraries to be relative to the binary location. This is crucial for creating relocatable application bundles.

```cmake
set(CMAKE_INSTALL_RPATH "$ORIGIN/lib")
```

--------------------------------

### Install AOT Library (Non-Debug)

Source: https://github.com/domferr/linux-powertoys/blob/main/linux/CMakeLists.txt

Installs the Ahead-Of-Time (AOT) compiled library for non-debug builds. Ensure the AOT_LIBRARY variable is correctly set.

```cmake
if(NOT CMAKE_BUILD_TYPE MATCHES "Debug")
  install(FILES "${AOT_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
    COMPONENT Runtime)
endif()
```

--------------------------------

### Run Linux PowerToys in Debug Mode

Source: https://github.com/domferr/linux-powertoys/blob/main/README.md

Execute the project in debug mode using the provided make command. Ensure Flutter and Dart are installed as prerequisites.

```bash
make run-debug
```

--------------------------------

### Project and Executable Configuration

Source: https://github.com/domferr/linux-powertoys/blob/main/linux/CMakeLists.txt

Sets the minimum CMake version, project name, executable name, and GTK application identifier. This is fundamental for project setup and identifying the application.

```cmake
cmake_minimum_required(VERSION 3.10)
project(runner LANGUAGES CXX)

# The name of the executable created for the application. Change this to change
# the on-disk name of your application.
set(BINARY_NAME "linuxpowertoys")
# The unique GTK application identifier for this application. See:
# https://wiki.gnome.org/HowDoI/ChooseApplicationID
set(APPLICATION_ID "com.ferrarodomenico.linuxpowertoys")
```

--------------------------------

### System Dependencies with PkgConfig

Source: https://github.com/domferr/linux-powertoys/blob/main/linux/CMakeLists.txt

Finds and checks for GTK 3.0 using PkgConfig. This ensures that the necessary GTK libraries are available for the application.

```cmake
find_package(PkgConfig REQUIRED)
pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0)
```

--------------------------------

### Runtime Output Directory Configuration

Source: https://github.com/domferr/linux-powertoys/blob/main/linux/CMakeLists.txt

Sets the runtime output directory for the executable to a subdirectory within the build directory. This prevents accidental execution of unbundled copies.

```cmake
set_target_properties(${BINARY_NAME}
  PROPERTIES
  RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/intermediates_do_not_run"
)
```

--------------------------------

### Cross-Building Sysroot Configuration

Source: https://github.com/domferr/linux-powertoys/blob/main/linux/CMakeLists.txt

Configures the sysroot and search paths for cross-building. This is used when building the application for a different platform than the build machine.

```cmake
if(FLUTTER_TARGET_PLATFORM_SYSROOT)
  set(CMAKE_SYSROOT ${FLUTTER_TARGET_PLATFORM_SYSROOT})
  set(CMAKE_FIND_ROOT_PATH ${CMAKE_SYSROOT})
  set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
  set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
  set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
  set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
endif()
```

--------------------------------

### Asset Directory Handling

Source: https://github.com/domferr/linux-powertoys/blob/main/linux/CMakeLists.txt

Ensures the assets directory is fully re-copied on each build. This prevents issues with stale asset files in the application bundle.

```cmake
# Fully re-copy the assets directory on each build to avoid having stale files
```

--------------------------------

### Configuring Flutter Library and Dependencies

Source: https://github.com/domferr/linux-powertoys/blob/main/linux/flutter/CMakeLists.txt

This section sets up the Flutter library path, ICU data file, project build directory, and AOT library path. It also defines the header files for the Flutter library and configures an INTERFACE library for Flutter with include directories and link libraries.

```cmake
set(EPHEMERAL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ephemeral")

# Configuration provided via flutter tool.
include(${EPHEMERAL_DIR}/generated_config.cmake)

# Serves the same purpose as list(TRANSFORM ... PREPEND ...),
# which isn't available in 3.10.
function(list_prepend LIST_NAME PREFIX)
    set(NEW_LIST "")
    foreach(element ${${LIST_NAME}})
        list(APPEND NEW_LIST "${PREFIX}${element}")
    endforeach(element)
    set(${LIST_NAME} "${NEW_LIST}" PARENT_SCOPE)
endfunction()

# === Flutter Library ===
# System-level dependencies.
find_package(PkgConfig REQUIRED)
pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0)
pkg_check_modules(GLIB REQUIRED IMPORTED_TARGET glib-2.0)
pkg_check_modules(GIO REQUIRED IMPORTED_TARGET gio-2.0)

set(FLUTTER_LIBRARY "${EPHEMERAL_DIR}/libflutter_linux_gtk.so")

# Published to parent scope for install step.
set(FLUTTER_LIBRARY ${FLUTTER_LIBRARY} PARENT_SCOPE)
set(FLUTTER_ICU_DATA_FILE "${EPHEMERAL_DIR}/icudtl.dat" PARENT_SCOPE)
set(PROJECT_BUILD_DIR "${PROJECT_DIR}/build/" PARENT_SCOPE)
set(AOT_LIBRARY "${PROJECT_DIR}/build/lib/libapp.so" PARENT_SCOPE)

list(APPEND FLUTTER_LIBRARY_HEADERS
  "fl_basic_message_channel.h"
  "fl_binary_codec.h"
  "fl_binary_messenger.h"
  "fl_dart_project.h"
  "fl_engine.h"
  "fl_json_message_codec.h"
  "fl_json_method_codec.h"
  "fl_message_codec.h"
  "fl_method_call.h"
  "fl_method_channel.h"
  "fl_method_codec.h"
  "fl_method_response.h"
  "fl_plugin_registrar.h"
  "fl_plugin_registry.h"
  "fl_standard_message_codec.h"
  "fl_standard_method_codec.h"
  "fl_string_codec.h"
  "fl_value.h"
  "fl_view.h"
  "flutter_linux.h"
)
list_prepend(FLUTTER_LIBRARY_HEADERS "${EPHEMERAL_DIR}/flutter_linux/")
add_library(flutter INTERFACE)
target_include_directories(flutter INTERFACE
  "${EPHEMERAL_DIR}"
)
target_link_libraries(flutter INTERFACE "${FLUTTER_LIBRARY}")
target_link_libraries(flutter INTERFACE
  PkgConfig::GTK
  PkgConfig::GLIB
  PkgConfig::GIO
)
add_dependencies(flutter flutter_assemble)
```

--------------------------------

### Generated Plugin Build Rules

Source: https://github.com/domferr/linux-powertoys/blob/main/linux/CMakeLists.txt

Includes the CMake file for generated plugin build rules. This is necessary for managing and building plugins used by the application.

```cmake
include(flutter/generated_plugins.cmake)
```

--------------------------------

### Modern CMake Behavior Opt-in

Source: https://github.com/domferr/linux-powertoys/blob/main/linux/CMakeLists.txt

Explicitly opts into modern CMake behaviors to avoid warnings with recent CMake versions. This ensures compatibility and adherence to current CMake standards.

```cmake
cmake_policy(SET CMP0063 NEW)
```

--------------------------------

### Custom CMake Function for List Prepending

Source: https://github.com/domferr/linux-powertoys/blob/main/linux/flutter/CMakeLists.txt

A custom CMake function to prepend an element to each item in a list. This is a workaround for older CMake versions (pre-3.10) that lack the `list(TRANSFORM ... PREPEND ...)` command.

```cmake
function(list_prepend LIST_NAME PREFIX)
    set(NEW_LIST "")
    foreach(element ${${LIST_NAME}})
        list(APPEND NEW_LIST "${PREFIX}${element}")
    endforeach(element)
    set(${LIST_NAME} "${NEW_LIST}" PARENT_SCOPE)
endfunction()
```

--------------------------------

### Flutter Tool Backend Custom Command

Source: https://github.com/domferr/linux-powertoys/blob/main/linux/flutter/CMakeLists.txt

Defines a custom command to execute the Flutter tool backend script. This command is designed to run every time by using a phony output file, as determining precise inputs/outputs for the Flutter tool is complex.

```cmake
add_custom_command(
  OUTPUT ${FLUTTER_LIBRARY} ${FLUTTER_LIBRARY_HEADERS}
    ${CMAKE_CURRENT_BINARY_DIR}/_phony_
  COMMAND ${CMAKE_COMMAND} -E env
    ${FLUTTER_TOOL_ENVIRONMENT}
    "${FLUTTER_ROOT}/packages/flutter_tools/bin/tool_backend.sh"
      ${FLUTTER_TARGET_PLATFORM} ${CMAKE_BUILD_TYPE}
  VERBATIM
)
add_custom_target(flutter_assemble DEPENDS
  "${FLUTTER_LIBRARY}"
  ${FLUTTER_LIBRARY_HEADERS}
)
```

--------------------------------

### Application Target Definition

Source: https://github.com/domferr/linux-powertoys/blob/main/linux/CMakeLists.txt

Defines the main executable target for the application, linking against Flutter and GTK libraries. It also applies standard build settings and adds Flutter assemble as a dependency.

```cmake
add_definitions(-DAPPLICATION_ID="${APPLICATION_ID}")

# Define the application target. To change its name, change BINARY_NAME above,
# not the value here, or `flutter run` will no longer work.
#
# Any new source files that you add to the application should be added here.
add_executable(${BINARY_NAME}
  "main.cc"
  "my_application.cc"
  "${FLUTTER_MANAGED_DIR}/generated_plugin_registrant.cc"
)

# Apply the standard set of build settings. This can be removed for applications
# that need different build settings.
apply_standard_settings(${BINARY_NAME})

# Add dependency libraries. Add any application-specific dependencies here.
target_link_libraries(${BINARY_NAME} PRIVATE flutter)
target_link_libraries(${BINARY_NAME} PRIVATE PkgConfig::GTK)

# Run the Flutter tool portions of the build. This must not be removed.
add_dependencies(${BINARY_NAME} flutter_assemble)
```

--------------------------------

### Flutter Managed Directory and Subdirectory

Source: https://github.com/domferr/linux-powertoys/blob/main/linux/CMakeLists.txt

Sets the path to the Flutter managed directory and adds it as a subdirectory. This is essential for integrating Flutter's build rules.

```cmake
set(FLUTTER_MANAGED_DIR "${CMAKE_CURRENT_SOURCE_DIR}/flutter")
add_subdirectory(${FLUTTER_MANAGED_DIR})
```

--------------------------------

### Build Type Configuration

Source: https://github.com/domferr/linux-powertoys/blob/main/linux/CMakeLists.txt

Sets the default build type to 'Debug' if not already specified. This ensures a consistent build mode for development.

```cmake
if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
  set(CMAKE_BUILD_TYPE "Debug" CACHE
    STRING "Flutter build mode" FORCE)
  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS
    "Debug" "Profile" "Release")
endif()
```

--------------------------------

### Standard Compilation Settings Function

Source: https://github.com/domferr/linux-powertoys/blob/main/linux/CMakeLists.txt

Defines a function to apply common compilation settings like C++ standard, warnings, optimization levels, and debug definitions. This promotes code consistency across targets.

```cmake
function(APPLY_STANDARD_SETTINGS TARGET)
  target_compile_features(${TARGET} PUBLIC cxx_std_14)
  target_compile_options(${TARGET} PRIVATE -Wall -Werror)
  target_compile_options(${TARGET} PRIVATE "<$<NOT:$<CONFIG:Debug>>:-O3>")
  target_compile_definitions(${TARGET} PRIVATE "<$<NOT:$<CONFIG:Debug>>:NDEBUG>")
endfunction()
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.