IF(WIN32)

cmake_dependent_option (URHO3D_OPENGL "Use OpenGL instead of Direct3D (Windows platform only)" "${DEFAULT_OPENGL}" WIN32 TRUE)

if(WIN32)

elseif (WIN32)

cmake_dependent_option(F3D_WINDOWS_BUILD_CONSOLE_APPLICATION "Build a supplemental f3d-console application" OFF "WIN32" OFF)

else(WIN32)

cmake_dependent_option(OGRE_BUILD_RENDERSYSTEM_D3D9 "Build Direct3D9 RenderSystem" TRUE "WIN32;DirectX9_FOUND;NOT WINDOWS_STORE;NOT WINDOWS_PHONE" FALSE)

if(WIN32)

add_executable(${PROJECT_NAME} WIN32 ${SOURCE_FILES})

if(WIN32)

elseif(MESHLAB_ALLOW_DOWNLOAD_DLL_EMBREE AND WIN32)

elseif(WIN32)

if (WIN32)

add_executable(${GAME_EXE} WIN32 ${GAME_SOURCES})

ELSE(WIN32)

IF (CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64" AND NOT WIN32)

if(WIN32)

target_compile_definitions(${reader_libname}
        PRIVATE
            WIN32
            _HAS_AUTO_PTR_ETC=1
    )

if(alpaka_ACC_GPU_HIP_ENABLE AND (MSVC OR WIN32))

target_compile_definitions(BookStoreSample PRIVATE
    _MBCS
    WIN32
)

elseif(WIN32)

add_executable(h2cli WIN32 MACOSX_BUNDLE ${h2cli_SRCS} )

elseif(WIN32)

add_library(${PROJECT_NAME} MODULE
            oid_bridge.cpp
            ../debuggerinterface/python_native_interface.cpp
            ../system/process/process.cpp
            $<$<BOOL:${UNIX}>:../system/process/process_unix.cpp>
            $<$<BOOL:${WIN32}>:../system/process/process_win32.cpp>)

if(WIN32)

if(NOT WIN32)

cmake_dependent_option(GLFW_BUILD_WIN32 "Build support for Win32" ON "WIN32" OFF)

target_compile_definitions(gtest_no_maidsafe_log PRIVATE $<$<BOOL:${WIN32}>:MAIDSAFE_WIN32> $<$<BOOL:${MSVC}>:BOOST_ALL_NO_LIB>)

if(WIN32)

if(WIN32)

elseif(WIN32 AND NOT MINGW)

cmake_dependent_option(GLFW_USE_HYBRID_HPG "Force use of high-performance GPU on hybrid systems" OFF
                       "WIN32" OFF)

else(WIN32)

endif (WIN32)

elseif (WIN32)

cmake_dependent_option(GLFW_USE_HYBRID_HPG "Force use of high-performance GPU on hybrid systems" OFF
                       "WIN32" OFF)

else(NOT WIN32)

cmake_dependent_option(PARAVIEW_WINDOWS_PYTHON_DEBUGGABLE
    "Explicitly indicate that the Python library is debuggable" OFF
    "WIN32;PARAVIEW_USE_PYTHON" OFF)

endif(USE_SQLITE3_DB AND NOT HAS_WT_DBO_SQLITE3 AND NOT WIN32 AND NOT InterSpec_FETCH_DEPENDENCIES )

if(NOT M_LIBRARY AND NOT WIN32)

ADD_CUSTOM_TARGET(devDoc ALL ${CMAKE_COMMAND} -DSPHINX_EXECUTABLE=${SPHINX_EXECUTABLE}
                                              -c ${CMAKE_CURRENT_BINARY_DIR}
                                              -DSRC_DIR=${CMAKE_CURRENT_SOURCE_DIR}
                                              -DBIN_DIR=${CMAKE_CURRENT_BINARY_DIR}
                                              -DAPPLE=${APPLE} -DWIN32=${WIN32}
                                              -DCMAKE_LIBRARY_PATH=${CMAKE_LIBRARY_PATH_STR}
                                              -P ${CMAKE_CURRENT_SOURCE_DIR}/genSphinxDoc.cmake
                                              VERBATIM)

target_compile_definitions(${PROJECT_NAME} PRIVATE
        "$<$<CONFIG:Debug>:"
            "_DEBUG"
        ">"
        "$<$<CONFIG:Release>:"
            "NDEBUG"
        ">"
        "WIN32;"
        "_LIB;"
        "UNICODE;"
        "_UNICODE"
    )

elseif(WIN32 AND IS64)

if(APPLE OR WIN32)

cmake_dependent_option(USE_EXPLICIT_INSTANTIATION "Use explicit instantiation for all supported classes
and methods against a pre-defined list of OpenVDB trees. This makes the core library larger and slower
to compile, but speeds up the compilation of all dependent code by bypassing the expensive template
instantation." ON "NOT WIN32" OFF)

elseif (WIN32)

else(WIN32)

ENDIF (NOT WIN32)

if(WIN32)

list(APPEND CEF_COMPILER_DEFINES
    WIN32 _WIN32 _WINDOWS             # Windows platform
    UNICODE _UNICODE                  # Unicode build
    WINVER=0x0601 _WIN32_WINNT=0x601  # Targeting Windows 7
    NOMINMAX                          # Use the standard's templated min/max
    WIN32_LEAN_AND_MEAN               # Exclude less common API declarations
    _HAS_EXCEPTIONS=0                 # Disable exceptions
    )

elseif (WIN32 AND NOT HAS_HASH_EMBED)

target_compile_definitions(fc PUBLIC WIN32 NOMINMAX _WIN32_WINNT=0x0501 _CRT_SECURE_NO_WARNINGS
    _SCL_SERCURE_NO_WARNINGS
    # Needed to disable MSVC autolinking feature (#pragma comment)
    BOOST_ALL_NO_LIB
    # The current version of websockets doesn't correctly guess what 'chrono' implementation boost::asio uses
    # on the recommended build platform of VC++12/boost_1.58.  Force it here until websocket gets their
    # autodetecting code to do the right thing.
    _WEBSOCKETPP_CPP11_CHRONO_
  )

elseif(WIN32)

if(WIN32)

check_cxx_source_compiles("
    #include <windows.h>

    #ifndef _M_IX86
        #error Not WIN32
    #endif

    int main()
    {
        return 0;
    }" IS_WIN32_TARGET)

cmake_dependent_option(GLFW_BUILD_WIN32 "Build support for Win32" ON "WIN32" OFF)

ELSEIF(WIN32)

elseif(WIN32)

add_compile_definitions(
			WIN32
			__GNUWIN32__
			_CRT_SECURE_NO_DEPRECATE
			NOMINMAX
		)

IF(WIN32)

list(APPEND CEF_COMPILER_DEFINES
    WIN32 _WIN32 _WINDOWS             # Windows platform
    UNICODE _UNICODE                  # Unicode build
    WINVER=0x0601 _WIN32_WINNT=0x601  # Targeting Windows 7
    NOMINMAX                          # Use the standard's templated min/max
    WIN32_LEAN_AND_MEAN               # Exclude less common API declarations
    _HAS_EXCEPTIONS=0                 # Disable exceptions
    )

CMAKE_DEPENDENT_OPTION(BUILD_JAVASCRIPT "Build Javascript library" ON
                       "BUILD_LIBRARIES;WITH_JAVASCRIPT;NOT WIN32; NOT CYGWIN" OFF)

CMAKE_DEPENDENT_OPTION(BUILD_JAVASCRIPT "Build Javascript library" ON
                       "BUILD_LIBRARIES;WITH_JAVASCRIPT;NOT WIN32; NOT CYGWIN" OFF)

elseif (WIN32)

target_sources(gfxrecon_application
               PRIVATE
                    ${CMAKE_CURRENT_LIST_DIR}/application.h
                    ${CMAKE_CURRENT_LIST_DIR}/application.cpp
                    ${CMAKE_CURRENT_LIST_DIR}/wsi_context.h
                    ${CMAKE_CURRENT_LIST_DIR}/wsi_context.cpp
                    $<$<BOOL:${HEADLESS}>:${CMAKE_CURRENT_LIST_DIR}/headless_context.h>
                    $<$<BOOL:${HEADLESS}>:${CMAKE_CURRENT_LIST_DIR}/headless_window.h>
                    $<$<BOOL:${HEADLESS}>:${CMAKE_CURRENT_LIST_DIR}/headless_context.cpp>
                    $<$<BOOL:${HEADLESS}>:${CMAKE_CURRENT_LIST_DIR}/headless_window.cpp>
                    $<$<BOOL:${BUILD_WSI_DISPLAY_SUPPORT}>:${CMAKE_CURRENT_LIST_DIR}/display_context.h>
                    $<$<BOOL:${BUILD_WSI_DISPLAY_SUPPORT}>:${CMAKE_CURRENT_LIST_DIR}/display_window.h>
                    $<$<BOOL:${BUILD_WSI_DISPLAY_SUPPORT}>:${CMAKE_CURRENT_LIST_DIR}/display_context.cpp>
                    $<$<BOOL:${BUILD_WSI_DISPLAY_SUPPORT}>:${CMAKE_CURRENT_LIST_DIR}/display_window.cpp>
                    $<$<BOOL:${XCB_FOUND}>:${CMAKE_CURRENT_LIST_DIR}/xcb_context.h>
                    $<$<BOOL:${XCB_FOUND}>:${CMAKE_CURRENT_LIST_DIR}/xcb_window.h>
                    $<$<BOOL:${XCB_FOUND}>:${CMAKE_CURRENT_LIST_DIR}/xcb_context.cpp>
                    $<$<BOOL:${XCB_FOUND}>:${CMAKE_CURRENT_LIST_DIR}/xcb_window.cpp>
                    $<$<BOOL:${X11_FOUND}>:${CMAKE_CURRENT_LIST_DIR}/xlib_context.h>
                    $<$<BOOL:${X11_FOUND}>:${CMAKE_CURRENT_LIST_DIR}/xlib_window.h>
                    $<$<BOOL:${X11_FOUND}>:${CMAKE_CURRENT_LIST_DIR}/xlib_context.cpp>
                    $<$<BOOL:${X11_FOUND}>:${CMAKE_CURRENT_LIST_DIR}/xlib_window.cpp>
                    $<$<BOOL:${WAYLAND_FOUND}>:${CMAKE_CURRENT_LIST_DIR}/wayland_context.h>
                    $<$<BOOL:${WAYLAND_FOUND}>:${CMAKE_CURRENT_LIST_DIR}/wayland_window.h>
                    $<$<BOOL:${WAYLAND_FOUND}>:${CMAKE_CURRENT_LIST_DIR}/wayland_context.cpp>
                    $<$<BOOL:${WAYLAND_FOUND}>:${CMAKE_CURRENT_LIST_DIR}/wayland_window.cpp>
                    $<$<BOOL:${WIN32}>:${CMAKE_CURRENT_LIST_DIR}/win32_context.h>
                    $<$<BOOL:${WIN32}>:${CMAKE_CURRENT_LIST_DIR}/win32_window.h>
                    $<$<BOOL:${WIN32}>:${CMAKE_CURRENT_LIST_DIR}/win32_context.cpp>
                    $<$<BOOL:${WIN32}>:${CMAKE_CURRENT_LIST_DIR}/win32_window.cpp>
                    $<$<BOOL:${APPLE}>:${CMAKE_CURRENT_LIST_DIR}/metal_context.h>
                    $<$<BOOL:${APPLE}>:${CMAKE_CURRENT_LIST_DIR}/metal_window.h>
                    $<$<BOOL:${APPLE}>:${CMAKE_CURRENT_LIST_DIR}/metal_context.mm>
                    $<$<BOOL:${APPLE}>:${CMAKE_CURRENT_LIST_DIR}/metal_window.mm>
              )

add_executable(OpenGLSimpleShadowmap WIN32 ${SRC_FOR_EXCUTABLE} )

cmake_dependent_option(DIRECTX_SUPPORT "DirectX 12 support" ON "WIN32" OFF)

elseif(WIN32)

if(WIN32)

cmake_parse_arguments (PARSE_ARGV 1 _PGN "POSIX;INTERPRETER;COMPILER;CONFIG;LIBRARY;WIN32;DEBUG" "" "IMPLEMENTATIONS;VERSION")

if (WIN32)

if(WIN32)

if(WIN32)

elseif( WIN32 )

cmake_dependent_option(GLFW_USE_HYBRID_HPG "Force use of high-performance GPU on hybrid systems" OFF
                       "WIN32" OFF)

if( WIN32 AND NOT CYGWIN )

cmake_dependent_option( KICAD_WIN32_DPI_AWARE
    "Turn on DPI awareness for Windows builds only"
    OFF "WIN32"
    OFF )

if (WIN32)

elseif (WIN32)

cmake_dependent_option(
  BATTERY
  "Battery meter support"
  ON
  "WIN32 OR UNIX"
  OFF
)

elseif(WIN32)

target_compile_options(${PROJECT_NAME} INTERFACE
    $<$<OR:$<BOOL:${CLANG}>,$<CXX_COMPILER_ID:GNU>>:
        -fno-common;
        -fstrict-overflow;
        -ftrapv;
        -pedantic-errors;
        -Wall;
        -Wcast-align;
        -Wdouble-promotion;
        -Wextra;
        -Wformat=2;
        -Wmissing-declarations;
        -Wnon-virtual-dtor;
        -Wnull-dereference;
        -Wold-style-cast;
        -Woverloaded-virtual;
        -Wshadow;
        -Wsign-compare;
        -Wundef;
    >
    $<$<CXX_COMPILER_ID:GNU>:
        -Wduplicated-cond;
        -Wlogical-op;
    >
    $<$<BOOL:${CLANG}>:
        -Wmissing-variable-declarations;
        -Wno-gnu-zero-variadic-macro-arguments; # Required for gtest 1.10.
    >
    $<$<OR:$<BOOL:${CLANGCL}>,$<CXX_COMPILER_ID:MSVC>>:
        /permissive-;
        /W4;
        /w14254; # 'operator': conversion from 'type1:field_bits' to
                 # 'type2:field_bits', possible loss of data
        /w14263; # 'function': member function does not override any base class
                 # virtual member function
        /w14265; # 'classname': class has virtual functions, but destructor is not
                 # virtual instances of this class may not be destructed correctly
        /w14287; # 'operator': unsigned/negative constant mismatch
        /w14289; # nonstandard extension used: 'variable': loop control variable
                 # declared in the for-loop is used outside the for-loop scope
        /w14296; # 'operator': expression is always 'boolean_value'
        /w14311; # 'variable': pointer truncation from 'type1' to 'type2'
        /w14545; # expression before comma evaluates to a function which is missing
                 # an argument list
        /w14546; # function call before comma missing argument list
        /w14547; # 'operator': operator before comma has no effect; expected
                 # operator with side-effect
        /w14549; # 'operator': operator before comma has no effect; did you intend
                 # 'operator'?
        /w14555; # expression has no effect; expected expression with side- effect
        /w14619; # pragma warning: there is no warning number 'number'
        /w14640; # Enable warning on thread un-safe static member initialization
        /w14826; # Conversion from 'type1' to 'type_2' is sign-extended. This may
                 # cause unexpected runtime behavior.
        /w14928; # illegal copy-initialization; more than one user-defined
                 # conversion has been implicitly applied
        /wd4244; # 'argument': conversion from 'int' to 'unsigned char', possible
                 # loss of data # This one is sort of required for gtest.
        /WX;
    >
    $<$<BOOL:${STRICT_OPTIONS}>:
        -Werror;
    >
    $<$<BOOL:${COMPILER_SUPPORTS_WARNING_WEAK_VTABLES}>:
        -Wweak-vtables; # https://llvm.org/docs/CodingStandards.html#provide-a-virtual-method-anchor-for-classes-in-headers
    >
    $<$<BOOL:${COMPILER_SUPPORTS_WDATE_TIME}>:
        -Wdate-time; # avoid timestamps in binary for reproducible builds, not added until GCC 4.9
    >
    $<$<AND:$<NOT:$<BOOL:${WIN32}>>,$<NOT:$<BOOL:${HAIKU}>>>:
        -Wstack-protector;
    >
)

if(WIN32 AND NOT MSVC)

target_link_libraries(strawberry_lib PUBLIC
  ${CMAKE_THREAD_LIBS_INIT}
  $<$<BOOL:${HAVE_BACKTRACE}>:${Backtrace_LIBRARIES}>
  PkgConfig::GLIB
  PkgConfig::GOBJECT
  PkgConfig::SQLITE
  PkgConfig::GSTREAMER
  PkgConfig::GSTREAMER_BASE
  PkgConfig::GSTREAMER_AUDIO
  PkgConfig::GSTREAMER_APP
  PkgConfig::GSTREAMER_TAG
  PkgConfig::GSTREAMER_PBUTILS
  ${TAGLIB_LIBRARIES}
  Qt${QT_VERSION_MAJOR}::Core
  Qt${QT_VERSION_MAJOR}::Concurrent
  Qt${QT_VERSION_MAJOR}::Gui
  Qt${QT_VERSION_MAJOR}::Widgets
  Qt${QT_VERSION_MAJOR}::Network
  Qt${QT_VERSION_MAJOR}::Sql
  $<$<BOOL:${HAVE_DBUS}>:Qt${QT_VERSION_MAJOR}::DBus>
  $<$<BOOL:${HAVE_QPA_QPLATFORMNATIVEINTERFACE}>:Qt${QT_VERSION_MAJOR}::GuiPrivate>
  ICU::uc
  ICU::i18n
  $<$<BOOL:${HAVE_STREAMTAGREADER}>:PkgConfig::LIBSPARSEHASH>
  $<$<BOOL:${HAVE_ALSA}>:ALSA::ALSA>
  $<$<BOOL:${HAVE_PULSE}>:PkgConfig::LIBPULSE>
  $<$<BOOL:${HAVE_CHROMAPRINT}>:PkgConfig::CHROMAPRINT>
  $<$<BOOL:${HAVE_MOODBAR}>:PkgConfig::FFTW3>
  $<$<BOOL:${HAVE_EBUR128}>:PkgConfig::LIBEBUR128>
  $<$<BOOL:${HAVE_X11_GLOBALSHORTCUTS}>:X11::X11_xcb>
  $<$<BOOL:${HAVE_GIO}>:PkgConfig::GIO>
  $<$<BOOL:${HAVE_GIO_UNIX}>:PkgConfig::GIO_UNIX>
  $<$<BOOL:${HAVE_AUDIOCD}>:PkgConfig::LIBCDIO>
  $<$<BOOL:${HAVE_MTP}>:PkgConfig::LIBMTP>
  $<$<BOOL:${HAVE_GPOD}>:PkgConfig::LIBGPOD PkgConfig::GDK_PIXBUF>
  $<$<BOOL:${HAVE_QTSPARKLE}>:qtsparkle-qt${QT_VERSION_MAJOR}::qtsparkle>
  $<$<BOOL:${WIN32}>:dsound dwmapi ${GETOPT_LIBRARIES}>
  $<$<BOOL:${MSVC}>:WindowsApp>
  KDAB::kdsingleapplication
  $<$<BOOL:${HAVE_DISCORD_RPC}>:discord-rpc>
)

target_compile_definitions(
  maxmsp_commonsyms
  PRIVATE
    AVND_MAXMSP=1
    $<$<BOOL:${WIN32}>:MAXAPI_USE_MSCRT=1>
    C74_USE_STRICT_TYPES=1
)

if(WIN32)

CMAKE_DEPENDENT_OPTION(USE_CRYPTO_OPENSSL "Use OpenSSL instead of MbedTLS for cryptography in STK." ON
    "NOT USE_SWITCH;NOT WIN32" OFF)

add_executable(test_interface_exe WIN32 main.cpp mainwindow.cpp)

elseif(NOT (WIN32 OR CYGWIN))

if(WIN32)

cmake_dependent_option(GLFW_USE_HYBRID_HPG "Force use of high-performance GPU on hybrid systems" OFF
                       "WIN32" OFF)

add_executable(${TargetName} WIN32
    ${Sources}
    ${platform_specific_resources}
    
)

IF (WIN32)

cmake_dependent_option(URHO3D_XR                 "Enable OpenXR support"                                 ${URHO3D_ENABLE_ALL} "WIN32 OR URHO3D_OCULUS_QUEST;NOT MINGW;NOT UWP" OFF)

if(WIN32)

CMAKE_DEPENDENT_OPTION( VXL_FORCE_V3P_J2K "Use V3P instead of any native JPEG2000 library? (WIN32 only)" OFF
    "VXL_BUILD_CORE_IMAGING" OFF)

add_executable(timeout WIN32 MACOSX_BUNDLE timeout.c ${GLAD})

if(WIN32 AND NOT USERFILE_REMOTE_MACHINE)

if(WIN32)

if(WIN32)