code:
Alexandre Almeida <wilsalx@gmail.com> <meta.lx@hotmail.com>
Tobias Junghans <tobias.doerffel@gmail.com>
Dave French <dave.french3@googlemail.com>
Paul Giblock <drfaygo@gmail.com> <pgib@users.sf.net>
Paul Giblock <drfaygo@gmail.com> <p@pgiblock.net>
Andrew Kelley <superjoe30@gmail.com> <andrew.r.kelley@gmail.com>
Andrew Kelley <superjoe30@gmail.com> <andy@debian.superjoesoftware>
Janne Sinisalo <janne.m.sinisalo@gmail.com> <janne@janne-desktop.(none)>
Raine M. Ekman <raine@iki.fi> <raine@raine.(none)>
Raine M. Ekman <raine@iki.fi> <raine@raine.damex.fi>
Lukas W <lukaswhl@gmail.com> <lukaswhl@googlemail.com>
Vesa <contact.diizy@nbl.fi> <vesa@isokone.(none)>
Vesa <contact.diizy@nbl.fi> <diizy@users.noreply.github.com>
Tres Finocchiaro <tres.finocchiaro@gmail.com>
Tres Finocchiaro <tres.finocchiaro@gmail.com> <tres@ubuntu-1204.(none)>
Tres Finocchiaro <tres.finocchiaro@gmail.com> <ubuntu@ubuntu-1204.(none)>
Tres Finocchiaro <tres.finocchiaro@gmail.com> <tresf@github.com>
Rüdiger Ranft <rudi@qzzq.de> <_rdi_@web.de>
Spekular <Spekularr@gmail.com> <Spekular@users.noreply.github.com>
unfa <unfa00@gmail.com> <unfa@unfa.(none)>
mikobuntu <chrissy.mc.1@hotmail.co.uk> <mikobuntu@mikobuntu-Aspire-5332.(none)>
Jonathan Aquilina <eagles051387@gmail.com>
midi-pascal <midi-pascal@videotron.ca>
midi-pascal <midi-pascal@videotron.ca> <pascal@TDE.(none)>
Thomas Clark <the.thomas.j.clark@gmail.com>
Thomas Clark <the.thomas.j.clark@gmail.com> <tjclark@wpi.edu>
anonymous <support@lmms.io> Locale updater <>
grejppi <grejppi@gmail.com>
Johannes Lorenz <j.git@lorenz-ho.me> <johannes89@mailueberfall.de>
Johannes Lorenz <j.git@lorenz-ho.me> <1042576+JohannesLorenz@users.noreply.github.com>
Noah Brecht <noahb2713@gmail.com>
Olivier Humbert <trebmuh@tuxfamily.org> <trebmuh@users.noreply.github.com>
Hussam al-Homsi <sawuare@gmail.com> Hussam Eddin Alhomsi <hussameddin.alhomsi@gmail.com>

path: .mailmap


code:
language: cpp
compiler: gcc
dist: xenial
sudo: required
cache:
    directories:
        - $HOME/apt_mingw_cache
        - $HOME/.ccache
        - $HOME/pbuilder-bases
matrix:
    include:
        - env: TYPE=style
        - os: linux
        - env: TARGET_OS=debian-sid TARGET_DEPLOY=True
          git:
              depth: false
        - env: TARGET_OS=debian-sid TARGET_ARCH=i386
          git:
              depth: false
        - compiler: clang
          env: TARGET_OS=debian-sid
          git:
              depth: false
        - os: osx
          osx_image: xcode10.3
before_install:
    # appdmg doesn't work with old Node.js
    - if [ "$TRAVIS_OS_NAME" = osx ]; then nvm install 10; fi
install: ${TRAVIS_BUILD_DIR}/.travis/install.sh
script: ${TRAVIS_BUILD_DIR}/.travis/script.sh
after_script: ${TRAVIS_BUILD_DIR}/.travis/after_script.sh
before_deploy:
    - if [ "$TARGET_OS" != debian-sid ]; then make package; fi

repo_name: CYBERDEViL/LMMS

license: mit


code:
#!/usr/bin/env bash

set -e

if [ "$TYPE" != 'style' ]; then
	ccache -s
fi


code:
#!/usr/bin/env bash

set -e

if [ "$TYPE" = 'style' ]; then
	sudo apt-get -yqq update
	sudo apt-get install shellcheck
else
	"$TRAVIS_BUILD_DIR/.travis/$TRAVIS_OS_NAME.$TARGET_OS.before_install.sh"
	"$TRAVIS_BUILD_DIR/.travis/$TRAVIS_OS_NAME.$TARGET_OS.install.sh"
fi


code:
#!/usr/bin/env bash

set -e

sudo add-apt-repository ppa:beineri/opt-qt592-xenial -y

sudo dpkg --add-architecture i386
sudo apt-get update -qq || true


code:
#!/usr/bin/env bash

set -e

PACKAGES="cmake libsndfile-dev fftw3-dev libvorbis-dev libogg-dev libmp3lame-dev
	libasound2-dev libjack-jackd2-dev libsdl-dev libsamplerate0-dev libstk0-dev stk
	libfluidsynth-dev portaudio19-dev g++-multilib libfltk1.3-dev fluid
	libgig-dev libsoundio-dev qt59base qt59translations qt59tools"

# swh build dependencies
SWH_PACKAGES="perl libxml2-utils libxml-perl liblist-moreutils-perl"

# VST dependencies
VST_PACKAGES="wine-dev qt59x11extras qtbase5-private-dev libxcb-util0-dev libxcb-keysyms1-dev"

# LV2 dependencies; libsuil-dev is not required
LV2_PACKAGES="lv2-dev liblilv-dev"

# Help with unmet dependencies
PACKAGES="$PACKAGES $SWH_PACKAGES $VST_PACKAGES $LV2_PACKAGES libjack-jackd2-0"

# shellcheck disable=SC2086
sudo apt-get install -y $PACKAGES


code:
#!/usr/bin/env bash
unset QTDIR QT_PLUGIN_PATH LD_LIBRARY_PATH
# shellcheck disable=SC1091
source /opt/qt59/bin/qt59-env.sh

set -e

mkdir build
cd build

# shellcheck disable=SC2086
cmake -DUSE_WERROR=ON -DCMAKE_INSTALL_PREFIX=../target $CMAKE_FLAGS ..
make -j4
make tests
./tests/tests


code:
#!/bin/sh
sudo apt-get update -qq


code:
#!/bin/sh
set -e

sudo apt-get install -y \
	dpkg \
	pbuilder

# work around a pbuilder bug which breaks ccache
# https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=666525
# and also missing signing keys in Trusty's debian-archive-keyring
cd /tmp
wget http://archive.ubuntu.com/ubuntu/pool/main/p/pbuilder/pbuilder_0.229.1_all.deb
wget http://archive.ubuntu.com/ubuntu/pool/main/d/debootstrap/debootstrap_1.0.95_all.deb
wget http://archive.ubuntu.com/ubuntu/pool/universe/d/debian-archive-keyring/debian-archive-keyring_2017.7ubuntu1_all.deb
sha256sum -c "$TRAVIS_BUILD_DIR/.travis/debian_pkgs.sha256"
sudo dpkg -i pbuilder_0.229.1_all.deb debootstrap_1.0.95_all.deb debian-archive-keyring_2017.7ubuntu1_all.deb
cd "$OLDPWD"


code:
#!/bin/bash
set -e

: "${TARGET_ARCH:=amd64}"

BASETGZ="$HOME/pbuilder-bases/debian-sid-$TARGET_ARCH.tgz"
MIRROR=http://cdn-fastly.deb.debian.org/debian
KEYRING=/usr/share/keyrings/debian-archive-keyring.gpg

if [ -z "$TRAVIS_TAG" ]
then
	sudo \
	sh -c "echo CCACHEDIR=$HOME/.ccache >> /etc/pbuilderrc"
fi

if [ "$CC" = clang ]
then
	sudo sh -c "echo EXTRAPACKAGES=clang >> /etc/pbuilderrc"
fi

if [ ! -e "$BASETGZ.stamp" ]
then
	mkdir -p "$HOME/pbuilder-bases"
	sudo pbuilder --create --basetgz "$BASETGZ" --mirror $MIRROR \
		--distribution sid --architecture $TARGET_ARCH \
		--debootstrapopts --variant=buildd \
		--debootstrapopts --keyring=$KEYRING \
		--debootstrapopts --include=perl
	touch "$BASETGZ.stamp"
else
	sudo pbuilder --update --basetgz "$BASETGZ"
fi

