Synergy

https://github.com/symless/synergy-core
Admin
Synergy is a software utility that allows you to use the keyboard, mouse, or trackpad of one...
Tokens:11,207
Snippets:85
Trust Score:9.7
License:GPL-2.0
Update:6 months ago
Show doc for...
Tokens:
Raw
### Start Synergy Server with Configuration

Source: https://context7.com/symless/synergy-core/llms.txt

Command-line examples for starting the Synergy server, including specifying a configuration file and enabling debug logging.

```bash
# Start server with configuration file
deskflow-server -c /path/to/deskflow.conf

# Start server with debug logging
deskflow-server -c /path/to/deskflow.conf --debug DEBUG

# Start server in foreground mode
deskflow-server -c /path/to/deskflow.conf -f
```

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

### Start Synergy Client Connection

Source: https://context7.com/symless/synergy-core/llms.txt

Command-line examples for starting the Synergy client, including connecting to a server, specifying a network interface, and disabling the clipboard.

```bash
# Start client connecting to server
deskflow-client --name my-client server-hostname:24800

# Start client with specific network interface
deskflow-client --name my-client --bind 192.168.1.50 server-hostname

# Start client with clipboard disabled
deskflow-client --name my-client --disable-clipboard server-hostname

# Start client in foreground with debug logging
deskflow-client -f --debug DEBUG --name my-client server-hostname
```

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

### Install Dependencies on Linux/macOS/BSD

Source: https://github.com/symless/synergy-core/blob/master/BUILD.md

Run this script to install necessary dependencies on Unix-like systems.

```bash
./scripts/install_deps.sh
```

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

### Event Queue and Event Handling Setup

Source: https://context7.com/symless/synergy-core/llms.txt

Illustrates setting up an event queue, registering event handlers for client connection/disconnection, creating timers, adding custom events, and running the main event loop.

```cpp
#include "base/EventQueue.h"
#include "base/Event.h"
#include "base/IEventJob.h"
#include "base/TMethodEventJob.h"

class MyEventHandler {
public:
    void handleConnect(const Event& event, void* userData) {
        // Handle connection event
    }

    void handleDisconnect(const Event& event, void* userData) {
        // Handle disconnection event
    }
};

// Event handling setup
void setupEventHandling() {
    EventQueue events;
    MyEventHandler handler;

    // Register event handlers using method jobs
    events.adoptHandler(
        events.forClient().connected(),
        &handler,
        new TMethodEventJob<MyEventHandler>(
            &handler,
            &MyEventHandler::handleConnect
        )
    );

    events.adoptHandler(
        events.forClient().disconnected(),
        &handler,
        new TMethodEventJob<MyEventHandler>(
            &handler,
            &MyEventHandler::handleDisconnect
        )
    );

    // Create a repeating timer (fires every 5 seconds)
    EventQueueTimer* timer = events.newTimer(5.0, &handler);

    // Create a one-shot timer (fires once after 10 seconds)
    EventQueueTimer* oneShot = events.newOneShotTimer(10.0, &handler);

    // Add custom event to the queue
    Event customEvent(Event::kUser, &handler, nullptr);
    events.addEvent(customEvent);

    // Main event loop
    Event event;
    while (events.getEvent(event, -1.0)) {
        if (!events.dispatchEvent(event)) {
            break;
        }
    }

    // Cleanup
    events.deleteTimer(timer);
    events.deleteTimer(oneShot);
    events.removeHandlers(&handler);
}
```

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

### Install Dependencies on Windows

Source: https://github.com/symless/synergy-core/blob/master/BUILD.md

Execute this Python script to install dependencies on Windows.

```python
python scripts/install_deps.py
```

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

### Setup IPC Server for GUI-Daemon Communication

Source: https://context7.com/symless/synergy-core/llms.txt

Demonstrates how to set up and use the IpcServer class to facilitate communication between the Synergy daemon and GUI. Includes sending log and command messages.

```cpp
#include "ipc/IpcServer.h"
#include "ipc/IpcMessage.h"
#include "net/SocketMultiplexer.h"
#include "base/EventQueue.h"

// IPC server setup for daemon
void setupIpcServer() {
    EventQueue events;
    SocketMultiplexer socketMultiplexer;

    // Create IPC server on default port (localhost only)
    IpcServer ipcServer(&events, &socketMultiplexer);

    // Or create on specific port
    // IpcServer ipcServer(&events, &socketMultiplexer, 24802);

    // Start listening for IPC clients (GUI)
    ipcServer.listen();

    // Check if GUI is connected
    if (ipcServer.hasClients(kIpcClientGui)) {
        // GUI is connected, can send messages
    }

    // Send log message to GUI
    IpcLogLineMessage logMessage("Connection established");
    ipcServer.send(logMessage, kIpcClientGui);

    // Send command message to all clients
    IpcCommandMessage cmdMessage("reload-config");
    ipcServer.send(cmdMessage, kIpcClientUnknown);  // Broadcast
}
```

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

### Platform-Specific Target Properties and Installation

Source: https://github.com/symless/synergy-core/blob/master/src/apps/deskflow-core/CMakeLists.txt

Configures runtime output directories and install paths for the executable based on the operating system. Sets RPATH for macOS and installs to 'bin' for Linux.

```cmake
if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin" AND BUILD_GUI)
  set_target_properties(${target} PROPERTIES
    BUILD_WITH_INSTALL_RPATH TRUE
    INSTALL_RPATH "@loader_path/../Libraries;@loader_path/../Frameworks"
    RUNTIME_OUTPUT_DIRECTORY $<TARGET_BUNDLE_CONTENT_DIR:${GUI_BINARY_NAME}>/MacOS
  )
elseif(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
  install(TARGETS ${target} DESTINATION bin)
endif()
```

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

### Install Executable on Linux

Source: https://github.com/symless/synergy-core/blob/master/src/apps/deskflow-legacy/CMakeLists.txt

Installs the target executable to the 'bin' directory on Linux systems.

```cmake
elseif(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
  install(TARGETS ${target} DESTINATION bin)
endif()
```

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

### Install Dependencies for Synergy

Source: https://context7.com/symless/synergy-core/llms.txt

