mirrors/SFML
1
0
Fork 0
mirror of https://github.com/SFML/SFML.git synced 2024-11-28 22:31:09 +08:00
Code Issues Packages Projects Releases Wiki Activity

Synchronized with trunk

Browse Source 
git-svn-id: https://sfml.svn.sourceforge.net/svnroot/sfml/branches/sfml2@1442 4e206d99-4929-0410-ac5d-dfc041789085
This commit is contained in:
LaurentGom 2010-03-05 11:05:30 +00:00
commit 4e93cc92fa
18 changed files with 1196 additions and 471 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

474
build/xcode/dist/autogen.sh vendored
View File

@ -35,20 +35,45 @@ XCODE_C_ROOT_DIR="$ROOT_DIR/CSFML/xcode"
XCODE_CXX_ROOT_DIR="$ROOT_DIR/build/xcode"
XCODE_SAMPLES_ROOT_DIR="$ROOT_DIR/samples/build/xcode"
XCODE_FRAMEWORKS_PROJECT="SFML.xcodeproj"
XCODE_64B_FRAMEWORKS_PROJECT="SFML with Intel 64 bits.xcodeproj"
XCODE_LIBRARIES_PROJECT="SFML-bare.xcodeproj"
XCODE_SAMPLES_PROJECT="samples.xcodeproj"
XCODE_64B_SAMPLES_PROJECT="samples with Intel 64 bits.xcodeproj"
XCODE_BUILD_STYLE="Release"
XCODE_C_TARGETS=("SFML" "csfml-system" "csfml-network" "csfml-audio" "csfml-window" "csfml-graphics")
XCODE_CXX_TARGETS=("SFML" "sfml-system" "sfml-network" "sfml-audio" "sfml-window" "sfml-graphics")
C_FRAMEWORKS_DIR="$ROOT_DIR/CSFML/lib"
CXX_FRAMEWORKS_DIR="$ROOT_DIR/lib"
CXX_SAMPLES_DIR="$ROOT_DIR/samples/bin"
PACKAGES_ROOT_DIR="$ROOT_DIR/dist"
CXX_SDK_PACKAGE="SFML-$SFML_VERSION-sdk-$OS"
CXX_DEV_PACKAGE="SFML-$SFML_VERSION-dev-$OS"
C_SDK_PACKAGE="SFML-$SFML_VERSION-c-sdk-$OS"
C_DEV_PACKAGE="SFML-$SFML_VERSION-c-dev-$OS"
# Architectures
ARCH_32B="ub32" # ppc + i386
ARCH_3264B="ub32+64" # ppc + i386 + x86_64
ARCH_64B="$ARCH_3264B" # same as 3264B for now
C_FRAMEWORKS_DIR="$ROOT_DIR/CSFML/lib" # target directory for C frameworks
CXX_FRAMEWORKS_DIR="$ROOT_DIR/lib" # target directory for C++ frameworks
CXX_32B_FRAMEWORKS_DIR="$CXX_FRAMEWORKS_DIR" # target directory for '32b' C++ frameworks
CXX_64B_FRAMEWORKS_DIR="$ROOT_DIR/lib/$ARCH_3264B" # target directory for '3264b' C++ frameworks
CXX_SAMPLES_DIR="$ROOT_DIR/samples/bin" # target directory for C++ samples
PACKAGES_ROOT_DIR="$ROOT_DIR/dist" # target directory for '32b' packages
PACKAGES_ROOT_DIR_64B="$PACKAGES_ROOT_DIR/$ARCH_64B" # target directory for '64b' packages
# Packages names (default, 32 bits, 64 bits)
CXX_SDK_PACKAGE="SFML-$SFML_VERSION-sdk-$OS-$ARCH_32B"
CXX_DEV_PACKAGE="SFML-$SFML_VERSION-dev-$OS-$ARCH_32B"
C_SDK_PACKAGE="SFML-$SFML_VERSION-c-sdk-$OS-$ARCH_32B"
C_DEV_PACKAGE="SFML-$SFML_VERSION-c-dev-$OS-$ARCH_32B"
CXX_SDK_PACKAGE_32B="$CXX_SDK_PACKAGE"
CXX_DEV_PACKAGE_32B="$CXX_DEV_PACKAGE"
C_SDK_PACKAGE_32B="$C_SDK_PACKAGE"
C_DEV_PACKAGE_32B="$C_DEV_PACKAGE"
CXX_SDK_PACKAGE_64B="SFML-$SFML_VERSION-sdk-$OS-$ARCH_64B"
CXX_DEV_PACKAGE_64B="SFML-$SFML_VERSION-dev-$OS-$ARCH_64B"
C_SDK_PACKAGE_64B="SFML-$SFML_VERSION-c-sdk-$OS-$ARCH_64B"
C_DEV_PACKAGE_64B="SFML-$SFML_VERSION-c-dev-$OS-$ARCH_64B"
# Package directories
CXX_SDK_PACKAGE_DIR="$PACKAGES_ROOT_DIR/$CXX_SDK_PACKAGE"
CXX_DEV_PACKAGE_DIR="$PACKAGES_ROOT_DIR/$CXX_DEV_PACKAGE"
C_SDK_PACKAGE_DIR="$PACKAGES_ROOT_DIR/$C_SDK_PACKAGE"
@ -57,6 +82,11 @@ C_DEV_PACKAGE_DIR="$PACKAGES_ROOT_DIR/$C_DEV_PACKAGE"
C_DEV_PACKAGE_SUB_DIR="$PACKAGES_ROOT_DIR/$C_DEV_PACKAGE/CSFML"
PACKAGES_INFO_FILES_DIR="$XCODE_CXX_ROOT_DIR/dist"
CXX_SDK_PACKAGE_DIR_64B="$PACKAGES_ROOT_DIR_64B/$CXX_SDK_PACKAGE_64B"
CXX_DEV_PACKAGE_DIR_64B="$PACKAGES_ROOT_DIR_64B/$CXX_DEV_PACKAGE_64B"
C_SDK_PACKAGE_DIR_64B="$PACKAGES_ROOT_DIR_64B/$C_SDK_PACKAGE_64B"
C_DEV_PACKAGE_DIR_64B="$PACKAGES_ROOT_DIR_64B/$C_DEV_PACKAGE_64B"
CXX_SDK_DIRS=("build" "src" "include" "lib" "extlibs" "samples" "doc")
CXX_DEV_DIRS=("lib" "extlibs" "build/xcode/templates")
C_SDK_DIRS=("src" "include" "extlibs")
@ -65,9 +95,15 @@ C_DEV_DIRS=("extlibs")
C_DEV_SUB_DIRS=("CSFML/xcode/templates" "CSFML/lib")
PACKAGE_INFO_FILES=("Read Me.rtf" "Release Notes.rtf" "Notes de version.rtf" "license.txt" "Lisez-moi.rtf")
# Build detection
SHOULD_CONSIDER_64B="yes"
SHOULD_CONSIDER_CXX="yes"
SHOULD_CONSIDER_CXX_64B="yes"
SHOULD_CONSIDER_C="yes"
SHOULD_CONSIDER_C_64B="yes"
SHOULD_CONSIDER_SAMPLES="yes"
SHOULD_CONSIDER_SAMPLES_64B="yes"
VERBOSE_OUTPUT="/dev/null"
@ -82,6 +118,7 @@ check_last_process()
fi
else
echo "*** Last process did not end properly. Process stopped."
echo "*** Error occured when executed from `pwd`"
exit 1
fi
}
@ -89,7 +126,7 @@ check_last_process()
# User help
print_usage()
{
echo "Usage: $0 [clean | build | build-samples | build-pkg | all [--verbose]]"
echo "Usage: $0 [clean[-32|-64] | build[-32|-64] | build-samples[-32|-64] | build-pkg[-32|-64] | all[-32|-64] [--verbose]]"
echo
echo "Commands:"
echo " clean\t\tdeletes the C and C++ frameworks, object files and packages"
@ -102,23 +139,42 @@ print_usage()
echo "Options:"
echo " --verbose\t\tdo not hide standard ouput, errors are still shown"
echo
echo "Command suffixes:"
echo " -32\t\t\tapply command for 32 bits PowerPC and Intel binaries"
echo " -64\t\t\tapply command for 32 bits PowerPC and Intel, and 64 bits Intel binaries"
echo " \t\t\tDefault applies command for both choices"
echo " \t\t\t(ie. build frameworks for both 32 and 64 bits platforms)"
echo
echo "Contents summary:"
echo " Found C++ project : $SHOULD_CONSIDER_CXX"
echo " Found C project : $SHOULD_CONSIDER_C"
echo " Found samples project : $SHOULD_CONSIDER_SAMPLES"
echo " Found C++ frameworks project \t\t $SHOULD_CONSIDER_CXX"
echo " Found C frameworks project \t\t\t $SHOULD_CONSIDER_C"
echo " Found samples project \t\t\t $SHOULD_CONSIDER_SAMPLES"
echo " Can build Intel 64 bits binaries \t\t $SHOULD_CONSIDER_64B"
echo " Found C++ 64 bits frameworks project \t $SHOULD_CONSIDER_CXX_64B"
echo " Found C 64 bits frameworks project \t\t $SHOULD_CONSIDER_C_64B"
echo " Found 64 bits samples project \t\t $SHOULD_CONSIDER_SAMPLES_64B"
echo " Missing projects will be skiped without further warning."
}
# Checks that the user computer can run this script
check_config()
{
# Check OS type and version
os=`uname -s`
version=`uname -r` # 10.2.0 form; 8.x = Mac OS X 10.4
if [ $os != "Darwin" ]
then
echo "You're not running Mac OS X !"
exit 1
fi
version=${version%%.*}
if test $version -le 8 # 64 bits builds not supported on Mac OS X 10.4 and earlier
then
SHOULD_CONSIDER_64B="no"
fi
# Check scripts tools
if ! test -f "/Developer/Library/PrivateFrameworks/DevToolsCore.framework/Resources/pbxcp"
then
echo "Missing tool pbxcp needed by this script (should be located at /Developer/Library/PrivateFrameworks/DevToolsCore.framework/Resources/pbxcp). Make sure Apple Developer Tools are correctly installed."
@ -138,6 +194,7 @@ check_config()
exit 1
fi
# Check Xcode projects availability
if ! test -d "$XCODE_CXX_ROOT_DIR/$XCODE_FRAMEWORKS_PROJECT"
then
SHOULD_CONSIDER_CXX="no"
@ -152,6 +209,29 @@ check_config()
then
SHOULD_CONSIDER_SAMPLES="no"
fi
# 64 bits projects
if [ "$SHOULD_CONSIDER_64B" == "no" ]
then
SHOULD_CONSIDER_CXX_64B="no"
SHOULD_CONSIDER_C_64B="no"
SHOULD_CONSIDER_SAMPLES_64B="no"
else
if ! test -d "$XCODE_CXX_ROOT_DIR/$XCODE_64B_FRAMEWORKS_PROJECT"
then
SHOULD_CONSIDER_CXX_64B="no"
fi
if ! test -d "$XCODE_C_ROOT_DIR/$XCODE_64B_FRAMEWORKS_PROJECT"
then
SHOULD_CONSIDER_C_64B="no"
fi
if ! test -d "$XCODE_SAMPLES_ROOT_DIR/$XCODE_64B_SAMPLE_PROJECT"
then
SHOULD_CONSIDER_SAMPLES_64B="no"
fi
fi
}
# Makes a directory if needed
@ -160,6 +240,7 @@ make_dir()
if ! test -d "$1"
then
mkdir -p "$1"
check_last_process "[param:$1]"
fi
}
@ -271,6 +352,85 @@ clean_all()
check_last_process " done"
}
# Delete built frameworks and intermediate object files (64 bits)
clean_all_64b()
{
if [ "$SHOULD_CONSIDER_64B" == "yes" ]
then
cd "$ROOT_DIR"
# Process cleaning for C++ project
if [ "$SHOULD_CONSIDER_CXX_64B" == "yes" ]
then
printf "Cleaning 64 bits C++ products..."
if test -d "$XCODE_CXX_ROOT_DIR/$XCODE_64B_FRAMEWORKS_PROJECT"
then
cd "$XCODE_CXX_ROOT_DIR"
xcodebuild -project "$XCODE_64B_FRAMEWORKS_PROJECT" -target "All" -configuration "$XCODE_BUILD_STYLE" clean > "$VERBOSE_OUTPUT"
check_last_process " done"
else
if test -d "$XCODE_CXX_ROOT_DIR"
then
echo "*** Missing file $XCODE_CXX_ROOT_DIR/$XCODE_64B_FRAMEWORKS_PROJECT. Process stopped."
exit 1
else
echo " not found. Skiped"
fi
fi
fi
# Process cleaning for C project
if [ "$SHOULD_CONSIDER_C_64B" == "yes" ]
then
printf "Cleaning 64 bits C products..."
if test -d "$XCODE_C_ROOT_DIR/$XCODE_64B_FRAMEWORKS_PROJECT"
then
cd "$XCODE_C_ROOT_DIR"
xcodebuild -project "$XCODE_64B_FRAMEWORKS_PROJECT" -target "All" -configuration "$XCODE_BUILD_STYLE" clean > "$VERBOSE_OUTPUT"
check_last_process " done"
else
# Do not produce error if the package does no contain the C stuff
if test -d "$XCODE_C_ROOT_DIR"
then
echo "*** Missing file $XCODE_C_ROOT_DIR/$XCODE_64B_FRAMEWORKS_PROJECT. Process stopped."
exit 1
else
echo " not found. Skiped"
fi
fi
fi
# Process cleaning for samples
if [ "$SHOULD_CONSIDER_64B_SAMPLES" == "yes" ]
then
printf "Cleaning 64 bits samples..."
if test -d "$XCODE_SAMPLES_ROOT_DIR/$XCODE_64B_SAMPLES_PROJECT"
then
cd "$XCODE_SAMPLES_ROOT_DIR"
xcodebuild -project "$XCODE_64B_SAMPLES_PROJECT" -target "All" -configuration "$XCODE_BUILD_STYLE" clean > "$VERBOSE_OUTPUT"
check_last_process " done"
else
# Do not produce error if the package does not contain the samples
if test -d "$XCODE_SAMPLES_ROOT_DIR"
then
echo "*** Missing file $XCODE_SAMPLES_ROOT_DIR/$XCODE_64B_SAMPLES_PROJECT. Process stopped."
exit 1
else
echo " not found. Skiped"
fi
fi
fi
# Process cleaning for packages
printf "Removing 64 bits packages..."
remove_dir "$PACKAGES_ROOT_DIR"
check_last_process " done"
else
echo "Intel 64 bits is not supported on your computer. Process skiped"
fi
}
# Build C and C++ frameworks
build_frameworks()
{
@ -323,6 +483,63 @@ build_frameworks()
fi
}
# Build C and C++ frameworks (with Intel 64 bits)
build_frameworks_64b()
{
if [ "$SHOULD_CONSIDER_64B" == "yes" ]
then
# Go into the C++ project directory
if [ "$SHOULD_CONSIDER_CXX_64B" == "yes" ]
then
cd "$XCODE_CXX_ROOT_DIR"
check_last_process
echo "Building 64 bits C++ SFML frameworks in $XCODE_BUILD_STYLE mode..."
if test -d "$XCODE_CXX_ROOT_DIR/$XCODE_64B_FRAMEWORKS_PROJECT"
then
# Build every C++ target (building manually each target to be able to show progress)
for target in "${XCODE_CXX_TARGETS[@]}"
do
printf "Building 64 bits $target framework..."
xcodebuild -project "$XCODE_64B_FRAMEWORKS_PROJECT" -target "$target" -parallelizeTargets -configuration "$XCODE_BUILD_STYLE" build > "$VERBOSE_OUTPUT"
check_last_process " done"
done
echo "All C++ SFML frameworks built."
else
echo "*** Missing file $XCODE_CXX_ROOT_DIR/$XCODE_64B_FRAMEWORKS_PROJECT. Process stopped."
exit 1
fi
fi
# Go into the C project directory
if [ "$SHOULD_CONSIDER_C_64B" == "yes" ]
then
cd "$XCODE_C_ROOT_DIR"
check_last_process
echo "Building C SFML frameworks in $XCODE_BUILD_STYLE mode..."
if test -d "$XCODE_C_ROOT_DIR/$XCODE_64B_FRAMEWORKS_PROJECT"
then
# Build every C target
for target in "${XCODE_C_TARGETS[@]}"
do
printf "Building 64 bits $target framework..."
xcodebuild -project "$XCODE_64B_FRAMEWORKS_PROJECT" -target "$target" -parallelizeTargets -configuration "$XCODE_BUILD_STYLE" build > "$VERBOSE_OUTPUT"
check_last_process " done"
done
echo "All C SFML frameworks built."
else
echo "*** Missing file $XCODE_C_ROOT_DIR/$XCODE_64B_FRAMEWORKS_PROJECT. Process stopped."
exit 1
fi
fi
else
echo "Intel 64 bits is not supported on your computer. Process skiped"
fi
}
# Build the samples
build_samples()
{
@ -347,6 +564,35 @@ build_samples()
fi
}
# Build the samples (with Intel 64 bits)
build_samples_64b()
{
if [ "$SHOULD_CONSIDER_64B" == "yes" ]
then
# Go into the samples project directory
if [ "$SHOULD_CONSIDER_SAMPLES_64B" == "yes" ]
then
cd "$XCODE_SAMPLES_ROOT_DIR"
check_last_process
printf "Building 64 bits SFML samples in $XCODE_BUILD_STYLE mode..."
if test -d "$XCODE_SAMPLES_ROOT_DIR/$XCODE_64B_SAMPLES_PROJECT"
then
# Build the samples
xcodebuild -project "$XCODE_64B_SAMPLES_PROJECT" -target "All" -parallelizeTargets -configuration "$XCODE_BUILD_STYLE" build > "$VERBOSE_OUTPUT"
check_last_process " done"
echo "In order to run the samples, the SFML frameworks (located in \"lib\") must be copied in the /Library/Frameworks directory." > "$CXX_SAMPLES_DIR/README"
check_last_process
else
echo "*** Missing file $XCODE_SAMPLES_ROOT_DIR/$XCODE_64B_SAMPLES_PROJECT. Process stopped."
exit 1
fi
fi
else
echo "Intel 64 bits is not supported on your computer. Process skiped"
fi
}
# Put the information files in the package
copy_info_files()
{
@ -494,6 +740,147 @@ build_packages()
echo "All packages have been built. See $PACKAGES_ROOT_DIR."
}
# Build the archives of the C and C++ Dev and SDK packages (for Intel 64 bits)
build_packages_64b()
{
if [ "$SHOULD_CONSIDER_64B" == "yes" ]
then
cd "$ROOT_DIR"
make_dir "$PACKAGES_ROOT_DIR_64B"
# Build the C++ SDK package
if [ "$SHOULD_CONSIDER_CXX_64B" == "yes" ]
then
printf "Building 64 bits C++ SDK package..."
make_dir "$CXX_SDK_PACKAGE_DIR_64B"
for dir in "${CXX_SDK_DIRS[@]}"
do
case "$dir" in
"doc")
if ! test -f "$ROOT_DIR/$dir/html/index.htm"
then
echo "*** $ROOT_DIR/$dir/html/index.htm not found. Make sure the documentation has been built."
exit 1
fi
;;
esac
copy "$ROOT_DIR/$dir" "$CXX_SDK_PACKAGE_DIR_64B"
check_last_process
done
copy_info_files "$CXX_SDK_PACKAGE_DIR_64B"
check_last_process
# Build the archive
cd "$PACKAGES_ROOT_DIR_64B"
tar -cjlf "$PACKAGES_ROOT_DIR_64B/$CXX_SDK_PACKAGE_64B.tar.bz2" "$CXX_SDK_PACKAGE_64B" > "$VERBOSE_OUTPUT"
check_last_process " done"
# Build the C++ Dev package
printf "Building 64 bits C++ Development package..."
make_dir "$CXX_DEV_PACKAGE_DIR_64B"
for dir in "${CXX_DEV_DIRS[@]}"
do
copy "$ROOT_DIR/$dir" "$CXX_DEV_PACKAGE_DIR_64B"
check_last_process
case $dir in
"build/xcode/templates")
# Special consideration for the templates folder that is to be moved in build/xcode
move_dir "$CXX_DEV_PACKAGE_DIR_64B/templates" "$CXX_DEV_PACKAGE_DIR_64B/build/xcode"
check_last_process
;;
"extlibs")
# Drop the libs-xcode and headers directories
remove_dir "$CXX_DEV_PACKAGE_DIR_64B/extlibs/libs-xcode"
check_last_process
remove_dir "$CXX_DEV_PACKAGE_DIR_64B/extlibs/headers"
check_last_process
;;
*)
;;
esac
done
copy_info_files "$CXX_DEV_PACKAGE_DIR_64B"
# Build the archive
cd "$PACKAGES_ROOT_DIR_64B"
tar -cjlf "$PACKAGES_ROOT_DIR_64B/$CXX_DEV_PACKAGE_64B.tar.bz2" "$CXX_DEV_PACKAGE_64B" > "$VERBOSE_OUTPUT"
check_last_process " done"
fi # SHOULD_CONSIDER_CXX
# Build the C SDK package
if [ "$SHOULD_CONSIDER_C_64B" == "yes" ]
then
printf "Building 64 bits C SDK package..."
make_dir "$C_SDK_PACKAGE_DIR_64B"
for dir in "${C_SDK_DIRS[@]}"
do
copy "$ROOT_DIR/$dir" "$C_SDK_PACKAGE_DIR_64B"
check_last_process
done
make_dir "$C_SDK_PACKAGE_SUB_DIR"
for dir in "${C_SDK_SUB_DIRS[@]}"
do
copy "$ROOT_DIR/$dir" "$C_SDK_PACKAGE_SUB_DIR"
check_last_process
done
copy_info_files "$C_SDK_PACKAGE_DIR_64B"
# Build the archive
cd "$PACKAGES_ROOT_DIR_64B"
tar -cjlf "$PACKAGES_ROOT_DIR_64B/$C_SDK_PACKAGE_64B.tar.bz2" "$C_SDK_PACKAGE_64B" > "$VERBOSE_OUTPUT"
check_last_process " done"
# Build the C Development package
printf "Building 64 bits C Development package..."
make_dir "$C_DEV_PACKAGE_DIR_64B"
for dir in "${C_DEV_DIRS[@]}"
do
copy "$ROOT_DIR/$dir" "$C_DEV_PACKAGE_DIR_64B"
check_last_process
case $dir in
"extlibs")
# Drop the libs-xcode and headers directories
remove_dir "$C_DEV_PACKAGE_DIR_64B/extlibs/libs-xcode"
check_last_process
remove_dir "$C_DEV_PACKAGE_DIR_64B/extlibs/headers"
check_last_process
;;
esac
done
make_dir "$C_DEV_PACKAGE_SUB_DIR"
for dir in "${C_DEV_SUB_DIRS[@]}"
do
copy "$ROOT_DIR/$dir" "$C_DEV_PACKAGE_SUB_DIR_64B"
check_last_process
case $dir in
"CSFML/xcode/templates")
# Special consideration for the templates folder that is to be moved in build/xcode
move_dir "$C_DEV_PACKAGE_DIR_64B/CSFML/templates" "$C_DEV_PACKAGE_DIR_64B/CSFML/xcode"
check_last_process
;;
esac
done
copy_info_files "$C_DEV_PACKAGE_DIR_64B"
# Build the archive
cd "$PACKAGES_ROOT_DIR_64B"
tar -cjlf "$PACKAGES_ROOT_DIR_64B/$C_DEV_PACKAGE_64B.tar.bz2" "$C_DEV_PACKAGE_64B" > "$VERBOSE_OUTPUT"
check_last_process " done"
fi
echo "All packages have been built. See $PACKAGES_ROOT_DIR_64B."
else
echo "Intel 64 bits is not supported on your computer. Process skiped"
fi
}
main()
{
# First make sure the user will be able to run the script
@ -517,28 +904,77 @@ main()
case $action in
"clean")
clean_all $*
clean_all_64b $*
;;
"clean-32")
clean_all $*
;;
"clean-64")
clean_all_64b $*
;;
"build")
build_frameworks $*
build_frameworks_64b $*
;;
"build-32")
build_frameworks $*
;;
"build-64")
build_frameworks_64b $*
;;
"build-samples")
build_samples $*
build_samples_64b $*
;;
"build-samples-32")
build_samples $*
;;
"build-samples-64")
build_samples_64b $*
;;
"build-pkg")
build_packages $*
build_packages_64b $*
;;
"build-pkg-32")
build_packages $*
;;
"build-pkg-64")
build_packages_64b $*
;;
"all")
build_frameworks $*
build_frameworks_64b $*
build_samples $*
build_samples_64b $*
build_packages $*
build_packages64b $*
;;
"-h")
print_usage $*
;;
"--help")
print_usage $*
;;
"help")
"all-32")
build_frameworks $*
build_samples $*
build_packages $*
;;
"all-64")
build_frameworks_64b $*
build_samples_64b $*
build_packages_64b $*
;;
"-h" | "--help" | "help")
print_usage $*
;;
"--verbose")