sync_version() {
	local VERSION
	local MMR
	local STAGE
	local EXTRA

	VERSION=$(git describe --tags --match v[0-9].[0-9].[0-9]*)
	VERSION=${VERSION#v}
	MMR=${VERSION%%-*}
	case $VERSION in
	*-*-*-*)
		VERSION=${VERSION%-*}
		STAGE=${VERSION#*-}
		STAGE=${STAGE%-*}
		EXTRA=${VERSION##*-}
		VERSION=$MMR~$STAGE.$EXTRA
		;;
	*-*-*)
		VERSION=${VERSION%-*}
		EXTRA=${VERSION##*-}
		VERSION=$MMR.$EXTRA
		;;
	*-*)
		STAGE=${VERSION#*-}
		VERSION=$MMR~$STAGE
		;;
	esac

	sed "1 s/@VERSION@/$VERSION/" -i debian/changelog
	echo "Set Debian version to $VERSION"
}

sync_version

DIR="$PWD"
cd ..
dpkg-source -b "$DIR"
env -i CC="$CC" CXX="$CXX" sudo pbuilder --build --debbuildopts "--jobs=auto" \
	--basetgz "$BASETGZ" ./*.dsc


code:
#!/usr/bin/env bash

set -e

CACHE_DIR=$HOME/apt_mingw_cache/$1
mkdir -p "$CACHE_DIR"

pushd "$CACHE_DIR"

# shellcheck disable=SC2086
apt-get --print-uris --yes install $MINGW_PACKAGES | grep ^\' | cut -d\' -f2 > downloads.list
wget -N --input-file downloads.list

sudo cp ./*.deb /var/cache/apt/archives/

popd


code:
#!/usr/bin/env bash

set -e

sudo add-apt-repository ppa:tobydox/mingw-x-trusty -y
sudo apt-get update -qq


code:
#!/usr/bin/env bash

set -e

MINGW_PACKAGES="mingw32-x-sdl mingw32-x-libvorbis mingw32-x-fluidsynth mingw32-x-stk
	mingw32-x-glib2 mingw32-x-portaudio mingw32-x-libsndfile mingw32-x-fftw
	mingw32-x-flac mingw32-x-fltk mingw32-x-libsamplerate
	mingw32-x-pkgconfig mingw32-x-binutils mingw32-x-gcc mingw32-x-runtime
	mingw32-x-libgig mingw32-x-libsoundio mingw32-x-lame mingw32-x-qt5base"

# swh build dependencies
SWH_PACKAGES="perl libxml2-utils libxml-perl liblist-moreutils-perl"

export MINGW_PACKAGES

"$TRAVIS_BUILD_DIR/.travis/linux.win.download.sh" win32

PACKAGES="nsis cloog-isl libmpc3 qt4-linguist-tools mingw32 $MINGW_PACKAGES $SWH_PACKAGES"

# shellcheck disable=SC2086
sudo apt-get install -y $PACKAGES

# ccache 3.2 is needed because mingw32-x-gcc is version 4.9, which causes cmake
# to use @file command line passing, which in turn ccache 3.1.9 doesn't support
pushd /tmp
wget http://archive.ubuntu.com/ubuntu/pool/main/c/ccache/ccache_3.2.4-1_amd64.deb
sha256sum -c "$TRAVIS_BUILD_DIR/.travis/ccache.sha256"
sudo dpkg -i ccache_3.2.4-1_amd64.deb
popd


code:
#!/usr/bin/env bash
set -e

mkdir build
cd build

export CMAKE_OPTS="$CMAKE_FLAGS -DUSE_WERROR=ON"
../cmake/build_win32.sh

make -j4
make tests


code:
#!/usr/bin/env bash

set -e

"$TRAVIS_BUILD_DIR/.travis/linux.win32.before_install.sh"


code:
#!/usr/bin/env bash

set -e

# First, install 32-bit deps
"$TRAVIS_BUILD_DIR/.travis/linux.win32.install.sh"

MINGW_PACKAGES="mingw64-x-sdl mingw64-x-libvorbis mingw64-x-fluidsynth mingw64-x-stk
	mingw64-x-glib2 mingw64-x-portaudio mingw64-x-libsndfile
	mingw64-x-fftw mingw64-x-flac mingw64-x-fltk mingw64-x-libsamplerate
	mingw64-x-pkgconfig mingw64-x-binutils mingw64-x-gcc mingw64-x-runtime
	mingw64-x-libgig mingw64-x-libsoundio mingw64-x-lame mingw64-x-qt5base"

export MINGW_PACKAGES

"$TRAVIS_BUILD_DIR/.travis/linux.win.download.sh" win64

# shellcheck disable=SC2086
sudo apt-get install -y $MINGW_PACKAGES


code:
#!/usr/bin/env bash
set -e

mkdir build
cd build

export CMAKE_OPTS="$CMAKE_FLAGS -DUSE_WERROR=ON"
../cmake/build_win64.sh

make -j4
make tests


code:
#!/usr/bin/env bash

set -e

brew update
# Python 2 may cause conflicts on dependency installation
brew unlink python@2 || true


code:
#!/usr/bin/env bash

set -e

PACKAGES="cmake pkg-config libogg libvorbis lame libsndfile libsamplerate lilv lv2 jack sdl libgig libsoundio stk fluid-synth portaudio node fltk qt carla"

if "${TRAVIS}"; then
   PACKAGES="$PACKAGES ccache"
fi

# removing already installed packages from the list
for p in $(brew list); do
	PACKAGES=${PACKAGES//$p/}
done;

# shellcheck disable=SC2086
brew install $PACKAGES

# fftw tries to install gcc which conflicts with travis
brew install fftw --ignore-dependencies

npm install -g appdmg


code:
#!/usr/bin/env bash
set -e

mkdir build
cd build

# Workaround; No FindQt5.cmake module exists
CMAKE_PREFIX_PATH="$(brew --prefix qt5)"
export CMAKE_PREFIX_PATH

# shellcheck disable=SC2086
cmake -DUSE_WERROR=OFF -DCMAKE_INSTALL_PREFIX=../target $CMAKE_FLAGS ..

make -j4
make tests
./tests/tests


code:
#!/usr/bin/env bash

set -e

if [ "$TYPE" = 'style' ]; then

	# SC2185 is disabled because of: https://github.com/koalaman/shellcheck/issues/942
	# once it's fixed, it should be enabled again
	# shellcheck disable=SC2185
	# shellcheck disable=SC2046
	shellcheck $(find -O3 . -maxdepth 3 -type f -name '*.sh' -o -name "*.sh.in")
	shellcheck doc/bash-completion/lmms

else

	export CMAKE_FLAGS="-DCMAKE_BUILD_TYPE=RelWithDebInfo -DBUNDLE_QT_TRANSLATIONS=ON"

	if [ -z "$TRAVIS_TAG" ]; then
		export CMAKE_FLAGS="$CMAKE_FLAGS -DUSE_CCACHE=ON"
	fi

	"$TRAVIS_BUILD_DIR/.travis/$TRAVIS_OS_NAME.$TARGET_OS.script.sh"

	# Package and upload non-tagged builds
	if [ -n "$TRAVIS_TAG" ]; then
		# Skip, handled by travis deploy instead
		exit 0
	elif [[ $TARGET_OS == win* ]]; then
		cd build
		make -j4 package
		PACKAGE="$(ls lmms-*win*.exe)"
	elif [[ $TRAVIS_OS_NAME == osx ]]; then
		cd build
		make -j4 install > /dev/null
		make dmg
		PACKAGE="$(ls lmms-*.dmg)"
	elif [[ $TARGET_OS != debian-sid ]]; then
		cd build
		make -j4 install > /dev/null
		make appimage
		PACKAGE="$(ls lmms-*.AppImage)"
	fi

	echo "Uploading $PACKAGE to transfer.sh..."
	# Limit the connection time to 3 minutes and total upload time to 5 minutes
	# Otherwise the build may hang
	curl --connect-timeout 180 --max-time 300 --upload-file "$PACKAGE" "https://transfer.sh/$PACKAGE" || true
fi


code:
[main]
host = https://www.transifex.com
minimum_perc = 51
#Need to finish at least 51% before merging back

[lmms.lmms]
file_filter = data/locale/<lang>.ts
source_file = data/locale/en.ts
source_lang = en
type = QT

path: .tx/config


code:
CMAKE_MINIMUM_REQUIRED(VERSION 3.3)

PROJECT(lmms)

SET(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/modules" ${CMAKE_MODULE_PATH})
SET(LMMS_BINARY_DIR ${CMAKE_BINARY_DIR})
SET(LMMS_SOURCE_DIR ${CMAKE_SOURCE_DIR})

IF(COMMAND CMAKE_POLICY)
	CMAKE_POLICY(SET CMP0005 NEW)
	CMAKE_POLICY(SET CMP0003 NEW)
	IF (CMAKE_MAJOR_VERSION GREATER 2)
		CMAKE_POLICY(SET CMP0026 NEW)
		CMAKE_POLICY(SET CMP0045 NEW)
		CMAKE_POLICY(SET CMP0050 OLD)
	ENDIF()
	CMAKE_POLICY(SET CMP0020 NEW)
	CMAKE_POLICY(SET CMP0057 NEW)
ENDIF(COMMAND CMAKE_POLICY)

# Import of windows.h breaks min()/max()
ADD_DEFINITIONS(-DNOMINMAX)

INCLUDE(PluginList)
INCLUDE(CheckSubmodules)
INCLUDE(AddFileDependencies)
INCLUDE(CheckIncludeFiles)
INCLUDE(FindPkgConfig)
INCLUDE(GenerateExportHeader)

STRING(TOUPPER          "${CMAKE_PROJECT_NAME}" PROJECT_NAME_UCASE)

SET(PROJECT_YEAR 2020)

SET(PROJECT_AUTHOR      "LMMS Developers")
SET(PROJECT_URL         "https://lmms.io")
SET(PROJECT_EMAIL       "lmms-devel@lists.sourceforge.net")
SET(PROJECT_DESCRIPTION "${PROJECT_NAME_UCASE} - Free music production software")
SET(PROJECT_COPYRIGHT   "2008-${PROJECT_YEAR} ${PROJECT_AUTHOR}")
SET(VERSION_MAJOR       "1")
SET(VERSION_MINOR       "3")
SET(VERSION_RELEASE     "0")
SET(VERSION_STAGE       "alpha")
SET(VERSION_BUILD       "")
SET(VERSION             "${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_RELEASE}")
IF(VERSION_STAGE)
	SET(VERSION     "${VERSION}-${VERSION_STAGE}")
ENDIF()
IF(VERSION_BUILD)
	SET(VERSION     "${VERSION}-${VERSION_BUILD}")
ENDIF()

# Override version information for non-base builds
INCLUDE(VersionInfo)
INCLUDE(DetectMachine)

OPTION(WANT_ALSA	"Include ALSA (Advanced Linux Sound Architecture) support" ON)
OPTION(WANT_CALF	"Include CALF LADSPA plugins" ON)
OPTION(WANT_CAPS	"Include C* Audio Plugin Suite (LADSPA plugins)" ON)
OPTION(WANT_CARLA	"Include Carla plugin" ON)
OPTION(WANT_CMT		"Include Computer Music Toolkit LADSPA plugins" ON)
OPTION(WANT_JACK	"Include JACK (Jack Audio Connection Kit) support" ON)
OPTION(WANT_WEAKJACK	"Loosely link JACK libraries" ON)
OPTION(WANT_LV2		"Include Lv2 plugins" ON)
OPTION(WANT_SUIL	"Include SUIL for LV2 plugin UIs" ON)
OPTION(WANT_MP3LAME	"Include MP3/Lame support" ON)
OPTION(WANT_OGGVORBIS	"Include OGG/Vorbis support" ON)
OPTION(WANT_PULSEAUDIO	"Include PulseAudio support" ON)
OPTION(WANT_PORTAUDIO	"Include PortAudio support" ON)
OPTION(WANT_SNDIO	"Include sndio support" ON)
OPTION(WANT_SOUNDIO	"Include libsoundio support" ON)
OPTION(WANT_SDL		"Include SDL (Simple DirectMedia Layer) support" ON)
OPTION(WANT_SF2		"Include SoundFont2 player plugin" ON)
OPTION(WANT_GIG		"Include GIG player plugin" ON)
OPTION(WANT_STK		"Include Stk (Synthesis Toolkit) support" ON)
OPTION(WANT_SWH		"Include Steve Harris's LADSPA plugins" ON)
OPTION(WANT_TAP		"Include Tom's Audio Processing LADSPA plugins" ON)
OPTION(WANT_VST		"Include VST support" ON)
OPTION(WANT_VST_32	"Include 32-bit VST support" ON)
OPTION(WANT_VST_64	"Include 64-bit VST support" ON)
OPTION(WANT_WINMM	"Include WinMM MIDI support" OFF)
OPTION(WANT_DEBUG_FPE	"Debug floating point exceptions" OFF)
OPTION(BUNDLE_QT_TRANSLATIONS	"Install Qt translation files for LMMS" OFF)

IF(LMMS_BUILD_APPLE)
	# Fix linking on 10.14+. See issue #4762 on github
	LINK_DIRECTORIES(/usr/local/lib)
	SET(WANT_SOUNDIO OFF)
	SET(WANT_ALSA OFF)
	SET(WANT_PULSEAUDIO OFF)
	SET(WANT_VST OFF)
	SET(STATUS_ALSA "<not supported on this platform>")
	SET(STATUS_PULSEAUDIO "<not supported on this platform>")
	SET(STATUS_APPLEMIDI "OK")
ELSE(LMMS_BUILD_APPLE)
	SET(STATUS_APPLEMIDI "<not supported on this platform>")
ENDIF(LMMS_BUILD_APPLE)

IF(LMMS_BUILD_WIN32)
	SET(WANT_ALSA OFF)
	SET(WANT_PULSEAUDIO OFF)
	SET(WANT_SNDIO OFF)
	SET(WANT_SOUNDIO OFF)
	SET(WANT_WINMM ON)
	SET(BUNDLE_QT_TRANSLATIONS ON)
	SET(LMMS_HAVE_WINMM TRUE)
	SET(STATUS_ALSA "<not supported on this platform>")
	SET(STATUS_PULSEAUDIO "<not supported on this platform>")
	SET(STATUS_SOUNDIO "<disabled in this release>")
	SET(STATUS_WINMM "OK")
	SET(STATUS_APPLEMIDI "<not supported on this platform>")
ELSE(LMMS_BUILD_WIN32)
	SET(STATUS_WINMM "<not supported on this platform>")
ENDIF(LMMS_BUILD_WIN32)

# TODO: Fix linking issues with msys debug builds
IF(LMMS_BUILD_MSYS AND CMAKE_BUILD_TYPE STREQUAL "Debug")
	SET(WANT_GIG OFF)
	SET(WANT_STK OFF)
	SET(WANT_SWH OFF)
	SET(STATUS_GIG "not built as requested")
	SET(STATUS_STK "not built as requested")
ENDIF()

SET(CMAKE_CXX_STANDARD_REQUIRED ON)

CHECK_INCLUDE_FILES(stdint.h LMMS_HAVE_STDINT_H)
CHECK_INCLUDE_FILES(stdlib.h LMMS_HAVE_STDLIB_H)
CHECK_INCLUDE_FILES(pthread.h LMMS_HAVE_PTHREAD_H)
CHECK_INCLUDE_FILES(semaphore.h LMMS_HAVE_SEMAPHORE_H)
CHECK_INCLUDE_FILES(unistd.h LMMS_HAVE_UNISTD_H)
CHECK_INCLUDE_FILES(sys/types.h LMMS_HAVE_SYS_TYPES_H)
CHECK_INCLUDE_FILES(sys/ipc.h LMMS_HAVE_SYS_IPC_H)
CHECK_INCLUDE_FILES(sys/shm.h LMMS_HAVE_SYS_SHM_H)
CHECK_INCLUDE_FILES(sys/time.h LMMS_HAVE_SYS_TIME_H)
CHECK_INCLUDE_FILES(sys/times.h LMMS_HAVE_SYS_TIMES_H)
CHECK_INCLUDE_FILES(sched.h LMMS_HAVE_SCHED_H)
CHECK_INCLUDE_FILES(sys/soundcard.h LMMS_HAVE_SYS_SOUNDCARD_H)
CHECK_INCLUDE_FILES(soundcard.h LMMS_HAVE_SOUNDCARD_H)
CHECK_INCLUDE_FILES(fcntl.h LMMS_HAVE_FCNTL_H)
CHECK_INCLUDE_FILES(sys/ioctl.h LMMS_HAVE_SYS_IOCTL_H)
CHECK_INCLUDE_FILES(ctype.h LMMS_HAVE_CTYPE_H)
CHECK_INCLUDE_FILES(string.h LMMS_HAVE_STRING_H)
CHECK_INCLUDE_FILES(process.h LMMS_HAVE_PROCESS_H)
CHECK_INCLUDE_FILES(locale.h LMMS_HAVE_LOCALE_H)

LIST(APPEND CMAKE_PREFIX_PATH "${CMAKE_INSTALL_PREFIX}")

FIND_PACKAGE(Qt5 5.6.0 COMPONENTS Core Gui Widgets Xml REQUIRED)
FIND_PACKAGE(Qt5 COMPONENTS LinguistTools QUIET)

INCLUDE_DIRECTORIES(
	${Qt5Core_INCLUDE_DIRS}
	${Qt5Gui_INCLUDE_DIRS}
	${Qt5Widgets_INCLUDE_DIRS}
	${Qt5Xml_INCLUDE_DIRS}
)

SET(QT_LIBRARIES
	Qt5::Core
	Qt5::Gui
	Qt5::Widgets
	Qt5::Xml
)

IF(LMMS_BUILD_LINUX AND WANT_VST)
    FIND_PACKAGE(Qt5 COMPONENTS X11Extras REQUIRED)
    LIST(APPEND QT_LIBRARIES Qt5::X11Extras)
ENDIF()

# Resolve Qt5::qmake to full path for use in packaging scripts
GET_TARGET_PROPERTY(QT_QMAKE_EXECUTABLE "${Qt5Core_QMAKE_EXECUTABLE}" IMPORTED_LOCATION)

# Find the location of Qt translation files
execute_process(COMMAND ${QT_QMAKE_EXECUTABLE} -query QT_INSTALL_TRANSLATIONS
	OUTPUT_VARIABLE QT_TRANSLATIONS_DIR
	OUTPUT_STRIP_TRAILING_WHITESPACE
	ERROR_QUIET
)
IF(EXISTS "${QT_TRANSLATIONS_DIR}")
	MESSAGE("-- Found Qt translations in ${QT_TRANSLATIONS_DIR}")
	ADD_DEFINITIONS(-D'QT_TRANSLATIONS_DIR="${QT_TRANSLATIONS_DIR}"')
ENDIF()

FIND_PACKAGE(Qt5Test)
SET(QT_QTTEST_LIBRARY Qt5::Test)

# check for libsndfile
FIND_PACKAGE(SndFile REQUIRED)
IF(NOT SNDFILE_FOUND)
	MESSAGE(FATAL_ERROR "LMMS requires libsndfile1 and libsndfile1-dev >= 1.0.18 - please install, remove CMakeCache.txt and try again!")
ENDIF()
# check if we can use SF_SET_COMPRESSION_LEVEL
IF(NOT SNDFILE_VERSION VERSION_LESS 1.0.26)
	SET(LMMS_HAVE_SF_COMPLEVEL TRUE)
ENDIF()

IF(WANT_LV2)
	IF(PKG_CONFIG_FOUND)
		PKG_CHECK_MODULES(LV2 lv2)
		PKG_CHECK_MODULES(LILV lilv-0)
	ENDIF()
	IF(NOT LV2_FOUND AND NOT LILV_FOUND)
		FIND_PACKAGE(LV2 CONFIG)
		FIND_PACKAGE(LILV CONFIG)
		IF(LILV_FOUND)
			SET(LILV_LIBRARIES "lilv::lilv")
		ENDIF()
	ENDIF()
	IF(LV2_FOUND AND LILV_FOUND)
		SET(LMMS_HAVE_LV2 TRUE)
		SET(STATUS_LV2 "OK")
	ELSE()
		SET(STATUS_LV2 "not found, install it or set PKG_CONFIG_PATH appropriately")
	ENDIF()
ELSE(WANT_LV2)
	SET(STATUS_LV2 "not built as requested")
ENDIF(WANT_LV2)

IF(WANT_SUIL)
	IF(PKG_CONFIG_FOUND)
		PKG_CHECK_MODULES(SUIL suil-0)
		IF(SUIL_FOUND)
			SET(LMMS_HAVE_SUIL TRUE)
			SET(STATUS_SUIL "OK")
		ELSE()
			SET(STATUS_SUIL "not found, install it or set PKG_CONFIG_PATH appropriately")
		ENDIF()
	ELSE()
		SET(STATUS_SUIL "not found, requires pkg-config")
	ENDIF()
ELSE(WANT_SUIL)
	SET(STATUS_SUIL "not built as requested")
ENDIF(WANT_SUIL)

IF(WANT_CALF)
	SET(LMMS_HAVE_CALF TRUE)
	SET(STATUS_CALF "OK")
ELSE(WANT_CALF)
	SET(STATUS_CALF "not built as requested")
ENDIF(WANT_CALF)

IF(WANT_CAPS)
	SET(LMMS_HAVE_CAPS TRUE)
	SET(STATUS_CAPS "OK")
ELSE(WANT_CAPS)
	SET(STATUS_CAPS "not built as requested")
ENDIF(WANT_CAPS)

IF(WANT_CMT)
	SET(LMMS_HAVE_CMT TRUE)
	SET(STATUS_CMT "OK")
ELSE(WANT_CMT)
	SET(STATUS_CMT "not built as requested")
ENDIF(WANT_CMT)

IF(WANT_SWH)
	SET(LMMS_HAVE_SWH TRUE)
	SET(STATUS_SWH "OK")
ELSE(WANT_SWH)
	SET(STATUS_SWH "not built as requested")
ENDIF(WANT_SWH)

IF(WANT_TAP)
	SET(LMMS_HAVE_TAP TRUE)
	SET(STATUS_TAP "OK")
ELSE(WANT_TAP)
	SET(STATUS_TAP "not built as requested")
ENDIF(WANT_TAP)

# check for CARLA
IF(WANT_CARLA)
	PKG_CHECK_MODULES(CARLA carla-native-plugin)
	# look for carla under old name
	IF(NOT CARLA_FOUND)
		PKG_CHECK_MODULES(CARLA carla-standalone>=1.9.5)
	ENDIF()
	IF(CARLA_FOUND)
		SET(LMMS_HAVE_CARLA TRUE)
		SET(STATUS_CARLA "OK")
	ELSE(CARLA_FOUND)
		SET(LMMS_HAVE_WEAKCARLA TRUE)
		SET(STATUS_CARLA "OK (weak linking enabled)")
	ENDIF(CARLA_FOUND)
ENDIF(WANT_CARLA)

# check for SDL2
IF(WANT_SDL)
	SET(SDL2_BUILDING_LIBRARY TRUE)
	FIND_PACKAGE(SDL2)
	IF(SDL2_FOUND)
		SET(LMMS_HAVE_SDL TRUE)
		SET(LMMS_HAVE_SDL2 TRUE)
		SET(STATUS_SDL "OK, using SDL2")
		SET(SDL_INCLUDE_DIR "")
		SET(SDL_LIBRARY "")
	ELSE()
		SET(SDL2_INCLUDE_DIR "")
		SET(SDL2_LIBRARY "")
	ENDIF()
ENDIF()

# fallback to SDL1
IF(WANT_SDL AND NOT LMMS_HAVE_SDL2)
	# Fallback to SDL1.2
	SET(SDL_BUILDING_LIBRARY TRUE)
	FIND_PACKAGE(SDL)
	IF(SDL_FOUND)
		SET(LMMS_HAVE_SDL TRUE)
		SET(STATUS_SDL "OK, using SDL1.2")
		# fix mingw since 53abd65
		IF(NOT SDL_INCLUDE_DIR)
			SET(SDL_INCLUDE_DIR "${CMAKE_FIND_ROOT_PATH}/include")
		ENDIF()

	ELSE()
		SET(STATUS_SDL "not found, please install libsdl2-dev (or similar) "
			"if you require SDL support")
		SET(SDL_INCLUDE_DIR "")
		SET(SDL_LIBRARY "")
	ENDIF()
ENDIF()

# check for Stk
IF(WANT_STK)
	FIND_PACKAGE(STK)
	IF(STK_FOUND)
		SET(LMMS_HAVE_STK TRUE)
		SET(STATUS_STK "OK")
	ELSE(STK_FOUND)
		SET(STK_INCLUDE_DIR "")
		SET(STATUS_STK "not found, please install libstk0-dev (or similar) "
			"if you require the Mallets instrument")
	ENDIF(STK_FOUND)
ENDIF(WANT_STK)

# check for PortAudio
IF(WANT_PORTAUDIO)
	FIND_PACKAGE(Portaudio)
	IF(PORTAUDIO_FOUND)
		SET(LMMS_HAVE_PORTAUDIO TRUE)
		SET(STATUS_PORTAUDIO "OK")
	ELSE(PORTAUDIO_FOUND)
		SET(STATUS_PORTAUDIO "not found, please install portaudio19-dev (or similar, version >= 1.9) "
			"if you require PortAudio support")
	ENDIF(PORTAUDIO_FOUND)
ENDIF(WANT_PORTAUDIO)

# check for libsoundio
IF(WANT_SOUNDIO)
  FIND_PACKAGE(SoundIo)
  IF(SOUNDIO_FOUND)
	SET(LMMS_HAVE_SOUNDIO TRUE)
	SET(STATUS_SOUNDIO "OK")
	INCLUDE_DIRECTORIES("${SOUNDIO_INCLUDE_DIR}")
  ELSE(SOUNDIO_FOUND)
	SET(SOUNDIO_INCLUDE_DIR "")
	SET(STATUS_SOUNDIO "not found, please install libsoundio if you require libsoundio support")
	SET(SOUNDIO_LIBRARY "")
  ENDIF(SOUNDIO_FOUND)
ENDIF(WANT_SOUNDIO)

# check for PulseAudio
IF(WANT_PULSEAUDIO)
	FIND_PACKAGE(PulseAudio)
	IF(PULSEAUDIO_FOUND)
		SET(LMMS_HAVE_PULSEAUDIO TRUE)
		SET(STATUS_PULSEAUDIO "OK")
	ELSE(PULSEAUDIO_FOUND)
		SET(STATUS_PULSEAUDIO "not found, please install libpulse-dev (or similar) "
			"if you require PulseAudio support")
	ENDIF(PULSEAUDIO_FOUND)
ENDIF(WANT_PULSEAUDIO)
IF(NOT LMMS_HAVE_PULSEAUDIO)
	SET(PULSEAUDIO_INCLUDE_DIR "")
	SET(PULSEAUDIO_LIBRARIES "")
ENDIF(NOT LMMS_HAVE_PULSEAUDIO)

# check for MP3/Lame-libraries
IF(WANT_MP3LAME)
	FIND_PACKAGE(Lame)
	IF(LAME_FOUND)
		SET(LMMS_HAVE_MP3LAME TRUE)
		SET(STATUS_MP3LAME "OK")
	ELSE(LAME_FOUND)
		SET(STATUS_MP3LAME "not found, please install libmp3lame-dev (or similar)")
		SET(LAME_LIBRARIES "")
		SET(LAME_INCLUDE_DIRS "")
	ENDIF(LAME_FOUND)
ELSE(WANT_MP3LAME)
	SET(STATUS_MP3LAME "Disabled for build")
ENDIF(WANT_MP3LAME)

# check for OGG/Vorbis-libraries
IF(WANT_OGGVORBIS)
	FIND_PACKAGE(OggVorbis)
	IF(OGGVORBIS_FOUND)
		SET(LMMS_HAVE_OGGVORBIS TRUE)
		SET(STATUS_OGGVORBIS "OK")
	ELSE(OGGVORBIS_FOUND)
		SET(STATUS_OGGVORBIS "not found, libogg-dev and libvorbis-dev (or similar) "
			"is highly recommended")
	ENDIF(OGGVORBIS_FOUND)
ENDIF(WANT_OGGVORBIS)

# check whether to enable OSS-support
IF(LMMS_HAVE_SOUNDCARD_H OR LMMS_HAVE_SYS_SOUNDCARD_H)
	SET(LMMS_HAVE_OSS TRUE)
	SET(STATUS_OSS "OK")
ELSE(LMMS_HAVE_SOUNDCARD_H OR LMMS_HAVE_SYS_SOUNDCARD_H)
	SET(STATUS_OSS "<not found or not supported on this platform>")
ENDIF(LMMS_HAVE_SOUNDCARD_H OR LMMS_HAVE_SYS_SOUNDCARD_H)

# check for ALSA
IF(WANT_ALSA)
	FIND_PACKAGE(Alsa)
	IF(ALSA_FOUND)
		SET(LMMS_HAVE_ALSA TRUE)
		SET(STATUS_ALSA "OK")
	ELSE(ALSA_FOUND)
		SET(STATUS_ALSA "not found, please install libasound2-dev (or similar) "
			"if you require ALSA support")
	ENDIF(ALSA_FOUND)
ENDIF(WANT_ALSA)
IF(NOT LMMS_HAVE_ALSA)
	SET(ASOUND_LIBRARY "")
ENDIF(NOT LMMS_HAVE_ALSA)

# check for JACK
IF(WANT_JACK)
	IF(WANT_WEAKJACK)
		SET(LMMS_HAVE_WEAKJACK TRUE)
		SET(WEAKJACK_INCLUDE_DIRS ${CMAKE_SOURCE_DIR}/src/3rdparty/weakjack/weakjack)
		SET(JACK_INCLUDE_DIRS ${CMAKE_SOURCE_DIR}/src/3rdparty/jack2/common)
		SET(STATUS_JACK "OK (weak linking enabled)")
		# use dlsym instead
		SET(JACK_LIBRARIES ${CMAKE_DL_LIBS})
		SET(LMMS_HAVE_JACK TRUE)
		SET(LMMS_HAVE_JACK_PRENAME TRUE)
		SET(JACK_FOUND TRUE)
	ELSE()
		PKG_CHECK_MODULES(JACK jack>=0.77)
		IF(JACK_FOUND)
			SET(LMMS_HAVE_JACK TRUE)
			SET(STATUS_JACK "OK")
			SET(CMAKE_REQUIRED_LIBRARIES_BACKUP "${CMAKE_REQUIRED_LIBRARIES}")
			SET(CMAKE_REQUIRED_LIBRARIES "${JACK_LIBRARIES}")
			CHECK_LIBRARY_EXISTS(jack jack_port_rename "" LMMS_HAVE_JACK_PRENAME)
			SET(CMAKE_REQUIRED_LIBRARIES "${CMAKE_REQUIRED_LIBRARIES_BACKUP}")
			UNSET(CMAKE_REQUIRED_LIBRARIES_BACKUP)
		ENDIF()
	ENDIF()

	IF(NOT JACK_FOUND)
		SET(JACK_INCLUDE_DIRS "")
		SET(STATUS_JACK "not found")
	ENDIF()
ENDIF(WANT_JACK)

# check for FFTW3F-library
FIND_PACKAGE(FFTW COMPONENTS fftw3f REQUIRED)

# check for FLTK
FIND_PACKAGE(FLTK)
IF(FLTK_FOUND)
	SET(STATUS_ZYN "OK")
ELSE()
	SET(STATUS_ZYN "not found, please install fltk")
ENDIF()

# check for Fluidsynth
IF(WANT_SF2)
	PKG_CHECK_MODULES(FLUIDSYNTH fluidsynth>=1.0.7)
	IF(FLUIDSYNTH_FOUND)
		SET(LMMS_HAVE_FLUIDSYNTH TRUE)
		SET(STATUS_FLUIDSYNTH "OK")
	ELSE(FLUIDSYNTH_FOUND)
		SET(STATUS_FLUIDSYNTH "not found, libfluidsynth-dev (or similar)"
			"is highly recommended")
	ENDIF(FLUIDSYNTH_FOUND)
ENDIF(WANT_SF2)

# check for libgig
If(WANT_GIG)
	PKG_CHECK_MODULES(GIG gig)
	IF(GIG_FOUND)
		SET(LMMS_HAVE_GIG TRUE)
		SET(STATUS_GIG "OK")
	ELSE(GIG_FOUND)
		SET(STATUS_GIG "not found, libgig needed for decoding .gig files")
	ENDIF(GIG_FOUND)
ENDIF(WANT_GIG)

# check for pthreads
IF(LMMS_BUILD_LINUX OR LMMS_BUILD_APPLE OR LMMS_BUILD_OPENBSD OR LMMS_BUILD_FREEBSD OR LMMS_BUILD_HAIKU)
	FIND_PACKAGE(Threads)
ENDIF(LMMS_BUILD_LINUX OR LMMS_BUILD_APPLE OR LMMS_BUILD_OPENBSD OR LMMS_BUILD_FREEBSD OR LMMS_BUILD_HAIKU)

# check for sndio (roaraudio won't work yet)
IF(WANT_SNDIO)
	FIND_PACKAGE(Sndio)
	IF(SNDIO_FOUND)
		SET(LMMS_HAVE_SNDIO TRUE)
        	SET(STATUS_SNDIO "OK")
    	ELSE()
        	SET(STATUS_SNDIO "<not found or not supported on this platform>")
	ENDIF(SNDIO_FOUND)
ENDIF(WANT_SNDIO)

# check for WINE
IF(WANT_VST)
	FIND_PACKAGE(Wine)
	IF(WINE_FOUND)
		SET(LMMS_SUPPORT_VST TRUE)
		IF(WINE_LIBRARY_FIX)
			SET(STATUS_VST "OK, with workaround linking ${WINE_LIBRARY_FIX}")
		ELSE()
			SET(STATUS_VST "OK")
		ENDIF()
	ELSEIF(WANT_VST_NOWINE)
		SET(LMMS_SUPPORT_VST TRUE)
		SET(STATUS_VST "OK")
	ELSE(WINE_FOUND)
		SET(STATUS_VST "not found, please install (lib)wine-dev (or similar) - 64 bit systems additionally need gcc-multilib and g++-multilib")
	ENDIF(WINE_FOUND)
ENDIF(WANT_VST)
IF(LMMS_BUILD_WIN32)
	SET(LMMS_SUPPORT_VST TRUE)
	SET(STATUS_VST "OK")
ENDIF(LMMS_BUILD_WIN32)

IF(WANT_DEBUG_FPE)
	IF(LMMS_BUILD_LINUX OR LMMS_BUILD_APPLE)
		SET(LMMS_DEBUG_FPE TRUE)
		SET (STATUS_DEBUG_FPE "Enabled")
	ELSE()
		SET (STATUS_DEBUG_FPE "Wanted but disabled due to unsupported platform")
	ENDIF()
ELSE()
	SET (STATUS_DEBUG_FPE "Disabled")
ENDIF(WANT_DEBUG_FPE)

# check for libsamplerate
FIND_PACKAGE(Samplerate 0.1.8 MODULE REQUIRED)

# set compiler flags
IF(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
	SET(WERROR_FLAGS "-Wall -Werror=unused-function -Wno-sign-compare -Wno-strict-overflow")
	OPTION(USE_WERROR "Add -werror to the build flags. Stops the build on warnings" OFF)
	IF(${USE_WERROR})
		SET(WERROR_FLAGS "${WERROR_FLAGS} -Werror")
	ENDIF()

	# Due to a regression in gcc-4.8.X, we need to disable array-bounds check
	IF (CMAKE_COMPILER_IS_GNUCXX AND ((CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL "4.8.0") OR (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER "4.8.0") OR LMMS_BUILD_WIN32))
		SET(WERROR_FLAGS "${WERROR_FLAGS} -Wno-array-bounds -Wno-attributes")
	ENDIF()
ELSEIF(MSVC)
	# Remove any existing /W flags
	STRING(REGEX REPLACE "/W[0-4]" "" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
	SET(WERROR_FLAGS "/W2")
	IF(${USE_WERROR})
		SET(WERROR_FLAGS "${WERROR_FLAGS} /WX")
	ENDIF()
ENDIF()

IF(NOT CMAKE_BUILD_TYPE)
	message(STATUS "Setting build type to 'Release' as none was specified.")
	set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
	# Set the possible values of build type for cmake-gui
	SET_PROPERTY(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release"
		"MinSizeRel" "RelWithDebInfo")
ENDIF()

SET(CMAKE_C_FLAGS "${WERROR_FLAGS} ${CMAKE_C_FLAGS}")
SET(CMAKE_CXX_FLAGS "${WERROR_FLAGS} ${CMAKE_CXX_FLAGS}")
SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DLMMS_DEBUG")
SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DLMMS_DEBUG")

# people simply updating git will still have this and mess up build with it
FILE(REMOVE include/lmmsconfig.h)

FILE(GLOB LMMS_INCLUDES "${CMAKE_SOURCE_DIR}/include/*.h")
LIST(SORT LMMS_INCLUDES)

# Get list of all committers from git history, ordered by number of commits.
# The CONTRIBUTORS file is used by AboutDialog. This information can be provided
# with -DCONTRIBUTORS=/path/to/CONTRIBUTORS instead. For instance, to generate
# this file for version 1.1.3, the command is:
# 	git shortlog -sne v1.1.3 | cut -c8-
FIND_PACKAGE(Git)
IF(GIT_FOUND AND NOT CONTRIBUTORS)
	SET(CONTRIBUTORS "${CMAKE_BINARY_DIR}/CONTRIBUTORS")
	EXECUTE_PROCESS(
		COMMAND "${GIT_EXECUTABLE}" shortlog -sne
		COMMAND cut -c8-
		OUTPUT_FILE "${CONTRIBUTORS}"
		WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
		TIMEOUT 1)
ENDIF()

# we somehow have to make LMMS-binary depend on MOC-files
ADD_FILE_DEPENDENCIES("${CMAKE_BINARY_DIR}/lmmsconfig.h")

IF(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
	IF(WIN32)
		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-attributes")
	ELSE(WIN32)
		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC -DPIC")
	ENDIF(WIN32)
ENDIF()

# use ccache
include(CompileCache)

# make sub-directories
ADD_SUBDIRECTORY(cmake)
ADD_SUBDIRECTORY(src)
ADD_SUBDIRECTORY(plugins)
ADD_SUBDIRECTORY(tests)
ADD_SUBDIRECTORY(data)
ADD_SUBDIRECTORY(doc)

# install tasks
ADD_SUBDIRECTORY(cmake/install)

FIND_PACKAGE(UnixCommands)
IF(GZIP)
	ADD_CUSTOM_COMMAND(OUTPUT "${CMAKE_BINARY_DIR}/lmms.1.gz"
					COMMAND ${GZIP} -c ${CMAKE_SOURCE_DIR}/doc/lmms.1 > ${CMAKE_BINARY_DIR}/lmms.1.gz
					DEPENDS "${CMAKE_SOURCE_DIR}/doc/lmms.1"
					COMMENT "Generating lmms.1.gz"
					VERBATIM)

	ADD_CUSTOM_TARGET(manpage ALL
					DEPENDS "${CMAKE_BINARY_DIR}/lmms.1.gz")
ELSEIF(UNIX)
	MESSAGE(FATAL_ERROR "Can't find gzip required for generating lmms.1.gz")
ENDIF()

# install headers

IF(LMMS_BUILD_LINUX)
	INSTALL(FILES ${LMMS_INCLUDES}
		"${CMAKE_BINARY_DIR}/lmmsconfig.h"
		"${CMAKE_BINARY_DIR}/lmmsversion.h"
		"${CMAKE_SOURCE_DIR}/src/gui/embed.cpp"
		DESTINATION "${CMAKE_INSTALL_PREFIX}/include/lmms/")
ENDIF(LMMS_BUILD_LINUX)

# package ZynAddSubFX into win32 build
IF(LMMS_BUILD_WIN32)
	IF(EXISTS "${CMAKE_SOURCE_DIR}/extras")
		ADD_SUBDIRECTORY("${CMAKE_SOURCE_DIR}/extras/data/presets")
		FILE(GLOB ZASF_BINARIES
			"${CMAKE_SOURCE_DIR}/extras/plugins/zynaddsubfx/zynaddsubfx.dll"
			"${CMAKE_SOURCE_DIR}/extras/plugins/zynaddsubfx/remote_zynaddsubfx.exe")
		LIST(SORT ZASF_BINARIES)
		INSTALL(FILES "${ZASF_BINARIES}" DESTINATION "${PLUGIN_DIR}")
	ENDIF(EXISTS "${CMAKE_SOURCE_DIR}/extras")
ENDIF(LMMS_BUILD_WIN32)

#
# add distclean-target
#
ADD_CUSTOM_TARGET(distclean
			COMMAND make clean
			COMMAND rm -rf `find -name cmake_install.cmake` `find -name Makefile` `find -type d -name CMakeFiles` CMakeCache.txt lmmsconfig.h lmms.1.gz)

#
# add tarball-target
#
SET(TMP "lmms-${VERSION}")
ADD_CUSTOM_TARGET(dist
			COMMAND make clean
			COMMAND rm -rf "${TMP}"
			COMMAND mkdir -p "${TMP}"
			COMMAND cp CMakeLists.txt LICENSE.txt INSTALL.txt README.md "${TMP}"
			COMMAND cp -r buildtools cmake data doc include plugins src "${TMP}"
			COMMAND rm -rf `find "${TMP}" -name cmake_install.cmake` `find "${TMP}" -name Makefile` `find "${TMP}" -type d -name CMakeFiles` "${TMP}/CMakeCache.txt"
			COMMAND tar cjf lmms-${VERSION}-src.tar.bz2 "${TMP}"
			COMMAND rm -rf "${TMP}")

#
# add uninstall-target
#
ADD_CUSTOM_TARGET(uninstall
	COMMAND ${CMAKE_COMMAND} -DCMAKE_INSTALL_PREFIX="${CMAKE_INSTALL_PREFIX}" -P "${CMAKE_CURRENT_SOURCE_DIR}/cmake/uninstall.cmake"
)

#
# display configuration information
#

MESSAGE("\n"
"Installation Summary\n"
"--------------------\n"
"* Install Directory           : ${CMAKE_INSTALL_PREFIX}\n"
)

MESSAGE(
"Supported audio interfaces\n"
"--------------------------\n"
"* ALSA                        : ${STATUS_ALSA}\n"
"* JACK                        : ${STATUS_JACK}\n"
"* OSS                         : ${STATUS_OSS}\n"
"* Sndio                       : ${STATUS_SNDIO}\n"
"* PortAudio                   : ${STATUS_PORTAUDIO}\n"
"* libsoundio                  : ${STATUS_SOUNDIO}\n"
"* PulseAudio                  : ${STATUS_PULSEAUDIO}\n"
"* SDL                         : ${STATUS_SDL}\n"
)

MESSAGE(
"Supported MIDI interfaces\n"
"-------------------------\n"
"* ALSA                        : ${STATUS_ALSA}\n"
"* OSS                         : ${STATUS_OSS}\n"
"* Sndio                       : ${STATUS_SNDIO}\n"
"* JACK                        : ${STATUS_JACK}\n"
"* WinMM                       : ${STATUS_WINMM}\n"
"* AppleMidi                   : ${STATUS_APPLEMIDI}\n"
)

MESSAGE(
"Supported file formats for project export\n"
"-----------------------------------------\n"
"* WAVE                        : OK\n"
"* FLAC                        : OK\n"
"* OGG/VORBIS                  : ${STATUS_OGGVORBIS}\n"
"* MP3/Lame                    : ${STATUS_MP3LAME}\n"
)

MESSAGE(
"Optional plugins\n"
"----------------\n"
"* Lv2 plugins                 : ${STATUS_LV2}\n"
"* SUIL for plugin UIs         : ${STATUS_SUIL}\n"
"* ZynAddSubFX instrument      : ${STATUS_ZYN}\n"
"* Carla Patchbay & Rack       : ${STATUS_CARLA}\n"
"* SoundFont2 player           : ${STATUS_FLUIDSYNTH}\n"
"* Stk Mallets                 : ${STATUS_STK}\n"
"* VST-instrument hoster       : ${STATUS_VST}\n"
"* VST-effect hoster           : ${STATUS_VST}\n"
"* CALF LADSPA plugins         : ${STATUS_CALF}\n"
"* CAPS LADSPA plugins         : ${STATUS_CAPS}\n"
"* CMT LADSPA plugins          : ${STATUS_CMT}\n"
"* TAP LADSPA plugins          : ${STATUS_TAP}\n"
"* SWH LADSPA plugins          : ${STATUS_SWH}\n"
"* GIG player                  : ${STATUS_GIG}\n"
)

MESSAGE(
"Developer options\n"
"-----------------------------------------\n"
"* Debug FP exceptions         : ${STATUS_DEBUG_FPE}\n"
)

MESSAGE(
"\n"
"-----------------------------------------------------------------\n"
"IMPORTANT:\n"
"after installing missing packages, remove CMakeCache.txt before\n"
"running cmake again!\n"
"-----------------------------------------------------------------\n"
"\n\n")

SET(CMAKE_INSTALL_SYSTEM_RUNTIME_DESTINATION "${BIN_DIR}")
if(MSVC)
	# We can't set this on the install time according to the configuration
	SET(CMAKE_INSTALL_DEBUG_LIBRARIES TRUE)
	SET(CMAKE_INSTALL_UCRT_LIBRARIES TRUE)
endif()
INCLUDE(InstallRequiredSystemLibraries)


code:
This project uses git submodules and several are required for a successful
build.  If this tarball was NOT provided with submodules (default), some source
dependencies will need to be manually added to src/3rdparty.

If this project WAS provided with submodules, there are detailed dependencies
(e.g. supported compilers, cmake requirements, cross-compilation) at
doc/wiki/Compiling.md including platform-specific build instructions (e.g.
apt-get, dnf, pacman, etc).

Online documentation:

   https://github.com/LMMS/lmms/wiki/

Live online chat via Discord (similar to IRC):

   https://lmms.io/chat, Channel #programming

Basic build steps:

   mkdir build
   cd build
   cmake ../
   make
   sudo make install
   # or alternately: su -c 'make install'

With the above commands an out-of-tree build is performed. You can also run
"cmake ." directly in the root of source tree although this is not recommended.
When performing an out-of-tree build after there's already an in-tree build,
make sure to run "make distclean" before running cmake inside build-directory.

If you want to use custom compiler flags simply set the environment variables
CFLAGS and CXXFLAGS.

After running cmake (the 3rd command above) you can see a summary of things
that are going to be built into LMMS or built as plugins. Install the
according libraries and development files if a certain feature is not enabled.
Then remove CMakeCache.txt and run cmake again.

For non-root installs, or to install to a non-standard location, provide an
install prefix to cmake, using the flag:

   -DCMAKE_INSTALL_PREFIX=<prefix>

The Compilation tutorial (see docs/wiki/Compilation.md)
specifically uses <prefix> as "../target" for all non-root installations.  This
is strongly recommended if developing a patch or a feature.  For root
installations, <prefix> can be /usr, /usr/local, /opt, etc. For most systems,
the default is /usr/local.

If your Qt5 installation does not reside in standard installation paths,
additionally pass:

   -DCMAKE_PREFIX_PATH=<prefix>

Where <prefix> is the location to Qt5 installation, usually /opt/qt5/, etc.

Important wiki sections:

doc/wiki/Compiling.md:
   Dependencies Detailed
      - Build Toolchain (cmake)
      - Compiler (gcc, clang)
      - Libraries (required and optional dependencies)

doc/wiki/Dependencies-<platform>.md
   Platform-specific dependencies (Windows, Ubuntu, Fedora, macOS, etc.)


code:
# ![LMMS Logo](http://lmms.sourceforge.net/Lmms_logo.png) LMMS

[![Build status](https://img.shields.io/travis/LMMS/lmms.svg?maxAge=3600)](https://travis-ci.org/LMMS/lmms)
[![Latest stable release](https://img.shields.io/github/release/LMMS/lmms.svg?maxAge=3600)](https://lmms.io/download)
[![Overall downloads on Github](https://img.shields.io/github/downloads/LMMS/lmms/total.svg?maxAge=3600)](https://github.com/LMMS/lmms/releases)
[![Join the chat at Discord](https://img.shields.io/badge/chat-on%20discord-7289DA.svg)](https://discord.gg/3sc5su7)
[![Localise on transifex](https://img.shields.io/badge/localise-on_transifex-green.svg)](https://www.transifex.com/lmms/lmms/)

**A soft PR-Freeze is currently underway to prepare for refactoring ([#5592](https://github.com/LMMS/lmms/issues/5592)). Please do not open non-essential PRs at this time.**

What is LMMS?
--------------

LMMS is a free cross-platform alternative to commercial programs like
FL Studio®, which allow you to produce music with your computer. This includes
the creation of melodies and beats, the synthesis and mixing of sounds, and
arranging of samples. You can have fun with your MIDI-keyboard and much more;
all in a user-friendly and modern interface.

[Homepage](https://lmms.io)

[Downloads/Releases](https://github.com/LMMS/lmms/releases)

[Developer Wiki](https://github.com/LMMS/lmms/wiki)

[Artist & User Wiki/Documentation](https://lmms.io/documentation)

[Sound Demos](https://lmms.io/showcase/)

[LMMS Sharing Platform](https://lmms.io/lsp/) Share your songs!

Features
---------

* Song-Editor for composing songs
* A Beat+Bassline-Editor for creating beats and basslines
* An easy-to-use Piano-Roll for editing patterns and melodies
* An FX mixer with unlimited FX channels and arbitrary number of effects
* Many powerful instrument and effect-plugins out of the box
* Full user-defined track-based automation and computer-controlled automation sources
* Compatible with many standards such as SoundFont2, VST(i), LADSPA, GUS Patches, and full MIDI support
* MIDI file importing and exporting

Building
---------

See [Compiling LMMS](https://github.com/LMMS/lmms/wiki/Compiling) on our
wiki for information on how to build LMMS.

Join LMMS-development
----------------------

If you are interested in LMMS, its programming, artwork, testing, writing demo
songs, (and improving this README...) or something like that, you're welcome
to participate in the development of LMMS!

Information about what you can do and how can be found in the
[wiki](https://github.com/LMMS/lmms/wiki).

Before coding a new big feature, please _always_
[file an issue](https://github.com/LMMS/lmms/issues/new) for your idea and
suggestions about your feature and about the intended implementation on GitHub,
or ask in one of the tech channels on Discord and wait for replies! Maybe there are different ideas, improvements, or hints, or
maybe your feature is not welcome/needed at the moment.


code:
#!/bin/bash
aberr(){ printf "[\e[31mERROR\e[0m]: \e[1m%s\e[0m\n" "$*" >&2; }
abinfo(){ printf "[\e[96mINFO\e[0m]: \e[1m%s\e[0m\n" "$*" >&2; }

function upload_to_tx() {
  if ! which tx > /dev/null; then
    aberr "You don't have Transifex client installed. \n Run \`pip install transifex-client\` to install it."
    exit 1
  fi
  abinfo "Uploading to transifex..."
  if ! tx push -s; then
    aberr "Problems occurred when uploading strings to Transifex."
    printf "\t Either there are syntax errors in source file or you don't have permission to update the source file."
    exit 1
  fi
  exit 0
}

function validate() {
  ERR_LANG=""
  ERR_BUF=""
  for i in data/locale/*.ts; do
    if ! ERR_BUF=$(lconvert-qt5 -i "${i}" -o "/tmp/test.qm" -of qm 2>&1); then
      ERR_LANG+="\e[96m$(basename "${i}")\e[0m: \e[93m${ERR_BUF}\e[0m "
      printf "\e[31mx\e[0m"
      continue
    fi
    printf "\e[32m.\e[0m"
  done
  echo ""
  if [[ "x${ERR_LANG}" != "x" ]]; then
    aberr "The following files failed the validation: "
    echo -e "${ERR_LANG}"
  fi
}

abinfo "Checking for your environment..."
if ! which lupdate-qt5 > /dev/null; then
  aberr "You don't seem to have Qt i18n tools installed."
  printf "\tUsually this comes with your Qt installation, or you need to\n"
  printf "\tinstall extra packages like \`qt5-tools\` or similar.\n"
  exit 1;
fi

abinfo "Scanning directories..."

if test -d src/3rdparty/qt5-x11embed/3rdparty/ECM/; then
  # prevent from collecting strings in ECM
  rm -rf src/3rdparty/qt5-x11embed/3rdparty/ECM/
fi

if ! lupdate-qt5 -I include/ src/ plugins/ -ts data/locale/en.ts; then
  aberr "There are some problems when collecting the strings."
  exit 1
fi

abinfo "Validating translations..."
validate

abinfo "Translations successfully updated."
printf "Do you want to upload translations to Transifex? [y/N]: "
read -n 1 -r TX
echo ""

if [[ "$TX" == "y" || "$TX" == "Y" ]]; then
  upload_to_tx
fi

abinfo "No upload as required."

exit 0


code:
SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY           "${PROJECT_DESCRIPTION}")
SET(CPACK_PACKAGE_VENDOR                        "${PROJECT_AUTHOR}")
SET(CPACK_PACKAGE_DESCRIPTION_FILE              "${CMAKE_SOURCE_DIR}/README.md")
SET(CPACK_RESOURCE_FILE_LICENSE                 "${CMAKE_SOURCE_DIR}/LICENSE.txt")
SET(CPACK_PACKAGE_VERSION_MAJOR                 "${VERSION_MAJOR}")
SET(CPACK_PACKAGE_VERSION_MINOR                 "${VERSION_MINOR}")
SET(CPACK_PACKAGE_VERSION_PATCH                 "${VERSION_RELEASE}")
IF(VERSION_STAGE)
	SET(CPACK_PACKAGE_VERSION_PATCH         "${CPACK_PACKAGE_VERSION_PATCH}-${VERSION_STAGE}")
ENDIF()
IF(VERSION_BUILD)
	SET(CPACK_PACKAGE_VERSION_PATCH         "${CPACK_PACKAGE_VERSION_PATCH}-${VERSION_BUILD}")
ENDIF()
SET(CPACK_PACKAGE_INSTALL_DIRECTORY             "${PROJECT_NAME_UCASE}")
SET(CPACK_SOURCE_GENERATOR                      "TBZ2")
SET(CPACK_SOURCE_PACKAGE_FILE_NAME              "${CMAKE_PROJECT_NAME}-${VERSION}")
IF(NOT DEFINED WIN32)
	SET(CPACK_STRIP_FILES                   "bin/${CMAKE_PROJECT_NAME};${PLUGIN_DIR}/*.so")
	SET(CPACK_PACKAGE_EXECUTABLES           "${CMAKE_PROJECT_NAME}" "${PROJECT_NAME_UCASE} binary")
ENDIF()

IF(LMMS_BUILD_WIN32)
	ADD_SUBDIRECTORY(nsis)
ELSEIF(LMMS_BUILD_APPLE)
	ADD_SUBDIRECTORY(apple)
ELSE()
	ADD_SUBDIRECTORY(linux)
ENDIF()

INCLUDE(CPack)


code:
SET(MACOSX_BUNDLE_ICON_FILE             "icon.icns")
SET(MACOSX_BUNDLE_GUI_IDENTIFIER        "${PROJECT_NAME_UCASE}")
SET(MACOSX_BUNDLE_LONG_VERSION_STRING   "${VERSION}")
SET(MACOSX_BUNDLE_BUNDLE_NAME           "${PROJECT_NAME_UCASE}")
SET(MACOSX_BUNDLE_SHORT_VERSION_STRING  "${VERSION}")
SET(MACOSX_BUNDLE_BUNDLE_VERSION        "${VERSION}")
SET(MACOSX_BUNDLE_COPYRIGHT             "${PROJECT_COPYRIGHT}")
SET(MACOSX_BUNDLE_MIMETYPE              "application/x-lmms-project")
SET(MACOSX_BUNDLE_MIMETYPE_ICON         "project.icns")
SET(MACOSX_BUNDLE_MIMETYPE_ID           "io.lmms")
SET(MACOSX_BUNDLE_PROJECT_URL           "${PROJECT_URL}")
SET(MACOSX_BUNDLE_DMG_TITLE             "${MACOSX_BUNDLE_BUNDLE_NAME} ${MACOSX_BUNDLE_LONG_VERSION_STRING}")

# FIXME: appdmg won't allow volume names > 27 char
# See also https://github.com/LinusU/node-appdmg/issues/48
STRING(SUBSTRING "${MACOSX_BUNDLE_DMG_TITLE}" 0 27 MACOSX_BUNDLE_DMG_TITLE)

CONFIGURE_FILE("lmms.plist.in"          "${CMAKE_BINARY_DIR}/Info.plist")
CONFIGURE_FILE("install_apple.sh.in"    "${CMAKE_BINARY_DIR}/install_apple.sh" @ONLY)
CONFIGURE_FILE("package_apple.json.in"  "${CMAKE_BINARY_DIR}/package_apple.json" @ONLY)

# DMG creation target
SET(DMG_FILE "${CMAKE_BINARY_DIR}/${CMAKE_PROJECT_NAME}-${VERSION}-mac${APPLE_OS_VER}.dmg")
FILE(REMOVE "${DMG_FILE}")
ADD_CUSTOM_TARGET(removedmg
	COMMAND touch "\"${DMG_FILE}\"" && rm "\"${DMG_FILE}\""
	COMMENT "Removing old DMG")
ADD_CUSTOM_TARGET(dmg
	COMMAND appdmg "\"${CMAKE_BINARY_DIR}/package_apple.json\"" "\"${DMG_FILE}\""
	DEPENDS "${CMAKE_BINARY_DIR}/package_apple.json"
	COMMENT "Generating DMG")
ADD_DEPENDENCIES(dmg removedmg)

# see also ../postinstall/CMakeLists.txt


code:
#!/bin/bash
# Creates Apple ".app" bundle for @PROJECT_NAME_UCASE@
# Note:
#   Examine linkings using `otool -L somelib.so`
#   Debug the loading of dynamic libraries using `export DYLD_PRINT_LIBRARIES=1`

set -e

# STK rawwaves directory
STK_RAWWAVE=$(brew --prefix stk)/share/stk/rawwaves

# Place to create ".app" bundle
APP="@CMAKE_BINARY_DIR@/@PROJECT_NAME_UCASE@.app"

MSG_COLOR='\x1B[1;36m'
COLOR_RESET='\x1B[0m'
echo -e "$MSG_COLOR\n\nCreating App Bundle \"$APP\"...$COLOR_RESET"

qtpath="$(dirname "@QT_QMAKE_EXECUTABLE@")"
export PATH="$PATH:$qtpath"

# Remove any old .app bundles
rm -Rf "$APP"

# Copy/overwrite Info.plist
command cp  "@CMAKE_BINARY_DIR@/Info.plist" "@CMAKE_INSTALL_PREFIX@/"

# Create .app bundle containing contents from CMAKE_INSTALL_PREFIX
mkdir -p "$APP/Contents/MacOS"
mkdir -p "$APP/Contents/Frameworks"
mkdir -p "$APP/Contents/Resources"
mkdir -p "$APP/Contents/share/stk/rawwaves"
cd "@CMAKE_INSTALL_PREFIX@"
cp -R ./* "$APP/Contents"
cp "@CMAKE_SOURCE_DIR@/cmake/apple/"*.icns "$APP/Contents/Resources/"
cp "$STK_RAWWAVE"/*.raw "$APP/Contents/share/stk/rawwaves" > /dev/null 2>&1

# Make all libraries writable for macdeployqt
cd "$APP"
find . -type f -print0 | xargs -0 chmod u+w

lmmsbin="MacOS/@CMAKE_PROJECT_NAME@"
zynlib="lib/lmms/libzynaddsubfx.so"
zynfmk="Frameworks/libZynAddSubFxCore.dylib"
zynbin="MacOS/RemoteZynAddSubFx"

# Move lmms binary
mv "$APP/Contents/bin/@CMAKE_PROJECT_NAME@" "$APP/Contents/$lmmsbin"

# Fix zyn linking
mv "$APP/Contents/lib/lmms/RemoteZynAddSubFx" "$APP/Contents/$zynbin"
mv "$APP/Contents/lib/lmms/libZynAddSubFxCore.dylib" "$APP/Contents/$zynfmk"

install_name_tool -change @rpath/libZynAddSubFxCore.dylib \
   @loader_path/../$zynfmk \
  "$APP/Contents/$zynbin"

install_name_tool -change @rpath/libZynAddSubFxCore.dylib \
   @loader_path/../../$zynfmk \
  "$APP/Contents/$zynlib"

# Replace @rpath with @loader_path for Carla
# See also plugins/carlabase/CMakeLists.txt
# This MUST be done BEFORE calling macdeployqt
install_name_tool -change @rpath/libcarlabase.dylib \
   @loader_path/libcarlabase.dylib \
  "$APP/Contents/lib/lmms/libcarlapatchbay.so"

install_name_tool -change @rpath/libcarlabase.dylib \
  @loader_path/libcarlabase.dylib \
  "$APP/Contents/lib/lmms/libcarlarack.so"

# Link lmms binary
_executables="${_executables} -executable=$APP/Contents/$zynbin"
_executables="${_executables} -executable=$APP/Contents/$zynfmk"

# Build a list of shared objects in target/lib/lmms
for file in "$APP/Contents/lib/lmms/"*.so; do
   _thisfile="$APP/Contents/lib/lmms/${file##*/}"
   _executables="${_executables} -executable=$_thisfile"
done

# Build a list of shared objects in target/lib/lmms/ladspa
for file in "$APP/Contents/lib/lmms/ladspa/"*.so; do
   _thisfile="$APP/Contents/lib/lmms/ladspa/${file##*/}"
   _executables="${_executables} -executable=$_thisfile"
done

# Finalize .app
# shellcheck disable=SC2086
macdeployqt "$APP" $_executables

# Carla is a standalone plugin.  Remove library, look for it side-by-side LMMS.app
# This MUST be done AFTER calling macdeployqt
#
# For example:
#    /Applications/LMMS.app
#    /Applications/Carla.app
carlalibs=$(echo "@CARLA_LIBRARIES@"|tr ";" "\n")

# Loop over all libcarlas, fix linking
for file in "$APP/Contents/lib/lmms/"libcarla*; do
   _thisfile="$APP/Contents/lib/lmms/${file##*/}"
   for lib in $carlalibs; do
     _oldpath="../../Frameworks/lib${lib}.dylib"
     _newpath="Carla.app/Contents/MacOS/lib${lib}.dylib"
     # shellcheck disable=SC2086
     install_name_tool -change @loader_path/$_oldpath \
       @executable_path/../../../$_newpath \
       "$_thisfile"
     rm -f "$APP/Contents/Frameworks/lib${lib}.dylib"
   done
done

# Cleanup
rm -rf "$APP/Contents/bin"
echo -e "\nFinished.\n\n"


code:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
  <dict>

    <key>CFBundleDevelopmentRegion</key>
    <string>English</string>

    <key>CFBundleIconFile</key>
    <string>@MACOSX_BUNDLE_ICON_FILE@</string>

    <key>CFBundlePackageType</key>
    <string>APPL</string>

    <key>CFBundleGetInfoString</key>
    <string>@MACOSX_BUNDLE_GUI_IDENTIFIER@ @MACOSX_BUNDLE_LONG_VERSION_STRING@</string>

<!--
    #############################################################
    #    Apple Creator Code Registered Application Signatures   #
    #############################################################
    #    Company:       LMMS Foundation                         #
    #    Registrant:    tres.finocchiaro@gmail.com              #
    #    ASCII Code:    LMMS                                    #
    #    HEX:           4C4D4D53                                #
    #############################################################
    #    Contact Apple Developer Support at cfreg@apple.com     #
    #    with any requested changes                             #
    #############################################################
-->
    <key>CFBundleSignature</key>
    <string>@MACOSX_BUNDLE_GUI_IDENTIFIER@</string>

    <key>CFBundleExecutable</key>
    <string>@MACOSX_BUNDLE_GUI_IDENTIFIER@</string>

    <key>CFBundleVersion</key>
    <string>@MACOSX_BUNDLE_LONG_VERSION_STRING@</string>

    <key>CFBundleShortVersionString</key>
    <string>@MACOSX_BUNDLE_LONG_VERSION_STRING@</string>

    <key>CFBundleName</key>
    <string>@MACOSX_BUNDLE_BUNDLE_NAME@</string>

    <key>CFBundleInfoDictionaryVersion</key>
    <string>6.0</string>

    <key>CFBundleIdentifier</key>
    <string>@MACOSX_BUNDLE_MIMETYPE_ID@</string>

    <key>CFBundleDocumentTypes</key>
    <array>

      <dict>
        <key>CFBundleTypeExtensions</key>
          <array>
            <string>mmpz</string>
          </array>
        <key>CFBundleTypeIconFile</key>
        <string>@MACOSX_BUNDLE_MIMETYPE_ICON@</string>
        <key>CFBundleTypeName</key>
        <string>@MACOSX_BUNDLE_GUI_IDENTIFIER@ Project</string>
        <key>CFBundleTypeOSTypes</key>
           <array>
             <string>mmpz</string>
           </array>
        <key>CFBundleTypeRole</key>
        <string>Editor</string>
        <key>CFBundleTypeMIMETypes</key>
        <array>
           <string>@MACOSX_BUNDLE_MIMETYPE@</string>
        </array>
      </dict>

      <dict>
        <key>CFBundleTypeExtensions</key>
          <array>
            <string>mmp</string>
          </array>
        <key>CFBundleTypeIconFile</key>
        <string>@MACOSX_BUNDLE_MIMETYPE_ICON@</string>
        <key>CFBundleTypeName</key>
        <string>@MACOSX_BUNDLE_GUI_IDENTIFIER@ Project (uncompressed)</string>
        <key>CFBundleTypeOSTypes</key>
           <array>
             <string>mmp</string>
           </array>
        <key>CFBundleTypeRole</key>
        <string>Editor</string>
        <key>CFBundleTypeMIMETypes</key>
        <array>
           <string>@MACOSX_BUNDLE_MIMETYPE@</string>
        </array>
      </dict>

    </array>

    <key>UTExportedTypeDeclarations</key>
        <array>
            <dict>
                <key>UTTypeIdentifier</key>
                <string>@MACOSX_BUNDLE_MIMETYPE_ID@.mmpz</string>
                <key>UTTypeReferenceURL</key>
                <string>@MACOSX_BUNDLE_PROJECT_URL@</string>
                <key>UTTypeDescription</key>
                <string>@MACOSX_BUNDLE_GUI_IDENTIFIER@ Project</string>
                <key>UTTypeIconFile</key>
                <string>@MACOSX_BUNDLE_MIMETYPE_ICON@</string>
                <key>UTTypeConformsTo</key>
                <array>
                    <string>public.data</string>
                </array>
                <key>UTTypeTagSpecification</key>
                <dict>
                    <key>public.filename-extension</key>
                    <array>
                        <string>mmpz</string>
                    </array>
                </dict>
            </dict>

            <dict>
                <key>UTTypeIdentifier</key>
                <string>@MACOSX_BUNDLE_MIMETYPE_ID@.mmp</string>
                <key>UTTypeReferenceURL</key>
                <string>@MACOSX_BUNDLE_PROJECT_URL@</string>
                <key>UTTypeDescription</key>
                <string>@MACOSX_BUNDLE_GUI_IDENTIFIER@ Project (uncompressed)</string>
                <key>UTTypeIconFile</key>
                <string>@MACOSX_BUNDLE_MIMETYPE_ICON@</string>
                <key>UTTypeConformsTo</key>
                <array>
                    <string>public.xml</string>
                    <string>public.data</string>
                </array>
                <key>UTTypeTagSpecification</key>
                <dict>
                    <key>public.filename-extension</key>
                    <array>
                        <string>mmp</string>
                    </array>
                </dict>
            </dict>
        </array>
        <key>NSPrincipalClass</key>
        <string>NSApplication</string>
        <key>NSHighResolutionCapable</key>
        <string>True</string>
        <key>NSRequiresAquaSystemAppearance</key>
        <string>False</string>
  </dict>
</plist>


title: @MACOSX_BUNDLE_DMG_TITLE@

type: file

type: link

path: /Applications


code:
#!/usr/bin/env bash
DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"

# Accomodate both linux windows mingw locations
if [ -z "$ARCH" ]; then
	ARCH=32
fi

MINGW=/mingw$ARCH

if [ -z "$MSYSCON" ]; then
	MINGW=/opt$MINGW

	DISTRO=$(lsb_release -si)
	DISTRO_VERSION=$(lsb_release -sr)

	if [ "$DISTRO" != "Ubuntu" ]; then
		echo "This script only supports Ubuntu"
		exit 1
	fi

	if [ "$DISTRO_VERSION" == "14.04" ]; then
		TOOLCHAIN="$DIR/toolchains/Ubuntu-MinGW-X-Trusty-$ARCH.cmake"
	else
		TOOLCHAIN="$DIR/toolchains/Ubuntu-MinGW-W64-$ARCH.cmake"
	fi
else
	TOOLCHAIN="$DIR/toolchains/MSYS-$ARCH.cmake"
fi

export PATH=$MINGW/bin:$PATH
export CXXFLAGS="$CFLAGS"
if [ "$ARCH" == "32" ]; then
	export CFLAGS="-march=pentium3 -mtune=generic -mpreferred-stack-boundary=5 -mfpmath=sse"
fi

CMAKE_OPTS="-DCMAKE_PREFIX_PATH=$MINGW $CMAKE_OPTS"

# shellcheck disable=SC2086
cmake "$DIR/.." -DCMAKE_TOOLCHAIN_FILE="$TOOLCHAIN" $CMAKE_OPTS


code:
#!/usr/bin/env bash
DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
ARCH=64 "$DIR/build_win32.sh"


code:
SET(PLUGIN_FILES "")
IF(LMMS_BUILD_WIN32)
	INSTALL(FILES $<TARGET_FILE:Qt5::QWindowsIntegrationPlugin> DESTINATION platforms)
ENDIF()

IF(LMMS_BUILD_WIN32 OR LMMS_INSTALL_DEPENDENCIES)
	include(InstallTargetDependencies)

	# Collect directories to search for DLLs
	GET_FILENAME_COMPONENT(QTBIN_DIR "${QT_QMAKE_EXECUTABLE}" PATH)
	set(LIB_DIRS "${QTBIN_DIR}")

	GET_PROPERTY(PLUGINS_BUILT GLOBAL PROPERTY PLUGINS_BUILT)

	IF(LMMS_BUILD_WIN32)
		SET(LMMS_DEP_DESTINATION ${BIN_DIR})
		SET(PLUGIN_DEP_DESTINATION ${BIN_DIR})
	ELSE()
		SET(LMMS_DEP_DESTINATION ${LIB_DIR})
		SET(PLUGIN_DEP_DESTINATION ${LIB_DIR})
	ENDIF()

	INSTALL_TARGET_DEPENDENCIES(
			NAME "main_binary"
			TARGETS lmms
			DESTINATION "${LMMS_DEP_DESTINATION}"
			LIB_DIRS  ${LIB_DIRS}
	)

	INSTALL_TARGET_DEPENDENCIES(
			NAME "plugins"
			TARGETS ${PLUGINS_BUILT}
			DESTINATION ${PLUGIN_DEP_DESTINATION}
			LIB_DIRS ${LIB_DIRS} "${PLUGIN_DIR}" "${PLUGIN_DIR}/optional"
			SEARCH_PATHS "${PLUGIN_DIR}" "${PLUGIN_DIR}/optional"
	)
ENDIF()

IF(LMMS_BUILD_APPLE)
	INSTALL(CODE "EXECUTE_PROCESS(COMMAND chmod u+x ${CMAKE_BINARY_DIR}/install_apple.sh)")
	INSTALL(CODE "EXECUTE_PROCESS(COMMAND ${CMAKE_BINARY_DIR}/install_apple.sh)")
ENDIF()


code:
# List of DLLs considered to be system libraries.
# This is needed when cross-compiling for Windows.
ADVAPI32.dll
COMCTL32.dll
comdlg32.dll
dwmapi.dll
GDI32.dll
IMM32.dll
KERNEL32.dll
MPR.DLL
msvcrt.dll
ole32.dll
OLEAUT32.dll
OPENGL32.DLL
SHELL32.dll
USER32.dll
UxTheme.dll
VERSION.dll
WINMM.DLL
WS2_32.dll
RPCRT4.dll
dsound.dll
SETUPAPI.dll

path: cmake/install/excludelist-win


code:
INSTALL(DIRECTORY icons/                DESTINATION "${DATA_DIR}/icons/hicolor")
INSTALL(FILES lmms.desktop              DESTINATION "${DATA_DIR}/applications")
INSTALL(FILES lmms.xml                  DESTINATION "${DATA_DIR}/mime/packages")

# AppImage creation target
SET(APPIMAGE_FILE "${CMAKE_BINARY_DIR}/${CMAKE_PROJECT_NAME}-${VERSION}-linux-${CMAKE_SYSTEM_PROCESSOR}.AppImage")

CONFIGURE_FILE("package_linux.sh.in"    "${CMAKE_BINARY_DIR}/package_linux.sh" @ONLY)

FILE(REMOVE "${APPIMAGE_FILE}")
ADD_CUSTOM_TARGET(removeappimage
	COMMAND rm -f "${APPIMAGE_FILE}"
	COMMENT "Removing old AppImage")
ADD_CUSTOM_TARGET(appimage
	COMMAND chmod +x "${CMAKE_BINARY_DIR}/package_linux.sh"
	COMMAND "${CMAKE_BINARY_DIR}/package_linux.sh"
	COMMENT "Generating AppImage"
	WORKING_DIRECTORY "${CMAKE_BINARY_DIR}")
ADD_DEPENDENCIES(appimage removeappimage)


code:
#!/usr/bin/env bash
DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
export PATH="$PATH:/sbin"
if command -v carla > /dev/null 2>&1; then
   CARLAPATH="$(command -v carla)"
   CARLAPREFIX="${CARLAPATH%/bin*}"
   echo "Carla appears to be installed on this system at $CARLAPREFIX/lib[64]/carla so we'll use it."
   export LD_LIBRARY_PATH=$CARLAPREFIX/lib/carla:$CARLAPREFIX/lib64/carla:$LD_LIBRARY_PATH
else
   echo "Carla does not appear to be installed.  That's OK, please ignore any related library errors."
fi
export LD_LIBRARY_PATH=$DIR/usr/lib/:$DIR/usr/lib/lmms:$LD_LIBRARY_PATH
# Prevent segfault on VirualBox
if lsmod |grep vboxguest > /dev/null 2>&1; then
   echo "VirtualBox detected.  Forcing libgl software rendering."
   export LIBGL_ALWAYS_SOFTWARE=1;
fi
if ldconfig -p | grep libjack.so.0 > /dev/null 2>&1; then
   echo "Jack appears to be installed on this system, so we'll use it."
else
   echo "Jack does not appear to be installed.  That's OK, we'll use a dummy version instead."
   export LD_LIBRARY_PATH=$DIR/usr/lib/lmms/optional:$LD_LIBRARY_PATH
fi
QT_X11_NO_NATIVE_MENUBAR=1 "$DIR"/usr/bin/lmms.real "$@"


code:
?package(lmms):needs="X11" section="Apps/Sound" \
  title="LMMS" hints="Audio" command="/usr/bin/lmms" \
  longtitle="LMMS" \
  icon="/usr/share/icons/hicolor/scalable/apps/lmms.svg"

path: cmake/linux/lmms


code:
[Desktop Entry]
Name=LMMS
GenericName=Music production suite
GenericName[ca]=Programari de producció musical
GenericName[de]=Software zur Musik-Produktion
GenericName[fr]=Suite de production musicale
GenericName[pl]=Narzędzia do produkcji muzyki
Comment=Music sequencer and synthesizer
Comment[ca]=Producció fàcil de música per a tothom!
Comment[fr]=Séquenceur et synthétiseur de musique
Comment[pl]=Prosta produkcja muzyki dla każdego!
Icon=lmms
Exec=lmms %f
Terminal=false
Type=Application
Categories=Qt;AudioVideo;Audio;Midi;
MimeType=application/x-lmms-project;


code:
# Configuration variables
%define name            lmms
%define version         ${LMMS_VERSION}
%define rel             1
%define release         %{rel}%{?disttag}%{?repotag}

# Define what you can/want to build:
%define with_sdl        0%{nil}
%define with_jack       1%{nil}
%define with_vorbis     1%{nil}
%define with_flac       1%{nil}
%define with_sr         1%{nil}
%define with_sf         1%{nil}

# Build by setting these defines on the command line, for example:
# rpmbuild --define 'disttag .EL' --define 'repotag .fc6'
%{!?desktop_vendor:     %{expand: %%define desktop_vendor rpmfarm}}
# This can be changed at build time:
# rpmbuild --define 'desktop_vendor RPMfarm'

#--------------------------------------------------------------------

Name:		%{name}
Version:	%{version}
Release:	%{release}
Summary:	powerful sequencer-, synthesizer- and sample-studio for Linux
Summary(de):	Leistungsfaehiges Sequenzer-, Synthesizer- und Sample-Studio fuer Linux
License:	GPL
URL:		https://lmms.io/
Group:		Applications/Multimedia
Provides:	lmms = %{version}-%{release}
BuildRequires:	gcc gcc-c++ libstdc++-devel autoconf automake libtool make
BuildRequires:	alsa-lib-devel
BuildRequires:	qt-devel > 3.0
# ------------- BuildRequires:
%if %{with_vorbis}
BuildRequires:  libvorbis libvorbis-devel
%endif
%if %{with_sdl}
BuildRequires:	SDL SDL-devel SDL_sound
%endif
%if %{with_sr}
BuildRequires:	libsamplerate libsamplerate-devel
%endif
%if %{with_sf}
BuildRequires:  libsndfile libsndfile-devel
%endif
%if %{with_jack}
BuildRequires:	jack-audio-connection-kit-devel
%endif
%if %{with_flac}
BuildRequires:	flac-devel
%endif
# ------------- Requires:
Requires:	qt >= 3.0 alsa-lib
%if %{with_sr}
Requires:	libsamplerate
%endif
%if %{with_sf}
Requires:	libsndfile
%endif
%if %{with_jack}
Requires:	jack-audio-connection-kit
%endif
%if %{with_vorbis}
Requires:	libvorbis
%endif
%if %{with_flac}
Requires:	flac
%endif
%if %{with_sdl}
Requires:	SDL_sound
%endif

Requires:	lmms-data
Source:		%{name}-%{version}.tar.bz2
Patch1:		%{name}-%{version}-patch
BuildRoot:	%{_tmppath}/%{name}-%{version}-buildroot
Prefix:		%{_prefix}

%description
LMMS aims to be a free alternative to popular (but commercial and closed-
source) programs like FruityLoops, Cubase and Logic giving you the ability of
producing music with your computer by creating/synthesizing sounds, arranging
samples, playing live with keyboard and much more...

LMMS combines the features of a tracker-/sequencer-program (pattern-/channel-/
sample-/song-/effect-management) and those of powerful synthesizers and
samplers in a modern, user-friendly and easy to use graphical user-interface.

LMMS is still in heavy development, so with this version please don't expect a
complete, ready and bugfree program!!

%description -l de
LMMS ist eine freie Alternative zu bekannten (aber kommerziellen und
Closed-Source-) Programmen wie FruityLoops, Cubase und Logic, die Ihnen die
Moeglichkeit geben, mit Ihrem Computer Musik zu produzieren, indem Sie
Klaenge kreieren/synthetisieren, Samples anordnen, mit dem Keyboard live
spielen usw....

LMMS kombiniert die Funktionen eines Tracker-/Sequenzer-Programms (Pattern-/
Kanal-/Sample-/Song-/Effekt-Management) und die von leistungsfaehigen
Synthesizern und Samplern in einer modernen, benutzerfreundlichen und einfach zu
benutzenden grafischen Oberflaeche.

Derzeit befindet sich LMMS komplett in Entwicklung. Also erwarten Sie bitte mit
dieser Version nicht ein vollstaendiges, fertiges und fehlerfreies Programm!!

%package data
Summary:	samples, presets, demo-projects and localization-files for LMMS
Summary(de):	Samples, Presets, Demo-Projekte und Lokalisierungsdateien fuer LMMS
Group:		Applications/Multimedia
Provides:	lmms-data = %{version}-%{release}

%description data
This package contains platform-independent data and resources for LMMS, e.g.
samples, presets and demo-projects.

%description data -l de
Dieses Paket beinhaltet plattform-unabhaengige Daten und Resourcen fuer LMMS,
wie z.B. Samples, Presets und Demo-Projekte.

%prep
%setup -n %{name}-%{version}
%patch1 -p1 -b .EL

%build
%configure \
%if !%{with_jack}
    --without-jack \
%endif
%if !%{with_sdl}
    --without-sdl \
    --without-sdlsound \
%endif
%if !%{with_vorbis}
    --without-vorbis \
%endif
%if !%{with_flac}
    --without-flac \
%endif
%if !%{with_sr}
    --without-libsrc \
%endif
%if !%{with_sf}
    --without-libsf \
%endif

%{__make} %{?_smp_mflags}

# Create a desktop menu entry
%{__cat} > %{name}.desktop << EOF
[Desktop Entry]
Name=LMMS
Comment=Powerful sequencer-, synthesizer- and sample-studio for Linux
Exec=lmms
Icon=%{_datadir}/%{name}/themes/default/icon.png
Terminal=false
Type=Application
Categories=Application;AudioVideo;X-Fedora;X-RPMfarm;
Encoding=UTF-8
EOF

%install
%{__rm} -rf %{buildroot}
make DESTDIR=$RPM_BUILD_ROOT install

# Install menu entry
%{__mkdir_p} %{buildroot}%{_datadir}/applications
desktop-file-install \
    --vendor %{desktop_vendor} \
    --dir %{buildroot}%{_datadir}/applications \
    %{name}.desktop || :

%clean
%{__rm} -rf %{buildroot}

%files
%defattr(-, root, root, 0755)
%doc AUTHORS ChangeLog COPYING README TODO
%{_bindir}/lmms
%dir %{_libdir}/lmms
%{_libdir}/lmms/*
%{_mandir}/man*/lmms.*
%{_datadir}/applications/%{desktop_vendor}-%{name}.desktop

%files data
%defattr(-,root,root)
%dir %{_datadir}/lmms
%{_datadir}/lmms/*

-%changelog
-* Please see release notes (viewable online):
-- https://github.com/LMMS/lmms/releases/tag/v${LMMS_VERSION}
-


code:
<?xml version="1.0" encoding="UTF-8"?>
<mime-info xmlns="http://www.freedesktop.org/standards/shared-mime-info">
  <mime-type type="application/x-lmms-project">
    <sub-class-of type="application/xml"/>
    <comment>LMMS project</comment>
    <comment xml:lang="ca">Projecte LMMS</comment>
    <glob pattern="*.mmpz"/>
    <glob pattern="*.mmp"/>
  </mime-type>
</mime-info>


code:
#!/usr/bin/env bash
# Creates Linux ".AppImage" for @PROJECT_NAME_UCASE@
#
# Depends:  linuxdeployqt
#
# Notes:    Will attempt to fetch linuxdeployqt automatically (x86_64 only)
#           See Also: https://github.com/probonopd/linuxdeployqt/blob/master/BUILDING.md

set -e

LINUXDEPLOYQT="@CMAKE_BINARY_DIR@/linuxdeployqt"
VERBOSITY=2 # 3=debug
LOGFILE="@CMAKE_BINARY_DIR@/appimage.log"
APPDIR="@CMAKE_BINARY_DIR@/@PROJECT_NAME_UCASE@.AppDir/"
DESKTOPFILE="${APPDIR}usr/share/applications/lmms.desktop"
STRIP=""

# Don't strip for Debug|RelWithDebInfo builds
# shellcheck disable=SC2193
if [[ "@CMAKE_BUILD_TYPE@" == *"Deb"* ]]; then
	STRIP="-no-strip"
fi

# Console colors
RED="\\x1B[1;31m"
GREEN="\\x1B[1;32m"
YELLOW="\\x1B[1;33m"
PLAIN="\\x1B[0m"

function error {
	echo -e "   ${PLAIN}[${RED}error${PLAIN}] ${1}"
	return 1
}

function success {
	echo -e "   ${PLAIN}[${GREEN}success${PLAIN}] ${1}"
}

function skipped {
	echo -e "   ${PLAIN}[${YELLOW}skipped${PLAIN}] ${1}"
}

# Blindly assume system arch is appimage arch
ARCH=$(arch)
export ARCH

# Check for problematic install locations
INSTALL=$(echo "@CMAKE_INSTALL_PREFIX@" | sed 's/\/*$//g')
if [ "$INSTALL" == "/usr/local" ] || [ "$INSTALL" == "/usr" ] ; then
	error "Incompatible CMAKE_INSTALL_PREFIX for creating AppImage: @CMAKE_INSTALL_PREFIX@"
fi

echo -e "\nWriting verbose output to \"${LOGFILE}\""

# Ensure linuxdeployqt uses the same qmake version as cmake
PATH="$(pwd -P)/squashfs-root/usr/bin:$(dirname "@QT_QMAKE_EXECUTABLE@")":$PATH
export PATH

# Fetch portable linuxdeployqt if not in PATH
APPIMAGETOOL="squashfs-root/usr/bin/appimagetool"
echo -e "\nDownloading linuxdeployqt to ${LINUXDEPLOYQT}..."
if env -i which linuxdeployqt > /dev/null 2>&1; then
	skipped "System already provides this utility"
else
	filename="linuxdeployqt-continuous-$(uname -p).AppImage"
	url="https://github.com/probonopd/linuxdeployqt/releases/download/continuous/$filename"
	down_file="$(pwd)/$filename"
	if [ ! -f "$LINUXDEPLOYQT" ]; then
		ln -s "$down_file" "$LINUXDEPLOYQT"
	fi
	echo "   [.......] Downloading ($(uname -p)): ${url}"
	wget -N -q "$url" || (rm "$filename" && false)
	chmod +x "$LINUXDEPLOYQT"
	success "Downloaded $LINUXDEPLOYQT"
	# Extract AppImage and replace LINUXDEPLOYQT variable with extracted binary
	# to support systems without fuse
	# Also, we need to set LD_LIBRARY_PATH, but linuxdepoyqt's AppRun unsets it
	# See https://github.com/probonopd/linuxdeployqt/pull/370/
	"$LINUXDEPLOYQT" --appimage-extract > /dev/null 2>&1
	LINUXDEPLOYQT="squashfs-root/usr/bin/linuxdeployqt"
	success "Extracted $APPIMAGETOOL"
fi

# Make skeleton AppDir
echo -e "\nCreating ${APPDIR}..."
rm -rf "${APPDIR}"
mkdir -p "${APPDIR}usr"
success "Created ${APPDIR}"

# Clone install to AppDir
echo -e "\nCopying @CMAKE_INSTALL_PREFIX@ to ${APPDIR}..."
cp -R "@CMAKE_INSTALL_PREFIX@/." "${APPDIR}usr"
rm -rf "${APPDIR}usr/include"
success "${APPDIR}"

# Copy rawwaves directory for stk/mallets
mkdir -p "${APPDIR}usr/share/stk/"
cp -R /usr/share/stk/rawwaves/ "${APPDIR}usr/share/stk/"

# Create a wrapper script which calls the lmms executable
mv "${APPDIR}usr/bin/lmms" "${APPDIR}usr/bin/lmms.real"

cp "@CMAKE_CURRENT_SOURCE_DIR@/launch_lmms.sh" "${APPDIR}usr/bin/lmms"

chmod +x "${APPDIR}usr/bin/lmms"

# Per https://github.com/probonopd/linuxdeployqt/issues/129
unset LD_LIBRARY_PATH

# Ensure linuxdeployqt can find shared objects
export LD_LIBRARY_PATH="${APPDIR}"usr/lib/lmms/:"${APPDIR}"usr/lib/lmms/optional:"$LD_LIBRARY_PATH"

# Move executables so linuxdeployqt can find them
ZYNLIB="${APPDIR}usr/lib/lmms/RemoteZynAddSubFx"
VSTLIB32="${APPDIR}usr/lib/lmms/32/RemoteVstPlugin32.exe.so"
VSTLIB64="${APPDIR}usr/lib/lmms/RemoteVstPlugin64.exe.so"

ZYNBIN="${APPDIR}usr/bin/RemoteZynAddSubFx"
VSTBIN32="${APPDIR}usr/bin/RemoteVstPlugin32.exe.so"
VSTBIN64="${APPDIR}usr/bin/RemoteVstPlugin64.exe.so"

mv "$ZYNLIB" "$ZYNBIN"
mv "$VSTLIB32" "$VSTBIN32" || true
mv "$VSTLIB64" "$VSTBIN64" || true

# Handle wine linking
if [ -d "@WINE_32_LIBRARY_DIR@" ] && \
		ldd "$VSTBIN32" | grep "libwine\.so" | grep "not found"; then
   export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:"@WINE_32_LIBRARY_DIRS@"
fi
if [ -d "@WINE_64_LIBRARY_DIR@" ] && \
		ldd "$VSTBIN64" | grep "libwine\.so" | grep "not found"; then
   export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:"@WINE_64_LIBRARY_DIRS@"
fi

# Patch the desktop file
sed -i 's/.*Exec=.*/Exec=lmms.real/' "$DESKTOPFILE"

# Fix linking for soft-linked plugins
for file in "${APPDIR}usr/lib/lmms/"*.so; do
   thisfile="${APPDIR}usr/lib/lmms/${file##*/}"
   executables="${executables} -executable=$thisfile"
done
executables="${executables} -executable=${ZYNBIN}"
executables="${executables} -executable=${VSTBIN32}"
executables="${executables} -executable=${VSTBIN64}"
executables="${executables} -executable=${APPDIR}usr/lib/lmms/ladspa/imp_1199.so"
executables="${executables} -executable=${APPDIR}usr/lib/lmms/ladspa/imbeq_1197.so"
executables="${executables} -executable=${APPDIR}usr/lib/lmms/ladspa/pitch_scale_1193.so"
executables="${executables} -executable=${APPDIR}usr/lib/lmms/ladspa/pitch_scale_1194.so"

# Bundle both qt and non-qt dependencies into appimage format
echo -e "\nBundling and relinking system dependencies..."
echo -e ">>>>> linuxdeployqt" > "$LOGFILE"

# shellcheck disable=SC2086
"$LINUXDEPLOYQT" "$DESKTOPFILE" $executables -bundle-non-qt-libs -verbose=$VERBOSITY $STRIP >> "$LOGFILE" 2>&1
success "Bundled and relinked dependencies"

# Link to original location so lmms can find them
ln -sr  "$ZYNBIN" "$ZYNLIB"
ln -sr  "$VSTBIN32" "$VSTLIB32" || true
ln -sr  "$VSTBIN64" "$VSTLIB64" || true

# Remove wine library conflict
rm -f "${APPDIR}/usr/lib/libwine.so.1"

# Use system-provided carla
rm -f "${APPDIR}usr/lib/"libcarla*.so
rm -f "${APPDIR}usr/lib/lmms/optional/"libcarla*.so

# Remove bundled jack in LD_LIBRARY_PATH if exists
if [ -e "${APPDIR}/usr/lib/libjack.so.0" ]; then
   rm "${APPDIR}/usr/lib/libjack.so.0"
fi

# Bundle jack out of LD_LIBRARY_PATH
JACK_LIB=$(ldd "${APPDIR}/usr/bin/lmms.real" | sed -n 's/\tlibjack\.so\.0 => \(.\+\) (0x[0-9a-f]\+)/\1/p')
if [ -e "$JACK_LIB" ]; then
   mkdir -p "${APPDIR}usr/lib/lmms/optional/"
   cp "$JACK_LIB" "${APPDIR}usr/lib/lmms/optional/"
fi

# Point the AppRun to the shim launcher
rm -f "${APPDIR}/AppRun"
ln -sr "${APPDIR}/usr/bin/lmms" "${APPDIR}/AppRun"

# Create AppImage
echo -e "\nFinishing the AppImage..."
echo -e "\n\n>>>>> appimagetool" >> "$LOGFILE"
"$APPIMAGETOOL" "${APPDIR}" "@APPIMAGE_FILE@" >> "$LOGFILE" 2>&1
success "Created @APPIMAGE_FILE@"

echo -e "\nFinished"


code:
# A wrapper around pkg-config-provided and cmake-provided bash completion that
# will have dynamic behavior at INSTALL() time to allow both root-level
# INSTALL() as well as user-level INSTALL().
#
# See also https://github.com/scop/bash-completion
#
# Copyright (c) 2018, Tres Finocchiaro, <tres.finocchiaro@gmail.com>
# Redistribution and use is allowed according to the terms of the BSD license.
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
#
# Usage:
#    INCLUDE(BashCompletion)
#    BASHCOMP_INSTALL(foo)
#    ... where "foo" is a shell script adjacent to the CMakeLists.txt
#
# How it determines BASHCOMP_PKG_PATH, in order:
#    1. Uses BASHCOMP_PKG_PATH if already set (e.g. -DBASHCOMP_PKG_PATH=...)
#       a. If not, uses pkg-config's PKG_CHECK_MODULES to determine path
#       b. Fallback to cmake's FIND_PACKAGE(bash-completion) path
#       c. Fallback to hard-coded /usr/share/bash-completion/completions
#    2. Final fallback to ${CMAKE_INSTALL_PREFIX}/share/bash-completion/completions if
#       detected path is unwritable.

# - Windows does not support bash completion
# - macOS support should eventually be added for Homebrew (TODO)
IF(WIN32)
	MESSAGE(STATUS "Bash competion is not supported on this platform.")
ELSEIF(APPLE)
	MESSAGE(STATUS "Bash completion is not yet implemented for this platform.")
ELSE()
	INCLUDE(FindUnixCommands)
	# Honor manual override if provided
	IF(NOT BASHCOMP_PKG_PATH)
		# First, use pkg-config, which is the most reliable
		FIND_PACKAGE(PkgConfig QUIET)
		IF(PKGCONFIG_FOUND)
			PKG_CHECK_MODULES(BASH_COMPLETION bash-completion)
			PKG_GET_VARIABLE(BASHCOMP_PKG_PATH bash-completion completionsdir)
		ELSE()
			# Second, use cmake (preferred but less common)
			FIND_PACKAGE(bash-completion QUIET)
			IF(BASH_COMPLETION_FOUND)
				SET(BASHCOMP_PKG_PATH "${BASH_COMPLETION_COMPLETIONSDIR}")
			ENDIF()
		ENDIF()

		# Third, use a hard-coded fallback value
		IF("${BASHCOMP_PKG_PATH}" STREQUAL "")
			SET(BASHCOMP_PKG_PATH "/usr/share/bash-completion/completions")
		ENDIF()
	ENDIF()

	# Always provide a fallback for non-root INSTALL()
	SET(BASHCOMP_USER_PATH "${CMAKE_INSTALL_PREFIX}/share/bash-completion/completions")

	# Cmake doesn't allow easy use of conditional logic at INSTALL() time
	# this is a problem because ${BASHCOMP_PKG_PATH} may not be writable and we
	# need sane fallback behavior for bundled INSTALL() (e.g. .AppImage, etc).
	#
	# The reason this can't be detected by cmake is that it's fairly common to
	# run "cmake" as a one user (i.e. non-root) and "make install" as another user
	# (i.e. root).
	#
	# - Creates a script called "install_${SCRIPT_NAME}_completion.sh" into the
	#   working binary directory and invokes this script at install.
	# - Script handles INSTALL()-time conditional logic for sane ballback behavior
	#   when ${BASHCOMP_PKG_PATH} is unwritable (i.e. non-root); Something cmake
	#   can't handle on its own at INSTALL() time)
	MACRO(BASHCOMP_INSTALL SCRIPT_NAME)
		# A shell script for wrapping conditionl logic
		SET(BASHCOMP_SCRIPT "${CMAKE_CURRENT_BINARY_DIR}/install_${SCRIPT_NAME}_completion.sh")

		FILE(WRITE ${BASHCOMP_SCRIPT} "\
#!${BASH}\n\
set -e\n\
if [ -w \"${BASHCOMP_PKG_PATH}\" ]; then\n\
  BASHCOMP_PKG_PATH=\"${BASHCOMP_PKG_PATH}\"\n\
else \n\
  BASHCOMP_PKG_PATH=\"\$DESTDIR${BASHCOMP_USER_PATH}\"\n\
fi\n\
echo -e \"\\nInstalling bash completion...\\n\"\n\
mkdir -p \"\$BASHCOMP_PKG_PATH\"\n\
cp \"${CMAKE_CURRENT_SOURCE_DIR}/${SCRIPT_NAME}\" \"\$BASHCOMP_PKG_PATH\"\n\
chmod a+r \"\$BASHCOMP_PKG_PATH/${SCRIPT_NAME}\"\n\
echo -e \"Bash completion for ${SCRIPT_NAME} has been installed to \$BASHCOMP_PKG_PATH/${SCRIPT_NAME}\"\n\
")
		INSTALL(CODE "EXECUTE_PROCESS(COMMAND chmod u+x \"install_${SCRIPT_NAME}_completion.sh\" WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} )")
		INSTALL(CODE "EXECUTE_PROCESS(COMMAND \"./install_${SCRIPT_NAME}_completion.sh\" WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} )")

		MESSAGE(STATUS "Bash completion script for ${SCRIPT_NAME} will be installed to ${BASHCOMP_PKG_PATH} or fallback to ${BASHCOMP_USER_PATH} if unwritable.")
	ENDMACRO()
ENDIF()


code:
# BuildPlugin.cmake - Copyright (c) 2008 Tobias Doerffel
#
# description: build LMMS-plugin
# usage: BUILD_PLUGIN(<PLUGIN_NAME> <PLUGIN_SOURCES> MOCFILES <HEADERS_FOR_MOC> EMBEDDED_RESOURCES <LIST_OF_FILES_TO_EMBED> UICFILES <UI_FILES_TO_COMPILE> LINK <SHARED|MODULE>)

INCLUDE(GenQrc)

MACRO(BUILD_PLUGIN PLUGIN_NAME)
	CMAKE_PARSE_ARGUMENTS(PLUGIN "" "LINK;EXPORT_BASE_NAME" "MOCFILES;EMBEDDED_RESOURCES;UICFILES" ${ARGN})
	SET(PLUGIN_SOURCES ${PLUGIN_UNPARSED_ARGUMENTS})

	INCLUDE_DIRECTORIES("${CMAKE_CURRENT_BINARY_DIR}" "${CMAKE_BINARY_DIR}" "${CMAKE_SOURCE_DIR}/include")

	ADD_DEFINITIONS(-DPLUGIN_NAME=${PLUGIN_NAME})

	LIST(LENGTH PLUGIN_EMBEDDED_RESOURCES ER_LEN)
	IF(ER_LEN)
		# Expand and sort arguments to avoid locale dependent sorting in
		# shell
		SET(NEW_ARGS)
		FOREACH(ARG ${PLUGIN_EMBEDDED_RESOURCES})
			FILE(GLOB EXPANDED "${ARG}")
			LIST(SORT EXPANDED)
			FOREACH(ITEM ${EXPANDED})
				LIST(APPEND NEW_ARGS "${ITEM}")
			ENDFOREACH()
		ENDFOREACH()
		SET(PLUGIN_EMBEDDED_RESOURCES ${NEW_ARGS})

		ADD_GEN_QRC(RCC_OUT "${PLUGIN_NAME}.qrc" PREFIX artwork/${PLUGIN_NAME} ${PLUGIN_EMBEDDED_RESOURCES})
	ENDIF(ER_LEN)

	QT5_WRAP_CPP(plugin_MOC_out ${PLUGIN_MOCFILES})
	QT5_WRAP_UI(plugin_UIC_out ${PLUGIN_UICFILES})

	FOREACH(f ${PLUGIN_SOURCES})
		ADD_FILE_DEPENDENCIES(${f} ${RCC_OUT} ${plugin_UIC_out})
	ENDFOREACH(f)

	IF(LMMS_BUILD_APPLE)
		LINK_DIRECTORIES("${CMAKE_BINARY_DIR}")
		LINK_LIBRARIES(${QT_LIBRARIES})
	ENDIF(LMMS_BUILD_APPLE)
	IF(LMMS_BUILD_WIN32)
		LINK_DIRECTORIES("${CMAKE_BINARY_DIR}" "${CMAKE_SOURCE_DIR}")
		LINK_LIBRARIES(${QT_LIBRARIES})
	ENDIF(LMMS_BUILD_WIN32)
	IF(LMMS_BUILD_MSYS AND CMAKE_BUILD_TYPE STREQUAL "Debug")
		# Override Qt debug libraries with release versions
		SET(QT_LIBRARIES "${QT_OVERRIDE_LIBRARIES}")
	ENDIF()

	IF (NOT PLUGIN_LINK)
		SET(PLUGIN_LINK "MODULE")
	ENDIF()

	ADD_LIBRARY(${PLUGIN_NAME} ${PLUGIN_LINK} ${PLUGIN_SOURCES} ${plugin_MOC_out} ${RCC_OUT})

	TARGET_LINK_LIBRARIES(${PLUGIN_NAME} Qt5::Widgets Qt5::Xml)

	IF(LMMS_BUILD_WIN32)
		TARGET_LINK_LIBRARIES(${PLUGIN_NAME} lmms)
	ENDIF(LMMS_BUILD_WIN32)

	INSTALL(TARGETS ${PLUGIN_NAME}
		LIBRARY DESTINATION "${PLUGIN_DIR}"
		RUNTIME DESTINATION "${PLUGIN_DIR}"
	)

	IF(LMMS_BUILD_APPLE)
		IF ("${PLUGIN_LINK}" STREQUAL "SHARED")
			SET_TARGET_PROPERTIES(${PLUGIN_NAME} PROPERTIES LINK_FLAGS "-undefined dynamic_lookup")
		ELSE()
			SET_TARGET_PROPERTIES(${PLUGIN_NAME} PROPERTIES LINK_FLAGS "-bundle_loader \"${CMAKE_BINARY_DIR}/lmms\"")
		ENDIF()
		ADD_DEPENDENCIES(${PLUGIN_NAME} lmms)
	ENDIF(LMMS_BUILD_APPLE)
	IF(LMMS_BUILD_WIN32)
		IF(STRIP)
			ADD_CUSTOM_COMMAND(TARGET ${PLUGIN_NAME} POST_BUILD COMMAND ${STRIP} "$<TARGET_FILE:${PLUGIN_NAME}>")
		ENDIF()
		SET_TARGET_PROPERTIES(${PLUGIN_NAME} PROPERTIES PREFIX "")
	ENDIF()

	SET_DIRECTORY_PROPERTIES(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "${RCC_OUT} ${plugin_MOC_out}")

	IF(NOT PLUGIN_EXPORT_BASE_NAME)
		SET(PLUGIN_EXPORT_BASE_NAME "PLUGIN")
	ENDIF()

	GENERATE_EXPORT_HEADER(${PLUGIN_NAME}
		BASE_NAME ${PLUGIN_EXPORT_BASE_NAME}
	)
	TARGET_INCLUDE_DIRECTORIES(${PLUGIN_NAME}
		PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>
	)

	SET_PROPERTY(GLOBAL APPEND PROPERTY PLUGINS_BUILT ${PLUGIN_NAME})
	GET_PROPERTY(PLUGINS_BUILT GLOBAL PROPERTY PLUGINS_BUILT)
ENDMACRO(BUILD_PLUGIN)


code:
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:

1. Redistributions of source code must retain the copyright
   notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the copyright
   notice, this list of conditions and the following disclaimer in the
   documentation and/or other materials provided with the distribution.
3. The name of the author may not be used to endorse or promote products
   derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

path: cmake/modules/COPYING-CMAKE-SCRIPTS


code:
macro(CHECK_CXX_PREPROCESSOR VAR DIRECTIVE)
	string(RANDOM DEFINED_KEY)
	string(RANDOM UNDEFINED_KEY)

	set(TMP_FILENAME "${CMAKE_CURRENT_BINARY_DIR}/CxxTmp/src.cpp")
	SET(SRC "
		#if ${DIRECTIVE}
		#error ${DEFINED_KEY}
		#else
		#error ${UNDEFINED_KEY}
		#endif
		")
	file(WRITE ${TMP_FILENAME} "${SRC}")
	try_compile(RESULT_VAR
		${CMAKE_CURRENT_BINARY_DIR}
		${TMP_FILENAME}
		OUTPUT_VARIABLE OUTPUT_VAR
	)

	if(OUTPUT_VAR MATCHES ${DEFINED_KEY})
		set(${VAR} ON)
	elseif(OUTPUT_VAR MATCHES ${UNDEFINED_KEY})
		set(${VAR} OFF)
	else()
		message(FATAL_ERROR "Can't determine if \"${DIRECTIVE}\" is true.")
	endif()
endmacro()

macro(CHECK_CXX_DEFINE VAR DEFINE)
	CHECK_CXX_PREPROCESSOR(${VAR} "defined(${DEFINE})")
endmacro()


code:
# Utility for validating and, if needed, cloning all submodules
#
# Looks for a .gitmodules in the root project folder
# Loops over all modules looking well-known configure/build scripts
#
# Usage:
#       INCLUDE(CheckSubmodules)
#
# Options:
#       SET(PLUGIN_LIST "zynaddsubfx;...") # skips submodules for plugins not explicitely listed
#
# Or via command line:
#       cmake -PLUGIN_LIST=foo;bar
#
# Copyright (c) 2019, Tres Finocchiaro, <tres.finocchiaro@gmail.com>
#
# Redistribution and use is allowed according to the terms of the BSD license.
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.

# Files which confirm a successful clone
SET(VALID_CRUMBS "CMakeLists.txt;Makefile;Makefile.in;Makefile.am;configure.ac;configure.py;autogen.sh;.gitignore;LICENSE;Home.md")

OPTION(NO_SHALLOW_CLONE "Disable shallow cloning of submodules" OFF)

# Try and use the specified shallow clone on submodules, if supported
SET(DEPTH_VALUE 100)

# Number of times git commands will retry before failing
SET(MAX_ATTEMPTS 2)

MESSAGE("\nChecking submodules...")
IF(NOT EXISTS "${CMAKE_SOURCE_DIR}/.gitmodules")
	MESSAGE("Skipping the check because .gitmodules not detected."
		"Please make sure you have all submodules in the source tree!"
	)
	RETURN()
ENDIF()
FILE(READ "${CMAKE_SOURCE_DIR}/.gitmodules" SUBMODULE_DATA)

# Force English locale
SET(LC_ALL_BACKUP "$ENV{LC_ALL}")
SET(LANG_BACKUP "$ENV{LANG}")
SET(ENV{LC_ALL} "C")
SET(ENV{LANG} "en_US")

# Submodule list pairs, unparsed (WARNING: Assumes alpha-numeric paths)
STRING(REGEX MATCHALL "path = [-0-9A-Za-z/]+" SUBMODULE_LIST_RAW ${SUBMODULE_DATA})
STRING(REGEX MATCHALL "url = [.:%-0-9A-Za-z/]+" SUBMODULE_URL_RAW ${SUBMODULE_DATA})

# Submodule list pairs, parsed
SET(SUBMODULE_LIST "")
SET(SUBMODULE_URL "")

FOREACH(_path ${SUBMODULE_LIST_RAW})
	# Parse SUBMODULE_PATH
	STRING(REPLACE "path = " "" SUBMODULE_PATH "${_path}")

	# Grab index for matching SUBMODULE_URL
	LIST(FIND SUBMODULE_LIST_RAW "${_path}" SUBMODULE_INDEX)
	LIST(GET SUBMODULE_URL_RAW ${SUBMODULE_INDEX} _url)

	# Parse SUBMODULE_URL
	STRING(REPLACE "url = " "" SUBMODULE_URL "${_url}")

	SET(SKIP false)

	# Loop over skipped plugins, add to SKIP_SUBMODULES (e.g. -DPLUGIN_LIST=foo;bar)
	IF(${SUBMODULE_PATH} MATCHES "^plugins/")
		SET(REMOVE_PLUGIN true)
		FOREACH(_plugin ${PLUGIN_LIST})
			IF(_plugin STREQUAL "")
				CONTINUE()
			ENDIF()
			IF(${SUBMODULE_PATH} MATCHES "${_plugin}")
				SET(REMOVE_PLUGIN false)
			ENDIF()
		ENDFOREACH()

		IF(REMOVE_PLUGIN)
			LIST(APPEND SKIP_SUBMODULES "${SUBMODULE_PATH}")
		ENDIF()
	ENDIF()

	# Finally, loop and mark "SKIP" on match
	IF(SKIP_SUBMODULES)
		FOREACH(_skip ${SKIP_SUBMODULES})
			IF("${SUBMODULE_PATH}" MATCHES "${_skip}")
				MESSAGE("-- Skipping ${SUBMODULE_PATH} matches \"${_skip}\" (absent in PLUGIN_LIST)")
				SET(SKIP true)
				BREAK()
			ENDIF()
		ENDFOREACH()
	ENDIF()

	IF(NOT SKIP)
		LIST(APPEND SUBMODULE_LIST "${SUBMODULE_PATH}")
		LIST(APPEND SUBMODULE_URL "${SUBMODULE_URL}")
	ENDIF()
ENDFOREACH()

# Once called, status is stored in GIT_RESULT respectively.
# Note: Git likes to write to stderr.  Don't assume stderr is error; Check GIT_RESULT instead.
MACRO(GIT_SUBMODULE SUBMODULE_PATH FORCE_DEINIT FORCE_REMOTE NO_DEPTH)
	FIND_PACKAGE(Git REQUIRED)
	# Handle missing commits
	SET(FORCE_REMOTE_FLAG "${FORCE_REMOTE}")
	SET(NO_DEPTH_FLAG "${NO_DEPTH}")
	IF(FORCE_REMOTE_FLAG)
		MESSAGE("--   Adding remote submodulefix to ${SUBMODULE_PATH}")
		EXECUTE_PROCESS(
			COMMAND "${GIT_EXECUTABLE}" remote rm submodulefix
			COMMAND "${GIT_EXECUTABLE}" remote add submodulefix ${FORCE_REMOTE}
			COMMAND "${GIT_EXECUTABLE}" fetch submodulefix
			WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}/${SUBMODULE_PATH}"
			OUTPUT_QUIET ERROR_QUIET
		)
		# Recurse
		GIT_SUBMODULE(${SUBMODULE_PATH} false false ${NO_DEPTH_FLAG})
	ELSEIF(${FORCE_DEINIT})
		MESSAGE("--   Resetting ${SUBMODULE_PATH}")
		EXECUTE_PROCESS(
			COMMAND "${GIT_EXECUTABLE}" submodule deinit -f "${CMAKE_SOURCE_DIR}/${SUBMODULE_PATH}"
			WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
			OUTPUT_QUIET
		)
		MESSAGE("--   Deleting ${CMAKE_SOURCE_DIR}/.git/${SUBMODULE_PATH}")
		FILE(REMOVE_RECURSE "${CMAKE_SOURCE_DIR}/.git/modules/${SUBMODULE_PATH}")
		# Recurse without depth
		GIT_SUBMODULE(${SUBMODULE_PATH} false false true)
	ELSE()
		# Try to use the depth switch
		IF(NO_SHALLOW_CLONE OR GIT_VERSION_STRING VERSION_LESS "1.8.4" OR NO_DEPTH_FLAG)
			# Shallow submodules were introduced in 1.8.4
			MESSAGE("--   Fetching ${SUBMODULE_PATH}")
			SET(DEPTH_CMD "")
			SET(DEPTH_VAL "")
		ELSE()
			MESSAGE("--   Fetching ${SUBMODULE_PATH} @ --depth ${DEPTH_VALUE}")
			SET(DEPTH_CMD "--depth")
			SET(DEPTH_VAL "${DEPTH_VALUE}")
		ENDIF()

		EXECUTE_PROCESS(
			COMMAND "${GIT_EXECUTABLE}" submodule update --init --recursive ${DEPTH_CMD} ${DEPTH_VAL} "${CMAKE_SOURCE_DIR}/${SUBMODULE_PATH}"
			WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
			RESULT_VARIABLE GIT_RESULT
			OUTPUT_VARIABLE GIT_STDOUT
			ERROR_VARIABLE GIT_STDERR
		)

		SET(GIT_MESSAGE "${GIT_STDOUT}${GIT_STDERR}")
		MESSAGE("${GIT_MESSAGE}")
	ENDIF()
ENDMACRO()

SET(MISSING_COMMIT_PHRASES "no such remote ref;reference is not a tree;unadvertised object")
SET(RETRY_PHRASES "Failed to recurse;cannot create directory;already exists;${MISSING_COMMIT_PHRASES}")

# Attempt to do lazy clone
FOREACH(_submodule ${SUBMODULE_LIST})
	STRING(REPLACE "/" ";" PATH_PARTS "${_submodule}")
	LIST(REVERSE PATH_PARTS)
	LIST(GET PATH_PARTS 0 SUBMODULE_NAME)

	MESSAGE("-- Checking ${SUBMODULE_NAME}...")
	SET(CRUMB_FOUND false)
	FOREACH(_crumb ${VALID_CRUMBS})
		IF(EXISTS "${CMAKE_SOURCE_DIR}/${_submodule}/${_crumb}")
			SET(CRUMB_FOUND true)
			MESSAGE("--   Found ${_submodule}/${_crumb}")
			BREAK()
		ENDIF()
	ENDFOREACH()
	IF(NOT CRUMB_FOUND)
		GIT_SUBMODULE("${_submodule}" false false false)

		SET(COUNTED 0)
		# Handle edge-cases where submodule didn't clone properly or re-uses a non-empty directory
		WHILE(NOT GIT_RESULT EQUAL 0 AND COUNTED LESS MAX_ATTEMPTS)
			MATH(EXPR COUNTED "${COUNTED}+1")
			SET(MISSING_COMMIT false)
			FOREACH(_phrase ${MISSING_COMMIT_PHRASES})
				IF("${GIT_MESSAGE}" MATCHES "${_phrase}")
					SET(MISSING_COMMIT true)
					BREAK()
				ENDIF()
			ENDFOREACH()
			FOREACH(_phrase ${RETRY_PHRASES})
				IF(${MISSING_COMMIT} AND COUNTED LESS 2)
					LIST(FIND SUBMODULE_LIST ${_submodule} SUBMODULE_INDEX)
					LIST(GET SUBMODULE_URL_LIST ${SUBMODULE_INDEX} SUBMODULE_URL)
					MESSAGE("--   Retrying ${_submodule} using 'remote add submodulefix' (attempt ${COUNTED} of ${MAX_ATTEMPTS})...")

					GIT_SUBMODULE("${_submodule}" false "${SUBMODULE_URL}" false)
					BREAK()
				ELSEIF("${GIT_MESSAGE}" MATCHES "${_phrase}")
					MESSAGE("--   Retrying ${_submodule} using 'deinit' (attempt ${COUNTED} of ${MAX_ATTEMPTS})...")
					GIT_SUBMODULE("${_submodule}" true false false)
					BREAK()
				ENDIF()
			ENDFOREACH()
		ENDWHILE()

		IF(NOT GIT_RESULT EQUAL 0)
			MESSAGE(FATAL_ERROR "${GIT_EXECUTABLE} exited with status of ${GIT_RESULT}")
		ENDIF()
	ENDIF()
ENDFOREACH()
MESSAGE("-- Done validating submodules.\n")

# Reset locale
SET(ENV{LC_ALL} "${LC_ALL_BACKUP}")
SET(ENV{LANG} "${LANG_BACKUP}")


code:
INCLUDE(CheckCXXSourceCompiles)

FUNCTION(CheckWineGcc BITNESS WINEGCC_EXECUTABLE RESULT)
	FILE(WRITE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/winegcc_test.cxx" "
	#include <iostream>
	#define USE_WS_PREFIX
	#include <windows.h>
	int main(int argc, const char* argv[]) {
		return 0;
	}
	")
	EXECUTE_PROCESS(COMMAND ${WINEGCC_EXECUTABLE} "-m${BITNESS}"
		"${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/winegcc_test.cxx"
		"-o" "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/winegcc_test"
		OUTPUT_QUIET ERROR_QUIET
		RESULT_VARIABLE WINEGCC_RESULT
	)
	FILE(REMOVE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/winegcc_test.cxx"
		"${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/winegcc_test"
		"${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/winegcc_test.exe.so"
	)
	IF(WINEGCC_RESULT EQUAL 0)
		SET(${RESULT} True PARENT_SCOPE)
	ELSE()
		SET(${RESULT} False PARENT_SCOPE)
	ENDIF()
ENDFUNCTION()


code:
option(USE_COMPILE_CACHE "Use ccache or clcache for compilation" OFF)

# Compatibility for old option name
if(USE_CCACHE)
	set(USE_COMPILE_CACHE ON)
endif()

if(USE_COMPILE_CACHE)
	if(MSVC)
		set(CACHE_TOOL_NAME clcache)
	elseif(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|AppleClang|Clang)")
		set(CACHE_TOOL_NAME ccache)
	else()
		message(WARNING "Compile cache only available with MSVC or GNU")
	endif()

	find_program(CACHE_TOOL ${CACHE_TOOL_NAME})
	if (CACHE_TOOL)
		message(STATUS "Using ${CACHE_TOOL} found for caching")
		set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ${CACHE_TOOL})
		set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ${CACHE_TOOL})
	else()
		message(WARNING "USE_COMPILE_CACHE enabled, but no ${CACHE_TOOL_NAME} found")
	endif()