Shell commands to install build dependencies for Synergy on Linux/macOS/BSD and Windows.

```bash
# Install dependencies
# Linux/macOS/BSD:
./scripts/install_deps.sh

# Windows:
python scripts/install_deps.py
```

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

### Execute Test Configuration

Source: https://github.com/symless/synergy-core/blob/master/src/test/CMakeLists.txt

Invokes the primary macro to start the test configuration process.

```cmake
config_all_tests()
```

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

### Install Executable on macOS

Source: https://github.com/symless/synergy-core/blob/master/src/apps/deskflow-legacy/CMakeLists.txt

Installs the target executable to a specific bundle directory on macOS systems.

```cmake
if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
  install(TARGETS ${target} DESTINATION ${DESKFLOW_BUNDLE_BINARY_DIR})

```

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

### Configure macOS Deployment and Signing

Source: https://github.com/symless/synergy-core/blob/master/src/gui/CMakeLists.txt

Handles RPATH settings, bundle installation, and optional code signing for macOS development builds.

```cmake
if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")

  set_target_properties(${target} PROPERTIES
    INSTALL_RPATH "@loader_path/../Libraries;@loader_path/../Frameworks"
    MACOSX_BUNDLE_INFO_PLIST "${CMAKE_BINARY_DIR}/bundle/Synergy.app/Contents/Info.plist"
  )

  install(TARGETS ${target} BUNDLE DESTINATION ${CMAKE_BINARY_DIR}/bundle)

  find_program(MACDEPLOYQT_BIN macdeployqt6)
  message(STATUS "Found macdeployqt6: ${MACDEPLOYQT_BIN}")

  set(MACDEPLOYQT_CMD
      "${MACDEPLOYQT_BIN} ${DESKFLOW_BUNDLE_DIR} -always-overwrite")
  install(CODE "MESSAGE (\"Running: ${MACDEPLOYQT_CMD}\")")
  install(CODE "execute_process(COMMAND ${MACDEPLOYQT_CMD})")

  if (NOT "${APPLE_CODESIGN_DEV}" STREQUAL "")
    message(STATUS "Apple codesign ID for development only: ${APPLE_CODESIGN_DEV}")
    add_custom_command(
      TARGET ${target} POST_BUILD
      COMMAND /usr/bin/codesign
              --force
              --options runtime
              --entitlements "$<SHELL_PATH:${CMAKE_SOURCE_DIR}/res/mac/entitlements-dev.plist>"
              --sign "${APPLE_CODESIGN_DEV}"
              "$<TARGET_BUNDLE_DIR:${target}>"
      VERBATIM
    )
  endif()

elseif(${CMAKE_SYSTEM_NAME} MATCHES "Linux")

  install(TARGETS ${target} DESTINATION bin)

elseif(WIN32)

  find_package(Qt6 REQUIRED COMPONENTS Widgets)
  get_target_property(WINDEPLOYQT_EXE Qt6::windeployqt IMPORTED_LOCATION)
  add_custom_command(TARGET ${GUI_BINARY_NAME} POST_BUILD
    COMMAND ${WINDEPLOYQT_EXE}
      --force-openssl
      --no-compiler-runtime
      --no-system-d3d-compiler
      --no-opengl-sw
      --no-quick-import
      $<TARGET_FILE:${GUI_BINARY_NAME}>
    COMMENT "Deploying Qt runtime for ${GUI_BINARY_NAME}.exe"
  )

endif()
```

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

### Initialize and Manage Server via C++ API

Source: https://context7.com/symless/synergy-core/llms.txt

Demonstrates initializing the Server class, connecting screens, and managing client interactions programmatically.

```cpp
#include "server/Server.h"
#include "server/Config.h"
#include "deskflow/Screen.h"
#include "base/EventQueue.h"

// Initialize the server with configuration and primary client
void initializeServer() {
    IEventQueue* events = new EventQueue();
    deskflow::server::Config config(events);

    // Add screens to configuration
    config.addScreen("server-pc");
    config.addScreen("client-pc");

    // Define screen connections (client-pc is to the right of server-pc)
    config.connect("server-pc", kRight, 0.0f, 1.0f,
                   "client-pc", 0.0f, 1.0f);
    config.connect("client-pc", kLeft, 0.0f, 1.0f,
                   "server-pc", 0.0f, 1.0f);

    // Set the network address for listening
    NetworkAddress address(24800);  // Default Synergy port
    config.setDeskflowAddress(address);

    // Create primary screen and client
    deskflow::Screen* screen = createPlatformScreen(events);
    PrimaryClient* primaryClient = new PrimaryClient("server-pc", screen);

    // Create and start the server
    deskflow::ServerArgs args;
    Server* server = new Server(config, primaryClient, screen, events, args);

    // Get connected client count
    UInt32 numClients = server->getNumClients();

    // Get list of connected client names
    std::vector<String> clientNames;
    server->getClients(clientNames);

    // Send file to active client
    server->sendFileToClient("/path/to/file.txt");

    // Change configuration dynamically
    deskflow::server::Config newConfig(events);
    // ... configure newConfig ...
    if (server->setConfig(newConfig)) {
        // Configuration accepted
    }

    // Disconnect all clients
    server->disconnect();
}
```

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

### Initialize and Connect Client

Source: https://context7.com/symless/synergy-core/llms.txt

Initializes and connects a client to a Synergy server. Requires event queue, platform screen, network address, socket factory, and client arguments.

```cpp
#include "client/Client.h"
#include "deskflow/Screen.h"
#include "deskflow/ClientArgs.h"
#include "net/NetworkAddress.h"
#include "base/EventQueue.h"

// Initialize and connect a client to a server
void initializeClient() {
    IEventQueue* events = new EventQueue();

    // Create the client screen
    deskflow::Screen* screen = createPlatformScreen(events);

    // Configure server address (hostname:port)
    NetworkAddress serverAddress("192.168.1.100", 24800);
    serverAddress.resolve();  // Resolve hostname to IP

    // Create socket factory for network communication
    ISocketFactory* socketFactory = new TCPSocketFactory(events);

    // Configure client arguments
    deskflow::ClientArgs args;
    args.m_enableClipboard = true;
    args.m_clipboardSharingSize = 10 * 1024 * 1024;  // 10MB max clipboard

    // Create the client
    Client* client = new Client(
        events,
        "my-client-pc",     // Client name (must match server config)
        serverAddress,
        socketFactory,
        screen,
        args
    );

    // Initiate connection to server
    client->connect();

    // Check connection status
    if (client->isConnecting()) {
        // Connection in progress
    }

    if (client->isConnected()) {
        // Successfully connected
        NetworkAddress addr = client->getServerAddress();
    }

    // Send file to server
    client->sendFileToServer("/path/to/document.pdf");

    // Disconnect from server
    client->disconnect("User requested disconnect");

    // Cleanup
    delete client;
    delete screen;
}

```

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