2
include/SFML/Graphics/Sprite.hpp
View File

@ -61,7 +61,7 @@ public :
/// \param color : Color of the sprite
///
////////////////////////////////////////////////////////////
Sprite(const Image& image, const Vector2f& position = Vector2f(0, 0), const Vector2f& scale = Vector2f(1, 1), float rotation = 0.f, const Color& color = Color(255, 255, 255, 255));
explicit Sprite(const Image& image, const Vector2f& position = Vector2f(0, 0), const Vector2f& scale = Vector2f(1, 1), float rotation = 0.f, const Color& color = Color(255, 255, 255, 255));
////////////////////////////////////////////////////////////
/// Change the image of the sprite

6
include/SFML/Network/SocketTCP.hpp
View File

@ -214,8 +214,10 @@ private :
// Member data
////////////////////////////////////////////////////////////
SocketHelper::SocketType mySocket; ///< Socket descriptor
std::vector<char> myPendingPacket; ///< Data of the current pending packet, if any (in non-blocking mode)
Int32 myPendingPacketSize; ///< Size of the current pending packet, if any (in non-blocking mode)
Uint32 myPendingHeader; ///< Data of the current pending packet header, if any
Uint32 myPendingHeaderSize; ///< Size of the current pending packet header, if any
std::vector<char> myPendingPacket; ///< Data of the current pending packet, if any
Int32 myPendingPacketSize; ///< Size of the current pending packet, if any
bool myIsBlocking; ///< Is the socket blocking or non-blocking ?
};