endif()


code:
function(CreateTempFilePath)
    set(options CONFIG_SUFFIX)
    set(oneValueArgs OUTPUT_VAR TAG)
    set(multiValueArgs CONTENT)
    cmake_parse_arguments(TEMP "${options}" "${oneValueArgs}"
            "${multiValueArgs}" ${ARGN} )

    # Use hash to create a unique identifier
    # for this file.
    string(SHA1 hashed_content "${TEMP_CONTENT}")

    set(file_name "${CMAKE_BINARY_DIR}/${TEMP_TAG}_${hashed_content}")
    set(${TEMP_OUTPUT_VAR} "${file_name}" PARENT_SCOPE)
    if(CONFIG_SUFFIX)
        set(file_name "${file_name}_$<CONFIG>")
    endif()

    file(GENERATE OUTPUT "${file_name}"
            CONTENT "${TEMP_CONTENT}")

endfunction()


code:
# This functions forwards a variable to
# the install stage.
# Parameters:
#   CONTENT: Variable content.
#   NAME: Variable name.
# Options:
#   GENERATOR_EXPRESSION: Support generator expression for CONTENT.
function(DEFINE_INSTALL_VAR)
    set(options GENERATOR_EXPRESSION)
    set(oneValueArgs NAME )
    set(multiValueArgs CONTENT)
    cmake_parse_arguments(VAR "${options}" "${oneValueArgs}"
            "${multiValueArgs}" ${ARGN} )

    # install(CODE) does not support generator expression in ver<3.14
    if(VAR_GENERATOR_EXPRESSION AND ${CMAKE_VERSION} VERSION_LESS "3.14.0")
        include(CreateTempFile)
        if(CMAKE_CONFIGURATION_TYPES) # in case of multi-config generators like MSVC generators
            CreateTempFilePath(OUTPUT_VAR file_path TAG "${VAR_NAME}" CONTENT "${VAR_CONTENT}" CONFIG_SUFFIX)
            install(CODE "file(READ \"${file_path}_\${CMAKE_INSTALL_CONFIG_NAME}\" \"${VAR_NAME}\")")
        else()
            CreateTempFilePath(OUTPUT_VAR file_path TAG "${VAR_NAME}" CONTENT "${VAR_CONTENT}")
            install(CODE "file(READ \"${file_path}\" \"${VAR_NAME}\")")
        endif()
    else()
        if(VAR_GENERATOR_EXPRESSION)
            cmake_policy(SET CMP0087 NEW)
        endif()
        install(CODE "set(\"${VAR_NAME}\" \"${VAR_CONTENT}\")")
    endif()