### Run Synergy Application

Source: https://context7.com/symless/synergy-core/llms.txt

Command to launch the Synergy desktop application after building from source.

```bash
# Run the application
./build/bin/deskflow
```

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

### Configure Project on Windows

Source: https://github.com/symless/synergy-core/blob/master/BUILD.md

Configure the build system using CMake with a Windows-specific preset.

```bash
cmake -B build --preset=windows-release
```

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

### Configure Deskflow GUI Build

Source: https://github.com/symless/synergy-core/blob/master/src/gui/CMakeLists.txt

Sets up the executable target, enables Qt auto-generation features, and includes necessary source directories.

```cmake
set(target ${GUI_BINARY_NAME})

set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTORCC ON)
set(CMAKE_AUTOUIC ON)
set(CMAKE_INCLUDE_CURRENT_DIR ON)

set(res_dir ${GUI_RES_DIR})
set(qrc_file ${GUI_QRC_FILE})

file(
  GLOB
  sources
  src/*.cpp
  src/*.h
  src/validators/*
  src/widgets/*)
file(GLOB ui_files src/*.ui)

if(WIN32)
  set(rc_files ${res_dir}/win/app.rc ${PROJECT_BINARY_DIR}/src/version.rc)
endif()

# regular exe headers
include_directories(./src)

# gui library autogen headers:
# qt doesn't seem to auto include the autogen headers for libraries.
include_directories(${PROJECT_BINARY_DIR}/src/lib/gui/gui_autogen/include)

# generated includes
include_directories(${PROJECT_BINARY_DIR}/config)

add_executable(${target} WIN32 MACOSX_BUNDLE ${sources} ${ui_files} ${rc_files} ${qrc_file})

target_link_libraries(
  ${target}
  ${DESKFLOW_GUI_HOOK_LIB}
  gui
  Qt6::Core
  Qt6::Widgets
  Qt6::Network)

if(WIN32)
  set_target_properties(${target} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:LIBCMT")
endif()
```

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

### Create Static Client Library

Source: https://github.com/symless/synergy-core/blob/master/src/lib/client/CMakeLists.txt

Creates a static library named 'client' using the collected source files. Static libraries are linked directly into the executable, simplifying deployment.

```cmake
add_library(client STATIC ${sources})
```

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

### Configure Project on Linux/macOS/BSD

Source: https://github.com/symless/synergy-core/blob/master/BUILD.md

Configure the build system using CMake for Unix-like systems.

```bash
cmake -B build
```

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

### Configure and Build Synergy from Source

Source: https://context7.com/symless/synergy-core/llms.txt

CMake commands for configuring and building the Synergy project from source code on different platforms.

```bash
# Configure the build
# Linux/macOS/BSD:
cmake -B build

# Windows:
cmake -B build --preset=windows-release

# Build
cmake --build build -j8
```

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

### Define Basic Server Configuration

Source: https://context7.com/symless/synergy-core/llms.txt

Configures a horizontal layout of three computers using screens, links, and aliases sections.

```conf
# Basic configuration with three computers arranged horizontally
# Layout: [Laptop] -- [Desktop1] -- [iMac]

section: screens
    # Define logical names for each computer
    Laptop:
    Desktop1:
    iMac:
end

section: links
    # Desktop1 is the center screen
    Desktop1:
        right = iMac
        left  = Laptop

    # Laptop connects to Desktop1 on its right
    Laptop:
        right = Desktop1

    # iMac connects to Desktop1 on its left
    iMac:
        left = Desktop1
end

section: aliases
    # Map actual hostnames to logical names
    iMac:
        John-Smiths-iMac-3.local
    Laptop:
        John-Smiths-MacBook-3.local
end
```

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

### Configure Test Environment

Source: https://github.com/symless/synergy-core/blob/master/src/test/CMakeLists.txt

Initializes test directories and dependencies, then includes subdirectories for integration and unit tests.

```cmake
macro(config_all_tests)

  set(base_dir ${PROJECT_SOURCE_DIR})
  set(src_dir ${base_dir}/src)
  set(test_base_dir ${src_dir}/test)
  set(gui_dir ${src_dir}/gui/src)

  config_test_deps()

  add_subdirectory(integtests)
  add_subdirectory(unittests)

endmacro()
```

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

### Network Address Configuration

Source: https://context7.com/symless/synergy-core/llms.txt

Shows how to configure network addresses, including creating wildcard addresses, resolving hostnames, checking address validity, and comparing addresses.

```cpp
#include "net/NetworkAddress.h"

// Network address configuration
void networkConfiguration() {
    // Create wildcard address (listen on all interfaces)
    NetworkAddress listenAddress(24800);

    // Create address from hostname and port
    NetworkAddress serverAddress("server.local", 24800);

    // Create address from hostname with port suffix
    NetworkAddress addressWithPort("server.local:24801");

    // Resolve hostname to IP address
    size_t resolvedCount = serverAddress.resolve();

    // Check if address is valid
    if (serverAddress.isValid()) {
        // Get the hostname
        String hostname = serverAddress.getHostname();

        // Get the port
        int port = serverAddress.getPort();

        // Get native address for socket operations
        const ArchNetAddress& addr = serverAddress.getAddress();
    }

    // Try alternate addresses if multiple IPs resolved
    for (size_t i = 0; i < resolvedCount; ++i) {
        serverAddress.resolve(i);  // Select specific IP
        // Attempt connection...
    }

    // Compare addresses
    NetworkAddress addr1("192.168.1.100", 24800);
    NetworkAddress addr2("192.168.1.100", 24800);
    if (addr1 == addr2) {
        // Addresses are equal
    }
}
```

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

