Fix up minimal dependency case and clang support.

This commit is contained in:
James Grogan 2022-11-30 15:28:15 +00:00
parent 925f0c3ccd
commit 1adc9272f8
17 changed files with 183 additions and 226 deletions

View file

@ -1,3 +1,7 @@
set(APP_NAME sample_gui)
message(STATUS "Checking dependencies for app: " ${APP_NAME})
list(APPEND client_HEADERS list(APPEND client_HEADERS
MediaTool.h MediaTool.h
text_editor/TextEditorView.h text_editor/TextEditorView.h
@ -31,18 +35,22 @@ list(APPEND client_LIB_INCLUDES
web_client/WebClientView.cpp web_client/WebClientView.cpp
MediaTool.cpp) MediaTool.cpp)
set(DEPENDENCIES_FOUND True)
if(WIN32) if(WIN32)
add_executable(sample_gui WIN32 gui-main-win.cpp ${client_LIB_INCLUDES}) add_executable(${APP_NAME} WIN32 gui-main-win.cpp ${client_LIB_INCLUDES})
else() else()
find_package(X11 QUIET) find_package(X11 QUIET)
if(X11_FOUND) if(X11_FOUND)
add_executable(sample_gui gui-main.cpp ${client_LIB_INCLUDES} ${client_HEADERS}) add_executable(${APP_NAME} gui-main.cpp ${client_LIB_INCLUDES} ${client_HEADERS})
else() else()
message(STATUS "Skipping sample GUI as no X11 dev support") message(STATUS "X11 not found - skipping")
set(DEPENDENCIES_FOUND FALSE)
endif() endif()
endif() endif()
target_include_directories(sample_gui PUBLIC
if(DEPENDENCIES_FOUND)
target_include_directories(${APP_NAME} PUBLIC
"${CMAKE_CURRENT_SOURCE_DIR}/text_editor" "${CMAKE_CURRENT_SOURCE_DIR}/text_editor"
"${CMAKE_CURRENT_SOURCE_DIR}/audio_editor" "${CMAKE_CURRENT_SOURCE_DIR}/audio_editor"
"${CMAKE_CURRENT_SOURCE_DIR}/image_editor" "${CMAKE_CURRENT_SOURCE_DIR}/image_editor"
@ -50,7 +58,7 @@ target_include_directories(sample_gui PUBLIC
"${CMAKE_CURRENT_SOURCE_DIR}/canvas" "${CMAKE_CURRENT_SOURCE_DIR}/canvas"
"${CMAKE_CURRENT_SOURCE_DIR}/mesh_viewer" "${CMAKE_CURRENT_SOURCE_DIR}/mesh_viewer"
) )
target_link_libraries(sample_gui PUBLIC client windows console core network database geometry audio web) target_link_libraries(${APP_NAME} PUBLIC client windows console core network database geometry audio web)
set_property(TARGET sample_gui PROPERTY FOLDER apps) set_property(TARGET ${APP_NAME} PROPERTY FOLDER apps)
endif()

View file

@ -1,7 +1,11 @@
#include "AudioManager.h" #include "AudioManager.h"
#ifdef __linux__ #ifdef __linux__
#ifdef HAS_ALSA
#include "AlsaInterface.h" #include "AlsaInterface.h"
#else
#include "NullAudioInterface.h"
#endif
#endif #endif
AudioManager::AudioManager() AudioManager::AudioManager()
@ -9,7 +13,11 @@ AudioManager::AudioManager()
mAudioInterface() mAudioInterface()
{ {
#ifdef __linux__ #ifdef __linux__
#ifdef HAS_ALSA
mAudioInterface = AlsaInterface::Create(); mAudioInterface = AlsaInterface::Create();
#else
mAudioInterface = NullAudioInterface::Create();
#endif
#endif #endif
} }

View file

@ -1,38 +1,38 @@
set(MODULE_NAME audio)
set(platform_HEADERS "") message(STATUS "Checking dependencies for module: " ${MODULE_NAME})
set(platform_INCLUDES "")
if (UNIX) if (UNIX)
find_package(ALSA QUIET) find_package(ALSA QUIET)
if(ALSA_FOUND) if(ALSA_FOUND)
list(APPEND platform_HEADERS list(APPEND PLATFORM_HEADERS
audio_interfaces/AlsaInterface.h audio_interfaces/AlsaInterface.h
${ALSA_INCLUDE_DIRS}) ${ALSA_INCLUDE_DIRS})
list(APPEND platform_INCLUDES list(APPEND PLATFORM_SOURCES
audio_interfaces/AlsaInterface.cpp audio_interfaces/AlsaInterface.cpp
) )
list(APPEND platform_LIBS list(APPEND PLATFORM_LIBS
${ALSA_LIBRARIES} ${ALSA_LIBRARIES}
) )
list(APPEND DEFINES "HAS_ALSA")
else() else()
message(STATUS "ALSA package not found - not building audio interface.") message(STATUS "ALSA not found - skipping support")
list(APPEND platform_HEADERS list(APPEND PLATFORM_HEADERS
audio_interfaces/NullAudioInterface.h audio_interfaces/NullAudioInterface.h
) )
list(APPEND platform_INCLUDES list(APPEND PLATFORM_SOURCES
audio_interfaces/NullAudioInterface.cpp audio_interfaces/NullAudioInterface.cpp
) )
endif() endif()
else() else()
list(APPEND platform_HEADERS list(APPEND PLATFORM_HEADERS
audio_interfaces/WasapiInterface.h audio_interfaces/WasapiInterface.h
) )
list(APPEND platform_INCLUDES list(APPEND PLATFORM_SOURCES
audio_interfaces/WasapiInterface.cpp audio_interfaces/WasapiInterface.cpp
) )
endif (UNIX) endif (UNIX)
list(APPEND audio_HEADERS list(APPEND TARGET_HEADERS
AudioDevice.h AudioDevice.h
AudioManager.h AudioManager.h
AudioTrack.h AudioTrack.h
@ -47,9 +47,9 @@ list(APPEND audio_HEADERS
midi/MidiEvent.h midi/MidiEvent.h
midi/MetaMidiEvent.h midi/MetaMidiEvent.h
midi/MidiChannelEvent.h midi/MidiChannelEvent.h
${platform_HEADERS}) ${PLATFORM_HEADERS})
list(APPEND audio_LIB_INCLUDES list(APPEND TARGET_SOURCES
AudioDevice.cpp AudioDevice.cpp
AudioManager.cpp AudioManager.cpp
AudioSample.cpp AudioSample.cpp
@ -65,16 +65,17 @@ list(APPEND audio_LIB_INCLUDES
midi/MidiEvent.cpp midi/MidiEvent.cpp
midi/MetaMidiEvent.cpp midi/MetaMidiEvent.cpp
midi/MidiChannelEvent.cpp midi/MidiChannelEvent.cpp
${platform_INCLUDES}) ${PLATFORM_SOURCES})
add_library(audio SHARED ${audio_LIB_INCLUDES} ${platform_INCLUDES} ${audio_HEADERS} ${platform_HEADERS}) add_library(${MODULE_NAME} SHARED ${TARGET_HEADERS} ${TARGET_SOURCES})
target_include_directories(audio PUBLIC target_include_directories(${MODULE_NAME} PUBLIC
"${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}"
"${CMAKE_CURRENT_SOURCE_DIR}/audio_interfaces" "${CMAKE_CURRENT_SOURCE_DIR}/audio_interfaces"
"${CMAKE_CURRENT_SOURCE_DIR}/midi" "${CMAKE_CURRENT_SOURCE_DIR}/midi"
"${CMAKE_CURRENT_SOURCE_DIR}/midi/reader" "${CMAKE_CURRENT_SOURCE_DIR}/midi/reader"
) )
target_link_libraries(audio PUBLIC core ${platform_LIBS}) target_compile_definitions(${MODULE_NAME} PRIVATE ${DEFINES})
set_target_properties( audio PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON ) target_link_libraries(${MODULE_NAME} PUBLIC core ${PLATFORM_LIBS})
set_property(TARGET audio PROPERTY FOLDER src) set_target_properties(${MODULE_NAME} PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON)
set_property(TARGET ${MODULE_NAME} PROPERTY FOLDER src)

View file

@ -1,141 +1,31 @@
#include "AlsaInterface.h" #include "NullAudioInterface.h"
#include "FileLogger.h" #include "FileLogger.h"
#include "AudioSynth.h" #include "AudioSynth.h"
#include <vector> #include <vector>
AlsaInterface::AlsaInterface() NullAudioInterface::NullAudioInterface()
:mHandle(),
mHardwareParams(),
mPeriodSize(8192)
{ {
} }
AlsaInterface::~AlsaInterface() NullAudioInterface::~NullAudioInterface()
{ {
} }
std::unique_ptr<AlsaInterface> AlsaInterface::Create() std::unique_ptr<NullAudioInterface> NullAudioInterface::Create()
{ {
return std::make_unique<AlsaInterface>(); return std::make_unique<NullAudioInterface>();
} }
void AlsaInterface::OpenDevice(const AudioDevicePtr& device) void NullAudioInterface::OpenDevice(const AudioDevicePtr& device)
{ {
MLOG_INFO("Opening Device");
snd_pcm_stream_t stream = SND_PCM_STREAM_PLAYBACK;
if (snd_pcm_open(&mHandle, device->GetName().c_str(), stream, 0) < 0)
{
MLOG_ERROR("Error opening PCM device: " + device->GetName());
return;
}
snd_pcm_hw_params_alloca(&mHardwareParams);
if (snd_pcm_hw_params_any(mHandle, mHardwareParams) < 0)
{
MLOG_ERROR("Can not configure this PCM device.");
return;
}
SetAccessType(device);
SetSampleFormat(device);
SetSampleRate(device);
SetPeriod(device);
SetBufferSize(device);
SetChannelNumber(device);
/* Apply HW parameter settings to */
/* PCM device and prepare device */
if (snd_pcm_hw_params(mHandle, mHardwareParams) < 0) {
MLOG_ERROR("Error setting HW params.");
return;
}
} }
void AlsaInterface::SetAccessType(const AudioDevicePtr& device) void NullAudioInterface::Play(const AudioDevicePtr& device)
{ {
if (snd_pcm_hw_params_set_access(mHandle, mHardwareParams, SND_PCM_ACCESS_RW_INTERLEAVED) < 0) {
MLOG_ERROR("Error setting device access.");
return;
}
}
void AlsaInterface::SetSampleFormat(const AudioDevicePtr& device)
{
/* Set sample format */
if (snd_pcm_hw_params_set_format(mHandle, mHardwareParams, SND_PCM_FORMAT_S16_LE) < 0) {
MLOG_ERROR("Error setting format. ");
return;
}
}
void AlsaInterface::SetSampleRate(const AudioDevicePtr& device)
{
unsigned rate = device->GetSampleRate();
unsigned exact_rate = rate;
if (snd_pcm_hw_params_set_rate_near(mHandle, mHardwareParams, &exact_rate, 0) < 0)
{
MLOG_ERROR("Error setting rate. ");
return;
}
if (rate != exact_rate) {
MLOG_ERROR("The rate is not supported by your hardware.");
}
}
void AlsaInterface::SetPeriod(const AudioDevicePtr& device)
{
/* Set number of periods. Periods used to be called fragments. */
if (snd_pcm_hw_params_set_periods(mHandle, mHardwareParams, device->GetPeriod(), 0) < 0)
{
MLOG_ERROR("Error setting periods. ");
return;
}
}
void AlsaInterface::SetBufferSize(const AudioDevicePtr& device)
{
int periods = static_cast<int>(device->GetPeriod());
/* Set buffer size (in frames). The resulting latency is given by */
/* latency = periodsize * periods / (rate * bytes_per_frame) */
if (snd_pcm_hw_params_set_buffer_size(mHandle, mHardwareParams, (mPeriodSize * periods)>>2) < 0)
{
MLOG_ERROR("Error setting buffersize. ");
return;
}
}
void AlsaInterface::SetChannelNumber(const AudioDevicePtr& device)
{
/* Set number of channels */
if (snd_pcm_hw_params_set_channels(mHandle, mHardwareParams, device->GetNumChannels()) < 0)
{
MLOG_ERROR("Error setting channels");
return;
}
}
void AlsaInterface::Play(const AudioDevicePtr& device)
{
MLOG_INFO("Playing audio");
AudioSynth synth;
const unsigned duration = 100;
double freq = 440;
auto data = synth.GetSineWave(freq, duration)->GetChannelData(0);
int numFrames = mPeriodSize >> 2;
for(int count = 0; count < duration; count++)
{
const auto offset= count*4*numFrames;
unsigned char frame[4] = {data[offset], data[offset+1], data[offset+2], data[offset+3]};
while ((snd_pcm_writei(mHandle, frame, numFrames)) < 0)
{
snd_pcm_prepare(mHandle);
MLOG_ERROR("<<<<<<<<<<<<<<< Buffer Underrun >>>>>>>>>>>>>>>");
}
}
} }

View file

@ -4,37 +4,21 @@
#include "AudioDevice.h" #include "AudioDevice.h"
#include <memory> #include <memory>
#include <alsa/asoundlib.h>
class AlsaInterface : public IAudioInterface class NullAudioInterface : public IAudioInterface
{ {
snd_pcm_t* mHandle;
snd_pcm_hw_params_t* mHardwareParams;
snd_pcm_uframes_t mPeriodSize;
public: public:
AlsaInterface(); NullAudioInterface();
~AlsaInterface(); ~NullAudioInterface();
static std::unique_ptr<AlsaInterface> Create(); static std::unique_ptr<NullAudioInterface> Create();
void OpenDevice(const AudioDevicePtr& device) override; void OpenDevice(const AudioDevicePtr& device) override;
void SetAccessType(const AudioDevicePtr& device);
void SetSampleFormat(const AudioDevicePtr& device);
void SetSampleRate(const AudioDevicePtr& device);
void SetPeriod(const AudioDevicePtr& device);
void SetBufferSize(const AudioDevicePtr& device);
void SetChannelNumber(const AudioDevicePtr& device);
void Play(const AudioDevicePtr& device) override; void Play(const AudioDevicePtr& device) override;
}; };
using AlsaInterfacePtr = std::shared_ptr<AlsaInterface>; using NullAudioInterfacePtr = std::shared_ptr<NullAudioInterface>;

View file

@ -1,25 +1,27 @@
list(APPEND client_HEADERS set(MODULE_NAME client)
list(APPEND TARGET_HEADERS
TopBar.h TopBar.h
StatusBar.h StatusBar.h
GuiApplication.h GuiApplication.h
TabbedPanelWidget.h) TabbedPanelWidget.h)
list(APPEND client_LIB_INCLUDES list(APPEND TARGET_SOURCES
TopBar.cpp TopBar.cpp
StatusBar.cpp StatusBar.cpp
GuiApplication.cpp GuiApplication.cpp
TabbedPanelWidget.cpp) TabbedPanelWidget.cpp)
add_library(client SHARED ${client_LIB_INCLUDES} ${client_HEADERS}) add_library(${MODULE_NAME} SHARED ${TARGET_SOURCES} ${TARGET_HEADERS})
target_link_libraries(client ui_elements windows core console database geometry) target_link_libraries(${MODULE_NAME} ui_elements windows core console database geometry)
target_include_directories(client PUBLIC target_include_directories(${MODULE_NAME} PUBLIC
"${CMAKE_CURRENT_SOURCE_DIR}" ${CMAKE_CURRENT_SOURCE_DIR}
"${CMAKE_CURRENT_SOURCE_DIR}/text_editor" ${CMAKE_CURRENT_SOURCE_DIR}/text_editor
"${CMAKE_CURRENT_SOURCE_DIR}/audio_editor" ${CMAKE_CURRENT_SOURCE_DIR}/audio_editor
"${CMAKE_CURRENT_SOURCE_DIR}/image_editor" ${CMAKE_CURRENT_SOURCE_DIR}/image_editor
"${CMAKE_CURRENT_SOURCE_DIR}/web_client" ${CMAKE_CURRENT_SOURCE_DIR}/web_client
) )
set_property(TARGET client PROPERTY FOLDER src) set_property(TARGET ${MODULE_NAME} PROPERTY FOLDER src)
set_target_properties( client PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON ) set_target_properties( ${MODULE_NAME} PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON )

View file

@ -1,24 +1,25 @@
list(APPEND compiler_HEADERS set(MODULE_NAME compiler)
list(APPEND TARGET_HEADERS
Lexer.h Lexer.h
TemplatingEngine.h TemplatingEngine.h
TemplateFile.h TemplateFile.h
TemplateNodes.h TemplateNodes.h
) )
list(APPEND compiler_LIB_INCLUDES list(APPEND TARGET_SOURCES
Lexer.cpp Lexer.cpp
TemplatingEngine.cpp TemplatingEngine.cpp
TemplateFile.cpp TemplateFile.cpp
TemplateNodes.cpp TemplateNodes.cpp
) )
add_library(compiler SHARED ${compiler_LIB_INCLUDES} ${compiler_HEADERS}) add_library(${MODULE_NAME} SHARED ${TARGET_SOURCES} ${TARGET_HEADERS})
target_include_directories(compiler PUBLIC target_include_directories(${MODULE_NAME} PUBLIC
"${CMAKE_CURRENT_SOURCE_DIR}" ${CMAKE_CURRENT_SOURCE_DIR}
) )
set_target_properties( compiler PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON ) target_link_libraries( ${MODULE_NAME} PUBLIC core)
target_link_libraries( compiler PUBLIC core) set_target_properties( ${MODULE_NAME} PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON )
set_property(TARGET ${MODULE_NAME} PROPERTY FOLDER src)
set_property(TARGET compiler PROPERTY FOLDER src)

View file

@ -1,3 +1,5 @@
set(MODULE_NAME fonts)
message(STATUS "Checking dependencies for module: " ${MODULE_NAME})
set(fonts_LIB_DEPENDS "") set(fonts_LIB_DEPENDS "")
@ -18,17 +20,20 @@ if(UNIX)
list(APPEND fonts_LIB_DEPENDS list(APPEND fonts_LIB_DEPENDS
Freetype::Freetype Freetype::Freetype
) )
list(APPEND DEFINES "HAS_FREETYPE")
else() else()
message(STATUS "Did not find freetype - skipping font engine") message(STATUS "Freetype not found - skipping support")
endif() endif()
endif() endif()
add_library(fonts SHARED ${fonts_LIB_INCLUDES}) add_library(${MODULE_NAME} SHARED ${fonts_LIB_INCLUDES})
target_include_directories(fonts PUBLIC target_include_directories(${MODULE_NAME} PUBLIC
"${CMAKE_CURRENT_SOURCE_DIR}" ${CMAKE_CURRENT_SOURCE_DIR}
) )
target_link_libraries(fonts PUBLIC core image ${fonts_LIB_DEPENDS}) target_link_libraries(${MODULE_NAME} PUBLIC core image ${fonts_LIB_DEPENDS})
set_property(TARGET fonts PROPERTY FOLDER src)
set_target_properties( fonts PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON ) target_compile_definitions(${MODULE_NAME} PRIVATE ${DEFINES})
set_property(TARGET ${MODULE_NAME} PROPERTY FOLDER src)
set_target_properties( ${MODULE_NAME} PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON )

View file

@ -1,12 +1,19 @@
#include "FontsManager.h" #include "FontsManager.h"
#ifdef HAS_FREETYPE
#include "FreeTypeFontEngine.h" #include "FreeTypeFontEngine.h"
#else
#include "BasicFontEngine.h" #include "BasicFontEngine.h"
#endif
FontsManager::FontsManager() FontsManager::FontsManager()
: mFontEngine(std::make_unique<FreeTypeFontEngine>())
{ {
#ifdef HAS_FREETYPE
mFontEngine = std::make_unique<FreeTypeFontEngine>();
#else
mFontEngine = std::make_unique<BasicFontEngine>();
#endif
mFontEngine->initialize(); mFontEngine->initialize();
} }

View file

@ -1,3 +1,7 @@
set(MODULE_NAME graphics)
message(STATUS "Checking dependencies for module: " ${MODULE_NAME})
set(platform_LIB_INCLUDES "") set(platform_LIB_INCLUDES "")
set(platform_INCLUDE_DIRS "") set(platform_INCLUDE_DIRS "")
set(platform_HEADERS "") set(platform_HEADERS "")
@ -28,27 +32,29 @@ if (OpenGL_FOUND)
opengl/OpenGlFontTexture.cpp opengl/OpenGlFontTexture.cpp
opengl/OpenGlShaderProgram.cpp opengl/OpenGlShaderProgram.cpp
) )
list(APPEND graphics_HEADERS list(APPEND ${MODULE_NAME}
opengl/OpenGlPainter.h opengl/OpenGlPainter.h
opengl/OpenGlTextPainter.h opengl/OpenGlTextPainter.h
opengl/OpenGlMeshPainter.h opengl/OpenGlMeshPainter.h
opengl/OpenGlFontTexture.h opengl/OpenGlFontTexture.h
opengl/OpenGlShaderProgram.h) opengl/OpenGlShaderProgram.h)
list(APPEND DEFINES "HAS_OPENGL")
else() else()
message(STATUS "OpenGL headers not found - skipping OpenGL support") message(STATUS "OpenGL not found - skipping support")
endif() endif()
add_library(graphics SHARED add_library(${MODULE_NAME} SHARED
${graphics_LIB_INCLUDES} ${graphics_LIB_INCLUDES}
${graphics_HEADERS}) ${graphics_HEADERS})
target_include_directories(graphics PUBLIC target_include_directories(${MODULE_NAME} PUBLIC
${platform_INCLUDE_DIRS} ${platform_INCLUDE_DIRS}
"${CMAKE_CURRENT_SOURCE_DIR}" ${CMAKE_CURRENT_SOURCE_DIR}
"${CMAKE_CURRENT_SOURCE_DIR}/opengl" ${CMAKE_CURRENT_SOURCE_DIR}/opengl
) )
target_link_libraries(graphics PUBLIC geometry mesh fonts image visual_elements ${platform_LIBS}) target_compile_definitions(${MODULE_NAME} PRIVATE ${DEFINES})
target_link_libraries(${MODULE_NAME} PUBLIC geometry mesh fonts image visual_elements ${platform_LIBS})
set_property(TARGET graphics PROPERTY FOLDER src) set_property(TARGET ${MODULE_NAME} PROPERTY FOLDER src)
set_target_properties( graphics PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON ) set_target_properties( ${MODULE_NAME} PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON )

View file

@ -1,10 +1,12 @@
#include "PainterFactory.h" #include "PainterFactory.h"
#ifdef HAS_OPENGL
#include "OpenGlPainter.h" #include "OpenGlPainter.h"
#include "OpenGlMeshPainter.h" #include "OpenGlMeshPainter.h"
#include "OpenGlTextPainter.h" #include "OpenGlTextPainter.h"
#include "OpenGlShaderProgram.h" #include "OpenGlShaderProgram.h"
#include "OpenGlFontTexture.h" #include "OpenGlFontTexture.h"
#endif
#include "Grid.h" #include "Grid.h"
@ -14,6 +16,7 @@
std::unique_ptr<AbstractPainter> PainterFactory::Create(DrawingMode drawMode) std::unique_ptr<AbstractPainter> PainterFactory::Create(DrawingMode drawMode)
{ {
#ifdef HAS_OPENGL
if (drawMode == DrawingMode::GRAPH) if (drawMode == DrawingMode::GRAPH)
{ {
return std::make_unique<OpenGlPainter>(); return std::make_unique<OpenGlPainter>();
@ -22,6 +25,9 @@ std::unique_ptr<AbstractPainter> PainterFactory::Create(DrawingMode drawMode)
{ {
return std::make_unique<RasterPainter>(); return std::make_unique<RasterPainter>();
} }
#else
return std::make_unique<RasterPainter>();
#endif
} }

View file

@ -69,8 +69,8 @@ void UnixSocketInterface::Write(const SocketPtr& socket, const std::string& mess
return; return;
} }
char buffer[mBufferSize] = {0}; char buffer[BUFFER_SIZE] = {0};
int res = read(socket->GetHandle(), buffer, mBufferSize); int res = read(socket->GetHandle(), buffer, BUFFER_SIZE);
if (res < 0) if (res < 0)
{ {
std::cerr << "Error on read" << std::endl; std::cerr << "Error on read" << std::endl;
@ -124,8 +124,8 @@ void UnixSocketInterface::Run(const SocketPtr& socket)
return; return;
} }
char buffer[mBufferSize] = {0}; char buffer[BUFFER_SIZE] = {0};
int n = read(new_socket_handle, buffer, mBufferSize); int n = read(new_socket_handle, buffer, BUFFER_SIZE);
if (n < 0) if (n < 0)
{ {
std::cerr << "Error on read" << std::endl; std::cerr << "Error on read" << std::endl;

View file

@ -29,6 +29,7 @@ public:
private: private:
static constexpr unsigned BUFFER_SIZE{1024};
std::size_t mBufferSize { 0 }; std::size_t mBufferSize { 0 };
std::unique_ptr<ISocketMessageHandler> mMessageHandler; std::unique_ptr<ISocketMessageHandler> mMessageHandler;
}; };

View file

@ -13,7 +13,7 @@ list(APPEND video_LIB_INCLUDES
list(APPEND video_DEFINES "") list(APPEND video_DEFINES "")
message(STATUS "Checking optional dependencies for module: " ${MODULE_NAME}) message(STATUS "Checking dependencies for module: " ${MODULE_NAME})
find_package(PkgConfig QUIET) find_package(PkgConfig QUIET)
set(_HAS_FFMPEG Off) set(_HAS_FFMPEG Off)
if(PkgConfig_FOUND) if(PkgConfig_FOUND)
@ -38,17 +38,15 @@ if(PkgConfig_FOUND)
list(APPEND video_DEFINES "HAS_FFMPEG") list(APPEND video_DEFINES "HAS_FFMPEG")
set(_HAS_FFMPEG ON) set(_HAS_FFMPEG ON)
else() else()
message(STATUS "libavdevice not found - disabling ffmpeg support") message(STATUS "ffmpeg not found - skipping support")
endif() endif()
else() else()
message(STATUS "PkgConfig not found - disabling ffmpeg support") message(STATUS "ffmpeg not found - skipping support")
endif() endif()
set(HAS_FFMPEG ${_HAS_FFMPEG} CACHE BOOL "Can build with FFMPEG")
add_library(${MODULE_NAME} SHARED ${video_LIB_INCLUDES} ${video_HEADERS}) add_library(${MODULE_NAME} SHARED ${video_LIB_INCLUDES} ${video_HEADERS})
target_include_directories(video PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}") target_include_directories(${MODULE_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
set_target_properties( video PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON ) set_target_properties( video PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON )
list(APPEND video_LIBS image) list(APPEND video_LIBS image)

View file

@ -4,7 +4,7 @@ set (platform_INCLUDES "")
set (platform_LIBS "") set (platform_LIBS "")
if(UNIX) if(UNIX)
message(STATUS "Checking optional dependencies for module: window") message(STATUS "Checking dependencies for module: window")
find_package(X11 QUIET) find_package(X11 QUIET)
if(X11_FOUND) if(X11_FOUND)
list(APPEND platform_INCLUDES list(APPEND platform_INCLUDES
@ -21,8 +21,9 @@ if(UNIX)
) )
list(APPEND platform_LIBS ${X11_LIBRARIES} ${X11_xcb_LIB} ${X11_X11_xcb_LIB} ${X11_xkbcommon_LIB} ${X11_xkbcommon_X11_LIB} libxcb-image.so) list(APPEND platform_LIBS ${X11_LIBRARIES} ${X11_xcb_LIB} ${X11_X11_xcb_LIB} ${X11_xkbcommon_LIB} ${X11_xkbcommon_X11_LIB} libxcb-image.so)
list(APPEND X11_INCLUDE_DIRS ${X11_xkbcommon_INCLUDE_PATH}) list(APPEND X11_INCLUDE_DIRS ${X11_xkbcommon_INCLUDE_PATH})
list(APPEND DEFINES "HAS_X11")
else() else()
message(STATUS "x11 development headers not found - skipping support") message(STATUS "X11 not found - skipping support")
endif() endif()
find_package(Wayland QUIET) find_package(Wayland QUIET)
@ -47,7 +48,7 @@ if(UNIX)
list(APPEND platform_LIBS ${WAYLAND_LIBRARIES}) list(APPEND platform_LIBS ${WAYLAND_LIBRARIES})
endif() endif()
else() else()
Message(STATUS "Wayland dependencies not found - disabling Wayland support") Message(STATUS "Wayland not found - skipping support")
endif() endif()
else() else()
list(APPEND platform_INCLUDES list(APPEND platform_INCLUDES

View file

@ -0,0 +1,27 @@
#pragma once
#include "AbstractUiInterface.h"
#include "DesktopManager.h"
#include "FontsManager.h"
class NullUIInterface : public AbstractUIInterface
{
public:
NullUIInterface(DesktopManager* desktopManager, std::unique_ptr<FontsManager> fontsManager, bool useHardware = false)
: AbstractUIInterface(desktopManager, std::move(fontsManager), useHardware)
{
};
virtual ~NullUIInterface() = default;
void loop() override{};
void showWindow(mt::Window* window) override{};
void addWindow(mt::Window* window) override{};
protected:
void initialize() override{};
void shutDown() override{};
};

View file

@ -1,7 +1,9 @@
#include "UiInterfaceFactory.h" #include "UiInterfaceFactory.h"
#ifdef __linux__ #ifdef __linux__
#ifdef HAS_X11
#include "XcbInterface.h" #include "XcbInterface.h"
#endif
#ifdef HAS_WAYLAND #ifdef HAS_WAYLAND
#include "WaylandInterface.h" #include "WaylandInterface.h"
#endif #endif
@ -9,6 +11,8 @@
#include "Win32UiInterface.h" #include "Win32UiInterface.h"
#endif #endif
#include "NullUiInterface.h"
#include "FontsManager.h" #include "FontsManager.h"
std::unique_ptr<AbstractUIInterface> UiInterfaceFactory::create(DesktopManager* desktopManager, Backend backend) std::unique_ptr<AbstractUIInterface> UiInterfaceFactory::create(DesktopManager* desktopManager, Backend backend)
@ -18,18 +22,26 @@ std::unique_ptr<AbstractUIInterface> UiInterfaceFactory::create(DesktopManager*
#ifdef __linux__ #ifdef __linux__
if (backend == Backend::UNSET || backend == Backend::X11 || backend == Backend::X11_RASTER) if (backend == Backend::UNSET || backend == Backend::X11 || backend == Backend::X11_RASTER)
{ {
#ifdef HAS_X11
const bool use_hardware = (backend != Backend::X11_RASTER); const bool use_hardware = (backend != Backend::X11_RASTER);
return std::make_unique<XcbInterface>(desktopManager, std::move(fonts_manager), use_hardware); return std::make_unique<XcbInterface>(desktopManager, std::move(fonts_manager), use_hardware);
#else
return std::make_unique<NullUIInterface>(desktopManager, std::move(fonts_manager));
#endif
} }
else else
{ {
#ifdef HAS_WAYLAND #ifdef HAS_WAYLAND
const bool use_hardware = (backend != Backend::WAYLAND_RASTER); const bool use_hardware = (backend != Backend::WAYLAND_RASTER);
return std::make_unique<WaylandInterface>(desktopManager, std::move(fonts_manager), use_hardware); return std::make_unique<WaylandInterface>(desktopManager, std::move(fonts_manager), use_hardware);
#else #else
const bool use_hardware = (backend != Backend::X11_RASTER); #ifdef HAS_X11
return std::make_unique<XcbInterface>(desktopManager, std::move(fonts_manager), use_hardware); const bool use_hardware = (backend != Backend::X11_RASTER);
#endif return std::make_unique<XcbInterface>(desktopManager, std::move(fonts_manager), use_hardware);
#else
return std::make_unique<NullUIInterface>(desktopManager, std::move(fonts_manager));
#endif
#endif
} }
#else #else
return std::make_unique<Win32UiInterface>(); return std::make_unique<Win32UiInterface>();