endfunction()


code:
IF(WIN32)
	SET(LMMS_BUILD_WIN32 1)
ELSEIF(APPLE)
	SET(LMMS_BUILD_APPLE 1)
ELSEIF(${CMAKE_SYSTEM_NAME} MATCHES "OpenBSD")
	SET(LMMS_BUILD_OPENBSD 1)
ELSEIF(${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
	SET(LMMS_BUILD_FREEBSD 1)
ELSEIF(HAIKU)
	SET(LMMS_BUILD_HAIKU 1)
ELSE()
	SET(LMMS_BUILD_LINUX 1)
ENDIF(WIN32)

# LMMS_BUILD_MSYS also set in build_winXX.sh
IF(LMMS_BUILD_WIN32 AND CMAKE_COMPILER_IS_GNUCXX AND DEFINED ENV{MSYSCON})
	SET(LMMS_BUILD_MSYS TRUE)
ENDIF()

MESSAGE("PROCESSOR: ${CMAKE_SYSTEM_PROCESSOR}")
SET(LMMS_HOST_X86 FALSE)
SET(LMMS_HOST_X86_64 FALSE)

IF(NOT DEFINED WIN64 AND CMAKE_SIZEOF_VOID_P EQUAL 8)
    SET(WIN64 ON)
ENDIF()

IF(WIN32)
	IF(WIN64)
		SET(IS_X86_64 TRUE)
		SET(LMMS_BUILD_WIN64 TRUE)
	ELSE(WIN64)
		SET(IS_X86 TRUE)
	ENDIF(WIN64)

	if(MSVC)
		SET(MSVC_VER ${CMAKE_CXX_COMPILER_VERSION})

		IF(MSVC_VER VERSION_GREATER 19.20 OR MSVC_VER VERSION_EQUAL 19.20)
			SET(LMMS_MSVC_GENERATOR "Visual Studio 16 2019")
			SET(LMMS_MSVC_YEAR 2019) # Qt only provides binaries for MSVC 2017, but 2019 is binary compatible
		ELSEIF(MSVC_VER VERSION_GREATER 19.10 OR MSVC_VER VERSION_EQUAL 19.10)
			SET(LMMS_MSVC_GENERATOR "Visual Studio 15 2017")
			SET(LMMS_MSVC_YEAR 2017)
		ELSEIF(MSVC_VER VERSION_GREATER 19.0 OR MSVC_VER VERSION_EQUAL 19.0)
			SET(LMMS_MSVC_GENERATOR "Visual Studio 14 2015")
			SET(LMMS_MSVC_YEAR 2015)
		ELSE()
			MESSAGE(SEND_WARNING "Can't detect MSVC version: ${MSVC_VER}")
		ENDIF()

		unset(MSVC_VER)
	endif()
ELSE(WIN32)
	EXEC_PROGRAM( ${CMAKE_C_COMPILER} ARGS "-dumpmachine ${CMAKE_C_FLAGS}" OUTPUT_VARIABLE Machine )
	MESSAGE("Machine: ${Machine}")
	STRING(REGEX MATCH "i.86" IS_X86 "${Machine}")
	STRING(REGEX MATCH "86_64|amd64" IS_X86_64 "${Machine}")
ENDIF(WIN32)

IF(IS_X86)
	MESSAGE("-- Target host is 32 bit")
	SET(LMMS_HOST_X86 TRUE)
ELSEIF(IS_X86_64)
	MESSAGE("-- Target host is 64 bit")
	SET(LMMS_HOST_X86_64 TRUE)
ELSE(IS_X86)
	MESSAGE("Can't identify target host. Assuming 32 bit platform.")
ENDIF(IS_X86)

IF(CMAKE_INSTALL_LIBDIR)
	SET(LIB_DIR "${CMAKE_INSTALL_LIBDIR}")
ELSE(CMAKE_INSTALL_LIBDIR)
	SET(LIB_DIR lib)
ENDIF(CMAKE_INSTALL_LIBDIR)

IF(LMMS_BUILD_WIN32)
	SET(BIN_DIR .)
	SET(PLUGIN_DIR plugins)
	SET(DATA_DIR data)
	SET(LMMS_DATA_DIR data)
ELSE(LMMS_BUILD_WIN32)
	SET(BIN_DIR bin)
	SET(PLUGIN_DIR ${LIB_DIR}/lmms)
	SET(DATA_DIR share)
	SET(LMMS_DATA_DIR ${DATA_DIR}/lmms)
ENDIF(LMMS_BUILD_WIN32)

IF(LMMS_BUILD_APPLE)
	# Detect Homebrew versus Macports environment
	EXECUTE_PROCESS(COMMAND brew --prefix RESULT_VARIABLE DETECT_HOMEBREW OUTPUT_VARIABLE HOMEBREW_PREFIX ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
	EXECUTE_PROCESS(COMMAND which port RESULT_VARIABLE DETECT_MACPORTS OUTPUT_VARIABLE MACPORTS_PREFIX ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
	IF(${DETECT_HOMEBREW} EQUAL 0)
       		SET(HOMEBREW 1)
        	SET(APPLE_PREFIX "${HOMEBREW_PREFIX}")
	ELSEIF(${DETECT_MACPORTS} EQUAL 0)
        	SET(MACPORTS 1)
        	GET_FILENAME_COMPONENT(MACPORTS_PREFIX ${MACPORTS_PREFIX} DIRECTORY)
		GET_FILENAME_COMPONENT(MACPORTS_PREFIX ${MACPORTS_PREFIX} DIRECTORY)
		SET(APPLE_PREFIX "${MACPORTS_PREFIX}")
        	LINK_DIRECTORIES(${LINK_DIRECTORIES} ${APPLE_PREFIX}/lib)
	ENDIF()

	# Detect OS Version
	EXECUTE_PROCESS(COMMAND sw_vers -productVersion OUTPUT_VARIABLE APPLE_OS_VER ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
	STRING(REGEX REPLACE "\\.[0-9]*$" "" APPLE_OS_VER "${APPLE_OS_VER}")
	SET(CMAKE_MACOSX_RPATH 1)
ENDIF()


code:
# Alsa check, based on libkmid/configure.in.in.
# Only the support for Alsa >= 0.9.x was included; 0.5.x was dropped (but feel free to re-add it if you need it)
# It defines ...
# It offers the following macros:
#  ALSA_CONFIGURE_FILE(config_header) - generate a config.h, typical usage:
#                                       ALSA_CONFIGURE_FILE(${CMAKE_BINARY_DIR}/config-alsa.h)
#  ALSA_VERSION_STRING(version_string)  looks for alsa/version.h and reads the version string into
#                                       the first argument passed to the macro

# Copyright (c) 2006, David Faure, <faure@kde.org>
# Copyright (c) 2007, Matthias Kretz <kretz@kde.org>
#
# Redistribution and use is allowed according to the terms of the BSD license.
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.

include(CheckIncludeFiles)
include(CheckIncludeFileCXX)
include(CheckLibraryExists)

# Already done by toplevel
find_library(ASOUND_LIBRARY asound)
set(ASOUND_LIBRARY_DIR "")
if(ASOUND_LIBRARY)
   get_filename_component(ASOUND_LIBRARY_DIR ${ASOUND_LIBRARY} PATH)
endif(ASOUND_LIBRARY)

check_library_exists(asound snd_seq_create_simple_port "${ASOUND_LIBRARY_DIR}" HAVE_LIBASOUND2)
if(HAVE_LIBASOUND2)
    message(STATUS "Found ALSA: ${ASOUND_LIBRARY}")
else(HAVE_LIBASOUND2)
    message(STATUS "ALSA not found")
endif(HAVE_LIBASOUND2)
set(ALSA_FOUND ${HAVE_LIBASOUND2})

find_path(ALSA_INCLUDES alsa/version.h)

macro(ALSA_VERSION_STRING _result)
    # check for version in alsa/version.h
    if(ALSA_INCLUDES)
        file(READ "${ALSA_INCLUDES}/alsa/version.h" _ALSA_VERSION_CONTENT)
        string(REGEX REPLACE ".*SND_LIB_VERSION_STR.*\"(.*)\".*" "\\1" ${_result} ${_ALSA_VERSION_CONTENT})
    else(ALSA_INCLUDES)
        message(STATUS "ALSA version not known. ALSA output will probably not work correctly.")
    endif(ALSA_INCLUDES)
endmacro(ALSA_VERSION_STRING _result)

check_include_files(sys/soundcard.h LMMS_HAVE_SYS_SOUNDCARD_H)
check_include_files(machine/soundcard.h LMMS_HAVE_MACHINE_SOUNDCARD_H)

check_include_files(linux/awe_voice.h LMMS_HAVE_LINUX_AWE_VOICE_H)
check_include_files(awe_voice.h LMMS_HAVE_AWE_VOICE_H)
check_include_files(/usr/src/sys/i386/isa/sound/awe_voice.h LMMS_HAVE__USR_SRC_SYS_I386_ISA_SOUND_AWE_VOICE_H)
check_include_files(/usr/src/sys/gnu/i386/isa/sound/awe_voice.h LMMS_HAVE__USR_SRC_SYS_GNU_I386_ISA_SOUND_AWE_VOICE_H)

check_include_file_cxx(sys/asoundlib.h LMMS_HAVE_SYS_ASOUNDLIB_H)
check_include_file_cxx(alsa/asoundlib.h LMMS_HAVE_ALSA_ASOUNDLIB_H)

check_library_exists(asound snd_pcm_resume "${ASOUND_LIBRARY_DIR}" ASOUND_HAS_SND_PCM_RESUME)
if(ASOUND_HAS_SND_PCM_RESUME)
set(HAVE_SND_PCM_RESUME 1)
endif(ASOUND_HAS_SND_PCM_RESUME)

mark_as_advanced(ALSA_INCLUDES ASOUND_LIBRARY)