### Create Executable

Source: https://github.com/symless/synergy-core/blob/master/src/apps/deskflow-legacy/CMakeLists.txt

Defines the main executable target and lists all source files to be compiled.

```cmake
add_executable(${target} ${sources})
```

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

### Configure Test Directories

Source: https://github.com/symless/synergy-core/blob/master/src/test/CMakeLists.txt

Sets up include directories for test components and triggers source file discovery.

```cmake
macro(config_test)

  include_directories(
    ${test_base_dir}
    ${src_dir}
    ${src_dir}/lib
    ${gui_dir}
    ${ext_dir})

  set_sources()

endmacro()
```

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

### Run Unit Tests

Source: https://github.com/symless/synergy-core/blob/master/BUILD.md

Execute the unit tests after building Deskflow.

```bash
./build/bin/unittests
```

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

### Configure Deskflow Network Library with CMake

Source: https://github.com/symless/synergy-core/blob/master/src/lib/net/CMakeLists.txt

Defines source files, creates a static library, and links necessary dependencies including OpenSSL and platform-specific libraries.

```cmake
file(GLOB headers "*.h" "InverseSockets/*.h")
file(GLOB sources "*.cpp" "InverseSockets/*.cpp")

if(ADD_HEADERS_TO_SOURCES)
  list(APPEND sources ${headers})
endif()

add_library(net STATIC ${sources})

target_link_libraries(
  net
  PUBLIC ${OPENSSL_LIBRARIES}
  PRIVATE mt io)

if(WIN32)
  target_link_libraries(net PRIVATE Crypt32 ws2_32)
endif()
```

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

### Run Synergy Tests

Source: https://context7.com/symless/synergy-core/llms.txt

Commands to execute unit and integration tests for the Synergy application after building from source.

```bash
# Run tests
./build/bin/unittests
./build/bin/integtests
```

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

### Configure CMake project directories and subdirectories

Source: https://github.com/symless/synergy-core/blob/master/src/CMakeLists.txt

Sets up include directories and adds subdirectories for the project build process, with conditional logic for GUI and test components.

```cmake
include_directories(./lib)
include_directories(${CMAKE_CURRENT_BINARY_DIR}/lib)

add_subdirectory(lib)
add_subdirectory(apps)

if(BUILD_GUI)
  add_subdirectory(gui)
endif(BUILD_GUI)

if(BUILD_TESTS)
  add_subdirectory(test)
endif()
```

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

### Key Mapping Operations with KeyMap

Source: https://context7.com/symless/synergy-core/llms.txt

Illustrates various operations of the KeyMap class for handling keyboard input, including adding key entries, combinations, configuring modifiers, and mapping keys.

```cpp
#include "deskflow/KeyMap.h"

// Key mapping operations
void keyMappingOperations() {
    deskflow::KeyMap keyMap;

    // Add a key entry
    deskflow::KeyMap::KeyItem item;
    item.m_id = 'A';
    item.m_group = 0;
    item.m_button = 38;  // Platform-specific button
    item.m_required = KeyModifierShift;
    item.m_sensitive = KeyModifierShift | KeyModifierCapsLock;
    item.m_generates = 0;
    item.m_dead = false;
    item.m_lock = false;
    keyMap.addKeyEntry(item);

    // Add a key combination (e.g., compose sequence)
    KeyID sequence[] = {'`', 'e'};  // Produces é
    keyMap.addKeyCombinationEntry(0x00E9, 0, sequence, 2);

    // Configure half-duplex modifiers (toggle on press only)
    keyMap.addHalfDuplexModifier(kKeyNumLock);
    keyMap.addHalfDuplexModifier(kKeyCapsLock);

    // Finish key map configuration
    keyMap.finish();

    // Map a key press to keystrokes
    deskflow::KeyMap::Keystrokes keystrokes;
    deskflow::KeyMap::ModifierToKeys activeModifiers;
    KeyModifierMask currentState = 0;
    KeyModifierMask desiredMask = KeyModifierShift;

    const deskflow::KeyMap::KeyItem* mappedKey = keyMap.mapKey(
        keystrokes,
        'A',              // Key to map
        0,                // Group
        activeModifiers,
        currentState,
        desiredMask,
        false,            // Not autorepeat
        "en-US"           // Language
    );

    // Check for dead key
    if (deskflow::KeyMap::isDeadKey(kKeyDeadAcute)) {
        KeyID deadKey = deskflow::KeyMap::getDeadKey('\'');
    }

    // Format key for display
    String keyString = deskflow::KeyMap::formatKey(
        kKeyF1, KeyModifierControl | KeyModifierAlt
    );
    // Result: "ctrl+alt+f1"

    // Parse key from string
    KeyID parsedKey;
    if (deskflow::KeyMap::parseKey("f1", parsedKey)) {
        // Successfully parsed
    }

    // Parse modifiers from string
    String modString = "ctrl+alt+";
    KeyModifierMask parsedMods;
    if (deskflow::KeyMap::parseModifiers(modString, parsedMods)) {
        // parsedMods contains KeyModifierControl | KeyModifierAlt
    }
}
```

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

### Run Deskflow Application

Source: https://github.com/symless/synergy-core/blob/master/BUILD.md

Launch the Deskflow application after a successful build.

```bash
./build/bin/deskflow
```

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

### Run Integration Tests

Source: https://github.com/symless/synergy-core/blob/master/BUILD.md

Execute the integration tests after building Deskflow.

```bash
./build/bin/integtests
```

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

### Configure Deskflow Build System

Source: https://github.com/symless/synergy-core/blob/master/src/lib/arch/CMakeLists.txt

Collects source files, handles platform-specific architecture directories, and defines the static library target.

```cmake
file(GLOB headers "*.h")
file(GLOB sources "*.cpp")

if(ADD_HEADERS_TO_SOURCES)
  list(APPEND sources ${headers})
endif()

# arch
if(WIN32)
  file(GLOB arch_headers "win32/*.h")
  file(GLOB arch_sources "win32/*.cpp")