6
include/SFML/Network/SocketUDP.hpp
View File

@ -215,8 +215,10 @@ private :
////////////////////////////////////////////////////////////
SocketHelper::SocketType mySocket; ///< Socket identifier
unsigned short myPort; ///< Port to which the socket is bound
std::vector<char> myPendingPacket; ///< Data of the current pending packet, if any (in non-blocking mode)
Int32 myPendingPacketSize; ///< Size of the current pending packet, if any (in non-blocking mode)
Uint32 myPendingHeader; ///< Data of the current pending packet header, if any
Uint32 myPendingHeaderSize; ///< Size of the current pending packet header, if any
std::vector<char> myPendingPacket; ///< Data of the current pending packet, if any
Int32 myPendingPacketSize; ///< Size of the current pending packet, if any
bool myIsBlocking; ///< Is the socket blocking or non-blocking ?
};

11
src/SFML/Network/Ftp.cpp
View File

@ -380,7 +380,9 @@ Ftp::Response Ftp::Download(const std::string& distantFile, const std::string& d
std::ofstream file((path + filename).c_str(), std::ios_base::binary);
if (!file)
return Response(Response::InvalidFile);
file.write(&fileData[0], static_cast<std::streamsize>(fileData.size()));
if (!fileData.empty())
file.write(&fileData[0], static_cast<std::streamsize>(fileData.size()));
}
}
}
@ -398,11 +400,13 @@ Ftp::Response Ftp::Upload(const std::string& localFile, const std::string& destP
std::ifstream file(localFile.c_str(), std::ios_base::binary);
if (!file)
return Response(Response::InvalidFile);
file.seekg(0, std::ios::end);
std::size_t length = file.tellg();
file.seekg(0, std::ios::beg);
std::vector<char> fileData(length);
file.read(&fileData[0], static_cast<std::streamsize>(length));
if (length > 0)
file.read(&fileData[0], static_cast<std::streamsize>(length));
// Extract the filename from the file path
std::string filename = localFile;
@ -700,7 +704,8 @@ void Ftp::DataChannel::Receive(std::vector<char>& data)
void Ftp::DataChannel::Send(const std::vector<char>& data)
{
// Send data
myDataSocket.Send(&data[0], data.size());
if (!data.empty())
myDataSocket.Send(&data[0], data.size());
// Close the data socket
myDataSocket.Close();

5
src/SFML/Network/Http.cpp
View File

@ -27,6 +27,8 @@
////////////////////////////////////////////////////////////
#include <SFML/Network/Http.hpp>
#include <ctype.h>
#include <algorithm>
#include <iterator>
#include <sstream>
@ -294,8 +296,7 @@ void Http::Response::FromString(const std::string& data)
// Finally extract the body
myBody.clear();
while (std::getline(in, line))
myBody += line + "\n";
std::copy(std::istreambuf_iterator<char>(in), std::istreambuf_iterator<char>(), std::back_inserter(myBody));
}

18
src/SFML/Network/SocketTCP.cpp
View File

@ -344,11 +344,20 @@ Socket::Status SocketTCP::Receive(Packet& packet)
std::size_t received = 0;
if (myPendingPacketSize < 0)
{
Socket::Status status = Receive(reinterpret_cast<char*>(&packetSize), sizeof(packetSize), received);
if (status != Socket::Done)
return status;
// Loop until we've received the entire size of the packet
// (even a 4 bytes variable may be received in more than one call)
while (myPendingHeaderSize < sizeof(myPendingHeader))
{
char* data = reinterpret_cast<char*>(&myPendingHeader) + myPendingHeaderSize;
Socket::Status status = Receive(data, sizeof(myPendingHeader) - myPendingHeaderSize, received);
myPendingHeaderSize += received;
packetSize = ntohl(packetSize);
if (status != Socket::Done)
return status;
}
packetSize = ntohl(myPendingHeader);
myPendingHeaderSize = 0;
}
else
{
@ -472,6 +481,7 @@ void SocketTCP::Create(SocketHelper::SocketType descriptor)
myIsBlocking = true;
// Reset the pending packet
myPendingHeaderSize = 0;
myPendingPacket.clear();
myPendingPacketSize = -1;

21
src/SFML/Network/SocketUDP.cpp
View File

@ -249,11 +249,20 @@ Socket::Status SocketUDP::Receive(Packet& packet, IPAddress& address, unsigned s
std::size_t received = 0;
if (myPendingPacketSize < 0)
{
Socket::Status status = Receive(reinterpret_cast<char*>(&packetSize), sizeof(packetSize), received, address, port);
if (status != Socket::Done)
return status;
// Loop until we've received the entire size of the packet
// (even a 4 bytes variable may be received in more than one call)
while (myPendingHeaderSize < sizeof(myPendingHeader))
{
char* data = reinterpret_cast<char*>(&myPendingHeader) + myPendingHeaderSize;
Socket::Status status = Receive(data, sizeof(myPendingHeader) - myPendingHeaderSize, received, address, port);
myPendingHeaderSize += received;
packetSize = ntohl(packetSize);
if (status != Socket::Done)
return status;
}
packetSize = ntohl(myPendingHeader);
myPendingHeaderSize = 0;
}
else
{
@ -261,9 +270,6 @@ Socket::Status SocketUDP::Receive(Packet& packet, IPAddress& address, unsigned s
packetSize = myPendingPacketSize;
}
// Clear the user packet
packet.Clear();
// Use another address instance for receiving the packet data ;
// chunks of data coming from a different sender will be discarded (and lost...)
IPAddress sender;
@ -398,6 +404,7 @@ void SocketUDP::Create(SocketHelper::SocketType descriptor)
myPort = 0;
// Reset the pending packet
myPendingHeaderSize = 0;
myPendingPacket.clear();
myPendingPacketSize = -1;

6
src/SFML/System/Randomizer.cpp
View File

@ -26,8 +26,8 @@
// Headers
////////////////////////////////////////////////////////////
#include <SFML/System/Randomizer.hpp>
#include <SFML/System/Platform.hpp>
#include <cstdlib>
#include <stdlib.h>
#include <time.h>
////////////////////////////////////////////////////////////
@ -39,7 +39,7 @@ namespace
// in milliseconds, so that it is always different
unsigned int InitializeSeed()
{
unsigned int seed = static_cast<unsigned int>(sf::priv::Platform::GetSystemTime() * 1000);
unsigned int seed = static_cast<unsigned int>(time(NULL));
srand(seed);
return seed;
}

2
src/SFML/System/Thread.cpp
View File

@ -71,7 +71,7 @@ Thread::~Thread()
////////////////////////////////////////////////////////////
void Thread::Launch()
{
delete myThreadImpl;
Wait();
myThreadImpl = new priv::ThreadImpl(this);
}

10
src/SFML/Window/Cocoa/AppController.h
View File

@ -36,10 +36,10 @@ enum {
CleanScreen
};
@class WindowWrapper;
@interface AppController : NSObject {
@class sfPrivWindow;
@interface sfPrivAppController : NSObject {
BOOL myOwningEventLoop;
WindowWrapper *myFullscreenWrapper;
sfPrivWindow *myFullscreenWrapper;
NSAutoreleasePool *myMainPool;
sf::VideoMode myDesktopMode;
sf::VideoMode myPrevMode;
@ -48,7 +48,7 @@ enum {
////////////////////////////////////////////////////////////
/// Return the shared AppController instance. Make one if needed.
////////////////////////////////////////////////////////////
+ (AppController *)sharedController;
+ (sfPrivAppController *)sharedController;
////////////////////////////////////////////////////////////
/// Returns the primay computer's screen
@ -76,7 +76,7 @@ enum {
/// Set @window as the current fullscreen window
/// Change the screen resolution if needed according to @window and @fullscreenMode
////////////////////////////////////////////////////////////
- (void)setFullscreenWindow:(WindowWrapper *)window mode:(sf::VideoMode *)fullscreenMode;
- (void)setFullscreenWindow:(sfPrivWindow *)window mode:(sf::VideoMode *)fullscreenMode;
////////////////////////////////////////////////////////////
/// Perform fade operation where 'operation' is one of { FillScreen, CleanScreen}

56
src/SFML/Window/Cocoa/AppController.mm
View File

@ -57,7 +57,7 @@
@end
@implementation AppController
@implementation sfPrivAppController
////////////////////////////////////////////////////////////
@ -129,10 +129,10 @@
////////////////////////////////////////////////////////////
/// Return the shared AppController instance. Make one if needed.
////////////////////////////////////////////////////////////
+ (AppController *)sharedController
+ (sfPrivAppController *)sharedController
{
// AppController singleton object
static AppController *shared = [[AppController alloc] init];
static sfPrivAppController *shared = [[sfPrivAppController alloc] init];
return shared;
}
@ -192,7 +192,7 @@
if (myFullscreenWrapper) {
myPrevMode = sf::VideoMode::GetDesktopMode();
CFDictionaryRef displayMode = CGDisplayBestModeForParameters ([AppController primaryScreen],
CFDictionaryRef displayMode = CGDisplayBestModeForParameters ([sfPrivAppController primaryScreen],
myDesktopMode.BitsPerPixel,
myDesktopMode.Width,
myDesktopMode.Height,
@ -202,7 +202,7 @@
[[myFullscreenWrapper window] setAlphaValue:0.0f];
// Switch to the wished display mode
CGDisplaySwitchToMode([AppController primaryScreen], displayMode);
CGDisplaySwitchToMode([sfPrivAppController primaryScreen], displayMode);
}
}
@ -213,7 +213,7 @@
- (void)applicationWillActivate:(NSNotification *)aNotification
{
if (myFullscreenWrapper) {
CFDictionaryRef displayMode = CGDisplayBestModeForParameters ([AppController primaryScreen],
CFDictionaryRef displayMode = CGDisplayBestModeForParameters ([sfPrivAppController primaryScreen],
myPrevMode.BitsPerPixel,
myPrevMode.Width,
myPrevMode.Height,
@ -221,7 +221,7 @@
[NSMenu setMenuBarVisible:NO];
// Switch to the wished display mode
CGDisplaySwitchToMode([AppController primaryScreen], displayMode);
CGDisplaySwitchToMode([sfPrivAppController primaryScreen], displayMode);
// Show the fullscreen window if existing
if (myFullscreenWrapper)
@ -380,14 +380,14 @@
myOwningEventLoop = YES;
}
// Clean the autorelease pool
[myMainPool release];
myMainPool = [[NSAutoreleasePool alloc] init];
NSEvent *event = nil;
if (myOwningEventLoop)
{
// Clean the autorelease pool
[myMainPool release];
myMainPool = [[NSAutoreleasePool alloc] init];
// Minimal event loop
while (nil != (event = [NSApp nextEventMatchingMask:NSAnyEventMask
untilDate:nil
@ -404,13 +404,13 @@
/// Set @window as the current fullscreen window
/// Change the screen resolution if needed according to @window and @fullscreenMode
////////////////////////////////////////////////////////////
- (void)setFullscreenWindow:(WindowWrapper *)aWrapper mode:(sf::VideoMode *)fullscreenMode
- (void)setFullscreenWindow:(sfPrivWindow *)aWindow mode:(sf::VideoMode *)fullscreenMode
{
// If we have a fullscreen window and want to remove it
if (aWrapper == nil && myFullscreenWrapper)
if (aWindow == nil && myFullscreenWrapper)
{
// Get the CoreGraphics display mode according to the desktop mode
CFDictionaryRef displayMode = CGDisplayBestModeForParameters ([AppController primaryScreen],
CFDictionaryRef displayMode = CGDisplayBestModeForParameters ([sfPrivAppController primaryScreen],
myDesktopMode.BitsPerPixel,
myDesktopMode.Width,
myDesktopMode.Height,
@ -422,7 +422,7 @@
#endif
// Switch to the desktop display mode
CGDisplaySwitchToMode([AppController primaryScreen], displayMode);
CGDisplaySwitchToMode([sfPrivAppController primaryScreen], displayMode);
// Close the window
[[myFullscreenWrapper window] close];
@ -438,13 +438,13 @@
// Release the saved window wrapper
myFullscreenWrapper = nil;
}
else if (aWrapper)
else if (aWindow)
{
// else if we want to SET fullscreen
assert(fullscreenMode != NULL);
// Get the CoreGraphics display mode according to the given sf mode
CFDictionaryRef displayMode = CGDisplayBestModeForParameters ([AppController primaryScreen],
CFDictionaryRef displayMode = CGDisplayBestModeForParameters ([sfPrivAppController primaryScreen],
fullscreenMode->BitsPerPixel,
fullscreenMode->Width,
fullscreenMode->Height,
@ -465,7 +465,7 @@
{
// Switch to the wished display mode
myPrevMode = *fullscreenMode;
CGDisplaySwitchToMode([AppController primaryScreen], displayMode);
CGDisplaySwitchToMode([sfPrivAppController primaryScreen], displayMode);
}
if (myFullscreenWrapper)
@ -474,8 +474,8 @@
}
// Open and center the window
[[aWrapper window] makeKeyAndOrderFront:nil];
[[aWrapper window] center];
[[aWindow window] makeKeyAndOrderFront:nil];
[[aWindow window] center];
#if ENABLE_FADE_OPERATIONS
// Fade to normal screen
@ -483,11 +483,11 @@
#endif
// Save the fullscreen wrapper
myFullscreenWrapper = aWrapper;
myFullscreenWrapper = aWindow;
}
else
{
std::cerr << "Inconcistency error for arguments given to -[AppController setFullscreenWindow:mode:]" << std::endl;
std::cerr << "Inconcistency error for arguments given to -[sfPrivAppController setFullscreenWindow:mode:]" << std::endl;
}
}
@ -514,7 +514,7 @@
if (!result) {
// Capture display but do not fill the screen with black
// so that we can see the fade operation
capture = CGDisplayCaptureWithOptions([AppController primaryScreen], kCGCaptureNoFill);
capture = CGDisplayCaptureWithOptions([sfPrivAppController primaryScreen], kCGCaptureNoFill);
if (!capture) {
// Do the increasing fade operation
@ -524,11 +524,11 @@
0.0f, 0.0f, 0.0f, sync);
// Now, release the non black-filling capture
CGDisplayRelease([AppController primaryScreen]);
CGDisplayRelease([sfPrivAppController primaryScreen]);
// And capture with filling
// so that we don't see the switching in the meantime
CGDisplayCaptureWithOptions([AppController primaryScreen], kCGCaptureNoOptions);
CGDisplayCaptureWithOptions([sfPrivAppController primaryScreen], kCGCaptureNoOptions);
}
prevToken = token;
@ -541,10 +541,10 @@
if (!result) {
if (!capture) {
// Release the black-filling capture
CGDisplayRelease([AppController primaryScreen]);
CGDisplayRelease([sfPrivAppController primaryScreen]);
// Capture the display but do not fill with black (still for the fade operation)
CGDisplayCaptureWithOptions([AppController primaryScreen], kCGCaptureNoFill);
CGDisplayCaptureWithOptions([sfPrivAppController primaryScreen], kCGCaptureNoFill);
// Do the decreasing fading
CGDisplayFade(token, time,
@ -560,7 +560,7 @@
}
// Release the captured display
CGDisplayRelease([AppController primaryScreen]);
CGDisplayRelease([sfPrivAppController primaryScreen]);
}
}
}

141
src/SFML/Window/Cocoa/GLKit.h
View File

@ -32,10 +32,7 @@
////////////////////////////////////////////////////////////
/// Window independant OpenGL context class
////////////////////////////////////////////////////////////
@interface GLContext : NSOpenGLContext
{
}
@interface sfPrivGLContext : NSOpenGLContext
////////////////////////////////////////////////////////////
/// Return the shared OpenGL context instance (making one if needed)
@ -47,7 +44,7 @@
/// and the shared context @context
////////////////////////////////////////////////////////////
- (id)initWithAttributes:(sf::WindowSettings&)attribs
sharedContext:(GLContext *)context;
sharedContext:(sfPrivGLContext *)context;
@end
@ -55,22 +52,31 @@
////////////////////////////////////////////////////////////
/// Customized Cocoa OpenGL view
////////////////////////////////////////////////////////////
@interface GLView : NSOpenGLView
@interface sfPrivGLView : NSOpenGLView
{
sf::priv::WindowImplCocoa *myDelegate;
GLContext *myGLContext;
sfPrivGLContext *myGLContext;
}
////////////////////////////////////////////////////////////
/// Make a new view according the the rect @frame,
/// the video mode @mode, the window settings @settings
/// and the sf window delegate @delegate
/// @delegate must not be null
////////////////////////////////////////////////////////////
- (id)initWithFrame:(NSRect)frame
mode:(const sf::VideoMode&)mode
settings:(sf::WindowSettings&)settings
delegate:(sf::priv::WindowImplCocoa *)delegate;
settings:(sf::WindowSettings&)settings;
////////////////////////////////////////////////////////////
/// Sets @aDelegate as the view delegate
////////////////////////////////////////////////////////////
- (void)setDelegate:(sf::priv::WindowImplCocoa *)aDelegate;
////////////////////////////////////////////////////////////
/// Returns the view delegate
////////////////////////////////////////////////////////////
- (sf::priv::WindowImplCocoa *)delegate;
////////////////////////////////////////////////////////////
/// Finish view setting (after having added it to the window)
@ -94,53 +100,16 @@
@end
////////////////////////////////////////////////////////////
/// WindowWrapper class : handles both imported and self-built windows
/// Parent class for handling general SFML window stuff
////////////////////////////////////////////////////////////
@interface WindowWrapper : NSObject
@interface sfPrivWindow : NSObject
{
@private
NSWindow *myWindow;
GLView *myView;
sf::VideoMode myFullscreenMode;
bool myIsFullscreen;
sfPrivGLView *myView;
}
////////////////////////////////////////////////////////////
/// Make a new window wrapper according to the window settings @attribs,
/// the video mode @mode, the window style @style, the window title @title
/// and the sf window implementation delegate @delegate
////////////////////////////////////////////////////////////
- (id)initWithSettings:(sf::WindowSettings&)attribs
videoMode:(sf::VideoMode&)mode
style:(unsigned long)style
title:(NSString *)title
delegate:(sf::priv::WindowImplCocoa *)delegate;
////////////////////////////////////////////////////////////
/// Make a new window wrapper by importing @window and according to
/// the window settings @params and the sf window implementation delegate
/// @delegate
/// @window and @delegate must not be null
////////////////////////////////////////////////////////////
- (id)initWithWindow:(NSWindow *)window
settings:(sf::WindowSettings&)params
delegate:(sf::priv::WindowImplCocoa *)delegate;
////////////////////////////////////////////////////////////
/// Make a new window wrapper by importing @window if it's not null and according to
/// the window settings @params and the sf window implementation delegate
/// @delegate; or by creating a new window if @window is null. In this case @title
/// must therefore not be null and @params must be valid.
/// @delegate must never be null
////////////////////////////////////////////////////////////
- (id)initWithWindow:(NSWindow *)window
settings:(sf::WindowSettings&)params
videoMode:(sf::VideoMode&)mode
style:(unsigned long)style
title:(NSString *)title
delegate:(sf::priv::WindowImplCocoa *)delegate;
////////////////////////////////////////////////////////////
/// Return a reference to the internal Cocoa window
////////////////////////////////////////////////////////////
@ -149,7 +118,17 @@
////////////////////////////////////////////////////////////
/// Return a reference to the internal Cocoa OpenGL view
////////////////////////////////////////////////////////////
- (GLView *)glView;
- (sfPrivGLView *)view;
////////////////////////////////////////////////////////////
/// Sets @aDelegate as the window delegate
////////////////////////////////////////////////////////////
- (void)setDelegate:(sf::priv::WindowImplCocoa *)aDelegate;
////////////////////////////////////////////////////////////
/// Returns the window delegate
////////////////////////////////////////////////////////////
- (sf::priv::WindowImplCocoa *)delegate;
////////////////////////////////////////////////////////////
/// Forward call to set the window position on screen
@ -193,3 +172,61 @@
@end
////////////////////////////////////////////////////////////
/// Class for creating new SFML windows from informations
////////////////////////////////////////////////////////////
@interface sfPrivOwnedWindow : sfPrivWindow
{
@private
sf::VideoMode myFullscreenMode;
bool myIsFullscreen;
}
////////////////////////////////////////////////////////////
/// Creates and returns a new SFML window handler with
/// the given parameters
////////////////////////////////////////////////////////////
- (id)initWithVideoMode:(sf::VideoMode&)aMode
settings:(sf::WindowSettings&)someSettings
style:(unsigned long)aStyle
title:(NSString *)aTitle;
////////////////////////////////////////////////////////////
/// Returns the window's fullscreen state
////////////////////////////////////////////////////////////
- (BOOL)isFullscreen;
@end
////////////////////////////////////////////////////////////
/// Class for creating SFML windows from Cocoa windows
////////////////////////////////////////////////////////////
@interface sfPrivImportedWindow : sfPrivWindow
////////////////////////////////////////////////////////////
/// Returns a new SFML window handler with the given window
/// and parameters
////////////////////////////////////////////////////////////
- (id)initWithWindow:(NSWindow *)aWindow
settings:(sf::WindowSettings&)someSettings;
@end
////////////////////////////////////////////////////////////
/// Class for creating SFML windows from Cocoa views
////////////////////////////////////////////////////////////
@interface sfPrivImportedView : sfPrivWindow
{
NSView *parentView;
}
////////////////////////////////////////////////////////////
/// Returns a new SFML window handler with the given view
/// and parameters
////////////////////////////////////////////////////////////
- (id)initWithView:(NSView *)aView
settings:(sf::WindowSettings&)someSettings;
@end

797
src/SFML/Window/Cocoa/GLKit.mm
View File

File diff suppressed because it is too large Load Diff

8
src/SFML/Window/Cocoa/WindowImplCocoa.hpp
View File

@ -33,10 +33,10 @@
#include <string>
#ifdef __OBJC__
@class WindowWrapper;
typedef WindowWrapper* WindowWrapperRef;
@class sfPrivWindow;
typedef sfPrivWindow* sfPrivWindowRef;
#else
typedef void* WindowWrapperRef;
typedef void* sfPrivWindowRef;
#endif
namespace sf
@ -192,7 +192,7 @@ private :
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
WindowWrapperRef myWrapper;
sfPrivWindowRef myWrapper;
bool myUseKeyRepeat;
bool myMouseIn;
float myWheelStatus;

95
src/SFML/Window/Cocoa/WindowImplCocoa.mm
View File

@ -67,10 +67,10 @@ myUseKeyRepeat(false),
myMouseIn(false),
myWheelStatus(0.0f)
{
[AppController sharedController];
[sfPrivAppController sharedController];
// Create the shared OpenGL context
if ([GLContext sharedContext]) {
if ([sfPrivGLContext sharedContext]) {
// Then we make it the current active OpenGL context
SetActive();
} else {
@ -88,22 +88,19 @@ myUseKeyRepeat(false),
myMouseIn(false),
myWheelStatus(0.0f)
{
if (Handle)
{
NSWindow *cocoaWindow = nil;
if (Handle) {
// Classical window import
if ([(id)Handle isKindOfClass:[NSWindow class]])
{
cocoaWindow = (NSWindow *)Handle;
if ([(id)Handle isKindOfClass:[NSWindow class]]) {
myWrapper = [[sfPrivImportedWindow alloc]
initWithWindow:(NSWindow *)Handle
settings:params];
}
// Qt "window" import
else if ([(id)Handle isKindOfClass:[NSView class]])
{
cocoaWindow = [(NSView *)Handle window];
}
else
{
else if ([(id)Handle isKindOfClass:[NSView class]]) {
myWrapper = [[sfPrivImportedView alloc]
initWithView:(NSView *)Handle
settings:params];
} else {
std::cerr
<< "Cannot import this Window Handle because it is neither"
<< "a <NSWindow *> nor <NSView *> object"
@ -114,36 +111,23 @@ myWheelStatus(0.0f)
}
if (cocoaWindow)
{
if (myWrapper) {
[myWrapper setDelegate:this];
// We create the window according to the given handle
myWrapper = [[WindowWrapper alloc] initWithWindow:cocoaWindow
settings:params
delegate:this];
// initial mouse state
myMouseIn = [myWrapper mouseInside];
if (myWrapper)
{
// initial mouse state
myMouseIn = [myWrapper mouseInside];
// We set the myWidth and myHeight members to the correct values
myWidth = (int) [[myWrapper glView] frame].size.width;
myHeight = (int) [[myWrapper glView] frame].size.height;
} else {
std::cerr << "Failed to make the public window" << std::endl;
}
// We set the myWidth and myHeight members to the correct values
myWidth = (int) [[myWrapper view] frame].size.width;
myHeight = (int) [[myWrapper view] frame].size.height;
} else {
std::cerr << "Failed to make the public window" << std::endl;
}
else
{
std::cerr
<< "Could not get a valid NSWindow object from the given handle"
<< " (%p <"
<< [[(id)Handle className] UTF8String]
<< ">"
<< std::endl;
}
} else {
std::cerr
<< "Invalid null handle given to "
<< "Window::Window(WindowHandle Handle, const WindowSettings& Params)"
<< std::endl;
}
}
@ -163,14 +147,18 @@ myWheelStatus(0.0f)
encoding:NSASCIIStringEncoding];
// We create the window
myWrapper = [[WindowWrapper alloc] initWithSettings:params
videoMode:Mode
style:WindowStyle
title:title
delegate:this];
myWrapper = [[sfPrivOwnedWindow alloc]
initWithVideoMode:Mode
settings:params
style:WindowStyle
title:title];
if (myWrapper)
{
[myWrapper setDelegate:this];
// initial mouse state
myMouseIn = [myWrapper mouseInside];
@ -566,7 +554,7 @@ void WindowImplCocoa::Display()
void WindowImplCocoa::ProcessEvents()
{
// Forward event handling call to the application controller
[[AppController sharedController] processEvents];
[[sfPrivAppController sharedController] processEvents];
}
@ -581,10 +569,10 @@ void WindowImplCocoa::SetActive(bool Active) const
else {
// Or directly activate the shared OpenGL context if we're not using a window
if (Active) {
if ([NSOpenGLContext currentContext] != [GLContext sharedContext])
[[GLContext sharedContext] makeCurrentContext];
if ([NSOpenGLContext currentContext] != [sfPrivGLContext sharedContext])
[[sfPrivGLContext sharedContext] makeCurrentContext];
} else {
if ([NSOpenGLContext currentContext] == [GLContext sharedContext])
if ([NSOpenGLContext currentContext] == [sfPrivGLContext sharedContext])
[NSOpenGLContext clearCurrentContext];
}
}
@ -626,7 +614,7 @@ void WindowImplCocoa::SetCursorPosition(unsigned int Left, unsigned int Top)
pos.y = [[myWrapper window] frame].size.height - pos.y;
// Adjust for view reference instead of window
pos.y -= [[myWrapper window] frame].size.height - [[myWrapper glView] frame].size.height;
pos.y -= [[myWrapper window] frame].size.height - [[myWrapper view] frame].size.height;
// Convert to screen coordinates
NSPoint absolute = [[myWrapper window] convertBaseToScreen:pos];
@ -635,7 +623,8 @@ void WindowImplCocoa::SetCursorPosition(unsigned int Left, unsigned int Top)
absolute.y = [[NSScreen mainScreen] frame].size.height - absolute.y;
// Move cursor
CGDisplayMoveCursorToPoint([AppController primaryScreen], CGPointMake(absolute.x, absolute.y));
CGDisplayMoveCursorToPoint([sfPrivAppController primaryScreen],
CGPointMake(absolute.x, absolute.y));
}
}

1
src/SFML/Window/Win32/ContextWGL.cpp
View File

@ -224,6 +224,7 @@ void ContextWGL::CreateContext(ContextWGL* shared, unsigned int bitsPerPixel, co
descriptor.cColorBits = static_cast<BYTE>(bitsPerPixel);
descriptor.cDepthBits = static_cast<BYTE>(mySettings.DepthBits);
descriptor.cStencilBits = static_cast<BYTE>(mySettings.StencilBits);
descriptor.cAlphaBits = bitsPerPixel == 32 ? 8 : 0;
// Get the pixel format that best matches our requirements
bestFormat = ChoosePixelFormat(myDeviceContext, &descriptor);

8
src/SFML/Window/Win32/WindowImplWin32.cpp
View File

@ -367,14 +367,14 @@ void WindowImplWin32::SwitchToFullscreen(const VideoMode& mode)
return;
}
// Resize the window so that it fits the entire screen
SetWindowPos(myHandle, HWND_TOP, 0, 0, mode.Width, mode.Height, SWP_FRAMECHANGED);
ShowWindow(myHandle, SW_SHOW);
// Make the window flags compatible with fullscreen mode
SetWindowLong(myHandle, GWL_STYLE, WS_POPUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS);
SetWindowLong(myHandle, GWL_EXSTYLE, WS_EX_APPWINDOW);
// Resize the window so that it fits the entire screen
SetWindowPos(myHandle, HWND_TOP, 0, 0, mode.Width, mode.Height, SWP_FRAMECHANGED);
ShowWindow(myHandle, SW_SHOW);
// Set "this" as the current fullscreen window
FullscreenWindow = this;
}