elseif(UNIX)
  file(GLOB arch_headers "unix/*.h")
  file(GLOB arch_sources "unix/*.cpp")
endif()

list(APPEND sources ${arch_sources})
list(APPEND headers ${arch_headers})

if(ADD_HEADERS_TO_SOURCES)
  list(APPEND sources ${headers})
endif()

add_library(arch STATIC ${sources})

if(UNIX)
  target_link_libraries(arch ${CMAKE_DL_LIBS} ${libs})

  if(NOT APPLE)
    find_package(Qt6 COMPONENTS DBus)
    target_link_libraries(arch Qt6::DBus)
  endif()
endif()
```

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

### Initialize Git Submodule

Source: https://github.com/symless/synergy-core/blob/master/CMakeLists.txt

Ensures the 'synergy-extra' submodule is initialized. If the submodule is not found, it attempts to update it. If it still fails, the build process halts with an error message.

```cmake
cmake_minimum_required(VERSION 3.22)

project(deskflow C CXX)

set(SYNERGY_EXTRA_ROOT "${CMAKE_SOURCE_DIR}/ext/synergy-extra")
set(SYNERGY_EXTRA_FILE "${SYNERGY_EXTRA_ROOT}/cmake/Extra.cmake")
if (NOT EXISTS ${SYNERGY_EXTRA_FILE})
  execute_process(
    COMMAND git submodule update --init
    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
    RESULT_VARIABLE GIT_SUBMODULE_RESULT
  )
  if (NOT EXISTS ${SYNERGY_EXTRA_FILE})
    message(FATAL_ERROR "Unable to init submodule. Run manually: git submodule update --init")
  endif()
endif()
```

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

### Define Executable Target and Sources

Source: https://github.com/symless/synergy-core/blob/master/src/apps/deskflow-core/CMakeLists.txt

Sets the client source name and defines the main executable target along with its source files. Includes platform-specific manifest and resource files for Windows.

```cmake
set(client_source_name "deskflow-core")
set(target ${CORE_BINARY_NAME})
set(sources ${client_source_name}.cpp)

if(WIN32)
  list(APPEND sources ${client_source_name}.exe.manifest
       ${PROJECT_BINARY_DIR}/src/version.rc)
endif()

add_executable(${target} ${sources})
```

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

### Configure Test Dependencies

Source: https://github.com/symless/synergy-core/blob/master/src/test/CMakeLists.txt

Sets up include paths for GUI autogen headers and defines the list of required libraries for testing.

```cmake
macro(config_test_deps)

  # gui library autogen headers:
  # qt doesn't seem to auto include the autogen headers for libraries.
  include_directories(${PROJECT_BINARY_DIR}/src/lib/gui/gui_autogen/include)

  set(test_libs
      arch
      base
      client
      server
      io
      net
      platform
      server
      app
      mt
      ipc
      gui
      ${GMOCK_LIB}
      ${GTEST_LIB}
      ${libs})

endmacro()
```

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

### Build Deskflow

Source: https://github.com/symless/synergy-core/blob/master/BUILD.md

Compile the Deskflow project using CMake, utilizing multiple cores for faster build times.

```bash
cmake --build build -j8
```

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

### Configure Deskflow static library in CMake

Source: https://github.com/symless/synergy-core/blob/master/src/lib/io/CMakeLists.txt

Collects all .h and .cpp files in the directory and compiles them into a static library named io.

```cmake
file(GLOB headers "*.h")
file(GLOB sources "*.cpp")

if(ADD_HEADERS_TO_SOURCES)
  list(APPEND sources ${headers})
endif()

add_library(io STATIC ${sources})
```

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

### Clipboard Operations

Source: https://context7.com/symless/synergy-core/llms.txt

Demonstrates basic clipboard operations including opening, clearing, adding data in multiple formats, checking for data, retrieving data, and marshalling/unmarshalling for network transmission.

```cpp
#include "deskflow/Clipboard.h"
#include "deskflow/IClipboard.h"

// Clipboard operations
void clipboardOperations() {
    Clipboard clipboard;

    // Open clipboard for access
    IClipboard::Time time = 12345;
    clipboard.open(time);

    // Clear existing content
    clipboard.empty();

    // Add text content
    String textData = "Hello from Synergy!";
    clipboard.add(IClipboard::kText, textData);

    // Add HTML content
    String htmlData = "<html><body><b>Hello</b></body></html>";
    clipboard.add(IClipboard::kHTML, htmlData);

    // Check if format is available
    if (clipboard.has(IClipboard::kText)) {
        String text = clipboard.get(IClipboard::kText);
    }

    if (clipboard.has(IClipboard::kHTML)) {
        String html = clipboard.get(IClipboard::kHTML);
    }

    // Get clipboard timestamp
    IClipboard::Time clipTime = clipboard.getTime();

    // Close clipboard
    clipboard.close();

    // Marshal clipboard for network transmission
    String marshalled = clipboard.marshall();

    // Unmarshal clipboard data from network
    Clipboard receivedClipboard;
    receivedClipboard.unmarshall(marshalled, time);
}
```

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

### Configure Platform-Specific Sources and Libraries

Source: https://github.com/symless/synergy-core/blob/master/src/lib/platform/CMakeLists.txt

Uses CMake conditional logic to glob source files and link dependencies based on the target operating system.

```cmake
if(WIN32)
  file(GLOB headers "MSWindows*.h")
  file(GLOB sources "MSWindows*.cpp")
elseif(APPLE)
  file(GLOB headers "OSX*.h" "IOSX*.h")
  file(
    GLOB
    sources
    "OSX*.cpp"
    "IOSX*.cpp"
    "OSX*.m"
    "OSX*.mm")
elseif(UNIX)
  file(GLOB x_headers "XWindows*.h")
  file(GLOB x_sources "XWindows*.cpp")

  if(LIBEI_FOUND)
    file(GLOB ei_headers "Ei*.h")
    file(GLOB ei_sources "Ei*.cpp")

    # The Portal sources also require EI.
    if(LIBPORTAL_FOUND)
      file(GLOB portal_headers "Portal*.h")
      file(GLOB portal_sources "Portal*.cpp")
    endif()
  endif()

  list(
    APPEND
    headers
    ${x_headers}
    ${ei_headers}
    ${portal_headers})
  list(
    APPEND
    sources
    ${x_sources}
    ${ei_sources}
    ${portal_sources})
endif()

if(ADD_HEADERS_TO_SOURCES)
  list(APPEND sources ${headers})
endif()

if(APPLE)
  list(APPEND inc /System/Library/Frameworks)
endif()

include_directories(${inc})
add_library(platform STATIC ${sources})
target_link_libraries(platform client ${libs})

macro(link_wayland_libs)
  target_link_libraries(platform ${LIBXKBCOMMON_LINK_LIBRARIES}
                        ${GLIB2_LINK_LIBRARIES} ${LIBM_LIBRARIES})

  if(LIBEI_FOUND)
    target_link_libraries(platform ${LIBEI_LINK_LIBRARIES})
  endif()

  if(LIBPORTAL_FOUND)
    target_link_libraries(platform ${LIBPORTAL_LINK_LIBRARIES})
  endif()
endmacro()

if(UNIX)
  target_link_libraries(
    platform
    io
    net
    ipc
    app
    client
    ${libs})

  if(NOT APPLE)
    find_package(Qt6 COMPONENTS DBus)

    target_link_libraries(platform Qt6::DBus)

    if(${LIBXKBCOMMON_VERSION} VERSION_GREATER_EQUAL "1.10")
      target_compile_definitions(platform PRIVATE HAVE_XKB_KEYMAP_MOD_GET_MASK=1)
    endif()

    link_wayland_libs()
  endif()
endif()

if(APPLE)
  find_library(COCOA_LIBRARY Cocoa)
  target_link_libraries(platform ${COCOA_LIBRARY})
endif()
```

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

### Set Source Files

Source: https://github.com/symless/synergy-core/blob/master/src/test/CMakeLists.txt

Recursively gathers header and source files, including mocks and shared test utilities, and handles platform-specific resource files.

```cmake
macro(set_sources)

  file(GLOB_RECURSE headers ${CMAKE_CURRENT_SOURCE_DIR}/*.h)
  file(GLOB_RECURSE sources ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)

  file(GLOB_RECURSE shared_headers ${test_base_dir}/shared/*.h)
  file(GLOB_RECURSE shared_sources ${test_base_dir}/shared/*.cpp)

  list(APPEND headers ${shared_headers})
  list(APPEND sources ${shared_sources})

  file(GLOB_RECURSE mock_headers ${test_base_dir}/mock/*.h)
  file(GLOB_RECURSE mock_sources ${test_base_dir}/mock/*.cpp)

  list(APPEND headers ${mock_headers})
  list(APPEND sources ${mock_sources})

  if(ADD_HEADERS_TO_SOURCES)
    list(APPEND sources ${headers})
  endif()

  if(WIN32)
    list(APPEND sources ${PROJECT_BINARY_DIR}/src/version.rc)
  endif()

  replace_platform_sources()
  replace_arch_sources()

endmacro()
```

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

### Configure Deskflow Client Build

Source: https://github.com/symless/synergy-core/blob/master/src/apps/deskflow-client/CMakeLists.txt

Defines the build target, source files, and platform-specific logic for the Deskflow client application.

```cmake
set(client_source_name "deskflow-client")
set(target ${CLIENT_BINARY_NAME})
set(sources ${client_source_name}.cpp)

if(WIN32)
  file(GLOB arch_headers "MSWindows*.h")
  file(GLOB arch_sources "MSWindows*.cpp")
  list(
    APPEND
    sources
    resource.h
    ${client_source_name}.ico
    ${client_source_name}.rc
    tb_error.ico
    tb_idle.ico
    tb_run.ico
    tb_wait.ico
    ${client_source_name}.exe.manifest
    ${PROJECT_BINARY_DIR}/src/version.rc)
elseif(APPLE)
  file(GLOB arch_headers "OSX*.h")
  file(GLOB arch_sources "OSX*.cpp")
elseif(UNIX)
  file(GLOB arch_headers "XWindows*.h")
  file(GLOB arch_sources "XWindows*.cpp")
endif()

list(APPEND sources ${arch_sources})
list(APPEND headers ${arch_headers})

if(ADD_HEADERS_TO_SOURCES)
  list(APPEND sources ${headers})
endif()

add_executable(${target} ${sources})
target_link_libraries(
  ${target}
  arch
  base
  client
  io
  mt
  net
  ipc
  platform
  server
  app
  ${libs})

if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin" AND BUILD_GUI)
  set_target_properties(${target} PROPERTIES
    BUILD_WITH_INSTALL_RPATH TRUE
    INSTALL_RPATH "@loader_path/../Libraries;@loader_path/../Frameworks"
    RUNTIME_OUTPUT_DIRECTORY $<TARGET_BUNDLE_CONTENT_DIR:${GUI_BINARY_NAME}>/MacOS
  )
elseif(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
  install(TARGETS ${target} DESTINATION bin)
endif()
```

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

### Configure Deskflow base library with CMake

Source: https://github.com/symless/synergy-core/blob/master/src/lib/base/CMakeLists.txt

Defines the library source files and handles conditional linking for Unix-based systems.

```cmake
file(GLOB headers "*.h")
file(GLOB sources "*.cpp")

if(ADD_HEADERS_TO_SOURCES)
  list(APPEND sources ${headers})
endif()

add_library(base STATIC ${sources})

if(UNIX)
  target_link_libraries(base)
endif()
```

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

### Configure IPC Library Build

Source: https://github.com/symless/synergy-core/blob/master/src/lib/ipc/CMakeLists.txt

Defines source files and links necessary dependencies for the IPC static library.

```cmake
file(GLOB headers "*.h")
file(GLOB sources "*.cpp")

if(ADD_HEADERS_TO_SOURCES)
  list(APPEND sources ${headers})
endif()

add_library(ipc STATIC ${sources})

if(UNIX)
  target_link_libraries(
    ipc
    arch
    base
    mt
    io
    net
    app)
endif()
```

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

### Configure Deskflow Server Library in CMake

Source: https://github.com/symless/synergy-core/blob/master/src/lib/server/CMakeLists.txt

Defines the library target and manages source file inclusion and platform-specific dependencies.

```cmake
file(GLOB headers "*.h")
file(GLOB sources "*.cpp")

if(ADD_HEADERS_TO_SOURCES)
  list(APPEND sources ${headers})
endif()

add_library(server STATIC ${sources})

if(UNIX)
  target_link_libraries(server app)
endif()
```

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

### Discover Source and Header Files

Source: https://github.com/symless/synergy-core/blob/master/src/lib/client/CMakeLists.txt

Uses CMake's GLOB command to find all header and source files in the respective directories. This is a common pattern for managing source files in CMake projects.

```cmake
file(GLOB headers "*.h")
file(GLOB sources "*.cpp")
```

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

### Link Libraries for Executable

Source: https://github.com/symless/synergy-core/blob/master/src/apps/deskflow-core/CMakeLists.txt

Links the necessary libraries to the main executable target. Ensure all listed libraries are available and correctly configured in the build environment.

```cmake
target_link_libraries(
  ${target}
  arch
  base
  client
  io
  mt
  net
  ipc
  platform
  server
  app
  ${libs})
```

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

### Configure Deskflow Library Build

Source: https://github.com/symless/synergy-core/blob/master/src/lib/deskflow/CMakeLists.txt

Defines source files, platform-specific headers, and library linking requirements for the Deskflow project.

```cmake
set(lib_name app)

file(GLOB headers "*.h" "languages/*.h" "ipc/*.h")
file(GLOB sources "*.cpp" "languages/*.cpp" "ipc/*.cpp")

if(WIN32)
  file(GLOB arch_headers "win32/*.h")
  file(GLOB arch_sources "win32/*.cpp")

  if(HAVE_WINTOAST)
    list(APPEND arch_sources ${WINTOAST_DIR}/src/wintoastlib.cpp)
  endif()

elseif(UNIX)
  file(GLOB arch_headers "unix/*.h")
  file(GLOB arch_sources "unix/*.cpp")
endif()

list(APPEND sources ${arch_sources})
list(APPEND headers ${arch_headers})

if(ADD_HEADERS_TO_SOURCES)
  list(APPEND sources ${headers})
endif()
  
add_library(${lib_name} STATIC ${sources})

if(WIN32)

  target_link_libraries(${lib_name} PRIVATE Qt6::Core Qt6::Network)

elseif(UNIX)

  target_link_libraries(
    ${lib_name}
    PRIVATE
    arch
    client
    ipc
    net
    base
    platform
    mt
    server
    ${cli11_lib}
    ${tomlplusplus_lib})

  if(NOT APPLE)
    target_link_libraries(${lib_name} PRIVATE Qt6::Xml)

    find_package(PkgConfig)
    if(PKG_CONFIG_FOUND)
      target_link_libraries(
        ${lib_name} PRIVATE
        PkgConfig::lib_glib
        PkgConfig::lib_gdkpixbuf
        PkgConfig::lib_notify)
    endif()
  endif()
endif()
```

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

### Configure Project Settings

Source: https://github.com/symless/synergy-core/blob/master/CMakeLists.txt

Calls functions defined in the included CMake modules to set the project version, configure build definitions, set up build options, link libraries, and configure packaging.

```cmake
set_version()
configure_definitions()
configure_build()
configure_libs()
configure_packaging()
```

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

### Link Platform-Specific Libraries on Unix

Source: https://github.com/symless/synergy-core/blob/master/src/lib/client/CMakeLists.txt

Links the 'client' library with 'app' and 'io' libraries when building on a Unix-like system. This ensures that platform-specific dependencies are included.

```cmake
if(UNIX)
  target_link_libraries(client app io)
endif()
```

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

### Configure and link unit test executable

Source: https://github.com/symless/synergy-core/blob/master/src/test/unittests/CMakeLists.txt

Defines an executable target and links it with necessary test libraries using CMake.

```cmake
config_test()
set(target ${UNIT_TESTS_BIN})
add_executable(${target} ${sources})
target_link_libraries(${target} ${test_libs})
```

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

### Add Windows Version Resource

Source: https://github.com/symless/synergy-core/blob/master/src/apps/deskflow-legacy/CMakeLists.txt

Conditionally adds a version resource file for Windows builds. This file is typically generated.

```cmake
if(WIN32)
  list(APPEND sources ${PROJECT_BINARY_DIR}/src/version.rc)
endif()
```

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

### Define Advanced Multi-Monitor Configuration

Source: https://context7.com/symless/synergy-core/llms.txt

Configures complex screen layouts with multiple monitors per machine using spatial links.

```conf
# Advanced setup: Desktop2 has multiple monitors arranged around Desktop1
#
#            +--------+ +---------+
#            |Desktop2| |Desktop2 |
#            |        | |         |
#            +--------+ +---------+
# +-------+  +--------+ +---------+
# |Laptop |  |Desktop1| |Desktop2 |
# |       |  |        | |         |
# +-------+  +--------+ +---------+

section: screens
    desktop1:
    desktop2:
    laptop:
end

section: links
    # Desktop1 has neighbors on multiple sides
    desktop1:
        right = desktop2
        up    = desktop2
        left  = laptop

    # Desktop2 wraps around desktop1
    desktop2:
        left  = desktop1
        down  = desktop1

    # Laptop on the left
    laptop:
        right = desktop1
end

section: aliases
    desktop2:
        John-Smiths-MacBook-3.local
end
```

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

### Windows Daemon Build Configuration

Source: https://github.com/symless/synergy-core/blob/master/src/apps/deskflow-daemon/CMakeLists.txt

Configures the build for the Windows daemon executable. This block is conditional on WIN32 being defined. It finds all header and source files, adds the executable target, and links essential libraries.

```cmake
if(WIN32)

  set(target ${DAEMON_BINARY_NAME})

  file(GLOB headers "*.h")
  file(GLOB sources "*.cpp")

  add_executable(${target} WIN32 ${sources} ${PROJECT_BINARY_DIR}/src/version.rc)

  target_link_libraries(
    ${target}
    arch
    base
    io
    ipc
    mt
    net
    platform
    app
    ${libs}
    Qt6::Core)
  
  find_package(Qt6 REQUIRED COMPONENTS Widgets)
  get_target_property(WINDEPLOYQT_EXE Qt6::windeployqt IMPORTED_LOCATION)
  add_custom_command(TARGET ${DAEMON_BINARY_NAME} POST_BUILD
    COMMAND ${WINDEPLOYQT_EXE}
      --no-compiler-runtime
      --no-system-d3d-compiler
      --no-opengl-sw
      --no-quick-import
      $<TARGET_FILE:${DAEMON_BINARY_NAME}>
    COMMENT "Deploying Qt runtime for ${DAEMON_BINARY_NAME}.exe"
  )

endif()
```

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

### Include Custom CMake Modules

Source: https://github.com/symless/synergy-core/blob/master/CMakeLists.txt

Includes several custom CMake modules to configure project settings. These modules handle versioning, build definitions, build configurations, library linking, and packaging.

```cmake
# Include 'Synergy Extra' first to control the cached variables.
include(${SYNERGY_EXTRA_FILE})

include(cmake/Version.cmake)
include(cmake/Definitions.cmake)
include(cmake/Build.cmake)
include(cmake/Libraries.cmake)
include(cmake/Packaging.cmake)
```

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

### Define and link integration test executable

Source: https://github.com/symless/synergy-core/blob/master/src/test/integtests/CMakeLists.txt

Configures an integration test target by defining the executable and linking necessary test libraries.

```cmake
config_test()
set(target ${INTEG_TESTS_BIN})
add_executable(${target} ${sources})
target_link_libraries(${target} ${test_libs})
```

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

### Define Library with Source Files

Source: https://github.com/symless/synergy-core/blob/master/src/lib/mt/CMakeLists.txt

This CMake code defines a static library named 'mt' and includes all header and source files found in the respective directories. Optionally includes headers in sources if ADD_HEADERS_TO_SOURCES is set.

```cmake
file(GLOB headers "*.h")
file(GLOB sources "*.cpp")

if(ADD_HEADERS_TO_SOURCES)
  list(APPEND sources ${headers})
endif()

add_library(mt STATIC ${sources})
```

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

### Replace Platform Sources

Source: https://github.com/symless/synergy-core/blob/master/src/test/CMakeLists.txt

Filters out generic platform files and replaces them with files specific to the current operating system (Windows, macOS, or Unix).

```cmake
macro(replace_platform_sources)

  set(platform_dir ${CMAKE_CURRENT_SOURCE_DIR}/platform)

  # Remove platform files so that specific platform files can be added later.
  # This is a bit weird, but it's simpler to include everything, remove all
  # platform files, then only include the platforms we need.
  file(GLOB_RECURSE all_platform_files ${platform_dir}/*)
  list(REMOVE_ITEM headers ${all_platform_files})
  list(REMOVE_ITEM sources ${all_platform_files})

  if(WIN32)
    file(GLOB platform_sources ${platform_dir}/MSWindows*.cpp)
    file(GLOB platform_headers ${platform_dir}/MSWindows*.h)
  elseif(APPLE)
    file(GLOB platform_sources ${platform_dir}/OSX*.cpp)
    file(GLOB platform_headers ${platform_dir}/OSX*.h)
  elseif(UNIX)
    file(GLOB platform_sources ${platform_dir}/XWindows*.cpp)
    file(GLOB platform_headers ${platform_dir}/XWindows*.h)
  endif()

  list(APPEND sources ${platform_sources})
  list(APPEND headers ${platform_headers})

endmacro()
```

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

### Link Libraries

Source: https://github.com/symless/synergy-core/blob/master/src/apps/deskflow-legacy/CMakeLists.txt

Links the main executable target against various internal libraries required by Deskflow. Ensure these libraries are correctly defined elsewhere in the build system.

```cmake
target_link_libraries(
  ${target}
  app
  arch
  base
  client
  io
  ipc
  mt
  net
  platform
  server
  ${libs})
```

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

### Replace Architecture Sources

Source: https://github.com/symless/synergy-core/blob/master/src/test/CMakeLists.txt

Filters out generic architecture files and replaces them with files specific to the current architecture (win32 or unix).

```cmake
macro(replace_arch_sources)

  set(arch_dir ${CMAKE_CURRENT_SOURCE_DIR}/arch)

  # Remove arch files so that specific arch files can be added later.
  # This is a bit weird, but it's simpler to include everything, remove all
  # arch files, then only include the archs we need.
  file(GLOB_RECURSE all_arch_files ${arch_dir}/*)
  list(REMOVE_ITEM headers ${all_arch_files})
  list(REMOVE_ITEM sources ${all_arch_files})

  if(WIN32)
    file(GLOB arch_sources ${arch_dir}/win32/*.cpp)
    file(GLOB arch_headers ${arch_dir}/win32/*.h)
  elseif(UNIX)
    file(GLOB arch_sources ${arch_dir}/unix/*.cpp)
    file(GLOB arch_headers ${arch_dir}/unix/*.h)
  endif()

  list(APPEND sources ${arch_sources})
  list(APPEND headers ${arch_headers})

endmacro()
```

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

### Set Target Name

Source: https://github.com/symless/synergy-core/blob/master/src/apps/deskflow-legacy/CMakeLists.txt

Sets the target name for the executable. This is typically the name of the application.

```cmake
set(target ${LEGACY_BINARY_NAME})
```

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

### Add Subdirectories

Source: https://github.com/symless/synergy-core/blob/master/CMakeLists.txt

Adds the 'synergy-extra' and 'src' subdirectories to the build. This allows CMake to process the CMakeLists.txt files within these directories, compiling the project's source code and external dependencies.

```cmake
add_subdirectory(${SYNERGY_EXTRA_ROOT})
add_subdirectory(src)
```

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

### Conditionally Add Headers to Sources

Source: https://github.com/symless/synergy-core/blob/master/src/lib/client/CMakeLists.txt

Appends header files to the list of source files if the ADD_HEADERS_TO_SOURCES variable is set. This can be useful for certain build configurations or tools that require all files to be listed.

```cmake
if(ADD_HEADERS_TO_SOURCES)
  list(APPEND sources ${headers})
endif()
```
Tokens:
Raw