Added (void) to parameterless function prototypes in CSFML

git-svn-id: https://sfml.svn.sourceforge.net/svnroot/sfml/branches/sfml2@1518 4e206d99-4929-0410-ac5d-dfc041789085

CSFML/include/SFML/Audio/Listener.h

@@ -45,7 +45,7 @@ CSFML_API void sfListener_SetGlobalVolume(float volume);
 /// \return Current global volume, in the range [0, 100]
 ///
 ////////////////////////////////////////////////////////////
-CSFML_API float sfListener_GetGlobalVolume();
+CSFML_API float sfListener_GetGlobalVolume(void);
 
 ////////////////////////////////////////////////////////////
 /// Change the position of the listener

CSFML/include/SFML/Audio/Sound.h

@@ -39,7 +39,7 @@
 /// \return A new sfSound object (NULL if failed)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_API sfSound* sfSound_Create();
+CSFML_API sfSound* sfSound_Create(void);
 
 ////////////////////////////////////////////////////////////
 /// Copy an existing sound

CSFML/include/SFML/Audio/SoundBufferRecorder.h

@@ -38,7 +38,7 @@
 /// \return A new sfSoundBufferRecorder object (NULL if failed)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_API sfSoundBufferRecorder* sfSoundBufferRecorder_Create();
+CSFML_API sfSoundBufferRecorder* sfSoundBufferRecorder_Create(void);
 
 ////////////////////////////////////////////////////////////
 /// Destroy an existing sound buffer recorder

CSFML/include/SFML/Audio/SoundRecorder.h

@@ -97,7 +97,7 @@ CSFML_API unsigned int sfSoundRecorder_GetSampleRate(const sfSoundRecorder* soun
 /// \return sfTrue if audio capture is supported
 ///
 ////////////////////////////////////////////////////////////
-CSFML_API sfBool sfSoundRecorder_IsAvailable();
+CSFML_API sfBool sfSoundRecorder_IsAvailable(void);
 
 
 #endif // SFML_SOUNDRECORDER_H

CSFML/include/SFML/Graphics/Font.h

@@ -126,7 +126,7 @@ CSFML_API const sfImage* sfFont_GetImage(sfFont* font, unsigned int characterSiz
 /// \return Pointer to the default font
 ///
 ////////////////////////////////////////////////////////////
-CSFML_API const sfFont* sfFont_GetDefaultFont();
+CSFML_API const sfFont* sfFont_GetDefaultFont(void);
 
 
 #endif // SFML_IMAGE_H

CSFML/include/SFML/Graphics/Image.h

@@ -40,7 +40,7 @@
 /// \return A new sfImage object, or NULL if it failed
 ///
 ////////////////////////////////////////////////////////////
-CSFML_API sfImage* sfImage_Create();
+CSFML_API sfImage* sfImage_Create(void);
 
 ////////////////////////////////////////////////////////////
 /// Create a new image filled with a color
@@ -178,7 +178,7 @@ CSFML_API sfColor sfImage_GetPixel(const sfImage* image, unsigned int x, unsigne
 
 ////////////////////////////////////////////////////////////
 /// Get a read-only pointer to the array of pixels of an image (8 bits integers RGBA)
-/// Array size is sfImage_GetWidth() x sfImage_GetHeight() x 4
+/// Array size is sfImage_GetWidth(img) x sfImage_GetHeight(img) x 4
 /// This pointer becomes invalid if you reload or resize the image
 ///
 /// \param image : Image to read

CSFML/include/SFML/Graphics/RenderImage.h

@@ -208,7 +208,7 @@ CSFML_API const sfImage* sfRenderImage_GetImage(const sfRenderImage* renderImage
 /// \return sfTrue if the RenderImage class can be used
 ///
 ////////////////////////////////////////////////////////////
-CSFML_API sfBool sfRenderImage_IsAvailable();
+CSFML_API sfBool sfRenderImage_IsAvailable(void);
 
 
 #endif // SFML_RENDERIMAGE_H

CSFML/include/SFML/Graphics/Shader.h

@@ -142,7 +142,7 @@ CSFML_API void sfShader_Unbind(const sfShader* shader);
 /// \return sfTrue if the system can use shaders
 ///
 ////////////////////////////////////////////////////////////
-CSFML_API sfBool sfShader_IsAvailable();
+CSFML_API sfBool sfShader_IsAvailable(void);
 
 
 #endif // SFML_SHADER_H

CSFML/include/SFML/Graphics/Shape.h

@@ -40,7 +40,7 @@
 /// \return A new sfShape object, or NULL if it failed
 ///
 ////////////////////////////////////////////////////////////
-CSFML_API sfShape* sfShape_Create();
+CSFML_API sfShape* sfShape_Create(void);
 
 ////////////////////////////////////////////////////////////
 /// Create a new shape made of a single line

CSFML/include/SFML/Graphics/Sprite.h

@@ -41,7 +41,7 @@
 /// \return A new sfSprite object, or NULL if it failed
 ///
 ////////////////////////////////////////////////////////////
-CSFML_API sfSprite* sfSprite_Create();
+CSFML_API sfSprite* sfSprite_Create(void);
 
 ////////////////////////////////////////////////////////////
 /// Copy an existing sprite

CSFML/include/SFML/Graphics/Text.h

@@ -53,7 +53,7 @@ typedef enum
 /// \return A new sfText object, or NULL if it failed
 ///
 ////////////////////////////////////////////////////////////
-CSFML_API sfText* sfText_Create();
+CSFML_API sfText* sfText_Create(void);
 
 ////////////////////////////////////////////////////////////
 /// Copy an existing text

CSFML/include/SFML/Graphics/View.h

@@ -37,7 +37,7 @@
 /// Construct a default view (1000x1000)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_API sfView* sfView_Create();
+CSFML_API sfView* sfView_Create(void);
 
 ////////////////////////////////////////////////////////////
 /// Construct a view from a rectangle

CSFML/include/SFML/Network/Ftp.h

@@ -266,7 +266,7 @@ CSFML_API const char* sfFtpResponse_GetMessage(const sfFtpResponse* ftpResponse)
 /// \return Pointer to the new Ftp
 ///
 ////////////////////////////////////////////////////////////
-CSFML_API sfFtp* sfFtp_Create();
+CSFML_API sfFtp* sfFtp_Create(void);
 
 ////////////////////////////////////////////////////////////
 /// Destroy an existing Ftp

CSFML/include/SFML/Network/Http.h

@@ -85,7 +85,7 @@ enum sfHttpStatus
 /// \return Pointer to the new Http request
 ///
 ////////////////////////////////////////////////////////////
-CSFML_API sfHttpRequest* sfHttpRequest_Create();
+CSFML_API sfHttpRequest* sfHttpRequest_Create(void);
 
 ////////////////////////////////////////////////////////////
 /// Destroy an existing Http request
@@ -216,7 +216,7 @@ CSFML_API const char* sfHttpResponse_GetBody(const sfHttpResponse* httpResponse)
 /// \return Pointer to the new Http
 ///
 ////////////////////////////////////////////////////////////
-CSFML_API sfHttp* sfHttp_Create();
+CSFML_API sfHttp* sfHttp_Create(void);
 
 ////////////////////////////////////////////////////////////
 /// Destroy an existing Http object

CSFML/include/SFML/Network/IpAddress.h

@@ -96,7 +96,7 @@ CSFML_API sfUint32 sfIpAddress_ToInteger(sfIpAddress address);
 /// \return Local IP address
 ///
 ////////////////////////////////////////////////////////////
-CSFML_API sfIpAddress sfIpAddress_GetLocalAddress();
+CSFML_API sfIpAddress sfIpAddress_GetLocalAddress(void);
 
 ////////////////////////////////////////////////////////////
 /// Get the computer's public IP address (from the web point of view).
@@ -117,7 +117,7 @@ CSFML_API sfIpAddress sfIpAddress_GetPublicAddress(float timeout);
 /// \return Local host IP address (127.0.0.1, or "localhost")
 ///
 ////////////////////////////////////////////////////////////
-CSFML_API sfIpAddress sfIpAddress_LocalHost();
+CSFML_API sfIpAddress sfIpAddress_LocalHost(void);
 
 ////////////////////////////////////////////////////////////
 /// Get the empty/invalid address
@@ -125,7 +125,7 @@ CSFML_API sfIpAddress sfIpAddress_LocalHost();
 /// \return Empty object that represents invalid addresses
 ///
 ////////////////////////////////////////////////////////////
-CSFML_API sfIpAddress sfIpAddress_None();
+CSFML_API sfIpAddress sfIpAddress_None(void);
 
 
 #endif // SFML_IPADDRESS_H

CSFML/include/SFML/Network/Packet.h

@@ -38,7 +38,7 @@
 /// \return A new sfPacket object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_API sfPacket* sfPacket_Create();
+CSFML_API sfPacket* sfPacket_Create(void);
 
 ////////////////////////////////////////////////////////////
 /// Copy an existing packet

CSFML/include/SFML/Network/SocketSelector.h

@@ -38,7 +38,7 @@
 /// \return A new sfSelector object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_API sfSocketSelector* sfSocketSelector_Create();
+CSFML_API sfSocketSelector* sfSocketSelector_Create(void);
 
 ////////////////////////////////////////////////////////////
 /// Copy an existing selector

CSFML/include/SFML/Network/TcpListener.h

@@ -39,7 +39,7 @@
 /// \return Pointer to the new socket
 ///
 ////////////////////////////////////////////////////////////
-CSFML_API sfTcpListener* sfTcpListener_Create();
+CSFML_API sfTcpListener* sfTcpListener_Create(void);
 
 ////////////////////////////////////////////////////////////
 /// Destroy an existing TCP socket

CSFML/include/SFML/Network/TcpSocket.h

@@ -40,7 +40,7 @@
 /// \return Pointer to the new socket
 ///
 ////////////////////////////////////////////////////////////
-CSFML_API sfTcpSocket* sfTcpSocket_Create();
+CSFML_API sfTcpSocket* sfTcpSocket_Create(void);
 
 ////////////////////////////////////////////////////////////
 /// Destroy an existing TCP socket

CSFML/include/SFML/Network/UdpSocket.h

@@ -40,7 +40,7 @@
 /// \return Pointer to the new socket
 ///
 ////////////////////////////////////////////////////////////
-CSFML_API sfUdpSocket* sfUdpSocket_Create();
+CSFML_API sfUdpSocket* sfUdpSocket_Create(void);
 
 ////////////////////////////////////////////////////////////
 /// Destroy an existing UDP socket

CSFML/include/SFML/System/Clock.h

@@ -38,7 +38,7 @@
 /// \return A new sfClock object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_API sfClock* sfClock_Create();
+CSFML_API sfClock* sfClock_Create(void);
 
 ////////////////////////////////////////////////////////////
 /// Copy an existing clock

CSFML/include/SFML/System/Mutex.h

@@ -38,7 +38,7 @@
 /// \return A new sfMutex object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_API sfMutex* sfMutex_Create();
+CSFML_API sfMutex* sfMutex_Create(void);
 
 ////////////////////////////////////////////////////////////
 /// Destroy an existing mutex

CSFML/include/SFML/System/Randomizer.h

@@ -46,7 +46,7 @@ CSFML_API void sfRandom_SetSeed(unsigned int seed);
 /// \return Current seed
 ///
 ////////////////////////////////////////////////////////////
-CSFML_API unsigned int sfRandom_GetSeed();
+CSFML_API unsigned int sfRandom_GetSeed(void);
 
 ////////////////////////////////////////////////////////////
 /// Get a random float number in a given range

CSFML/include/SFML/Window/Context.h

@@ -38,7 +38,7 @@
 /// \return New context
 ///
 ////////////////////////////////////////////////////////////
-CSFML_API sfContext* sfContext_Create();
+CSFML_API sfContext* sfContext_Create(void);
 
 ////////////////////////////////////////////////////////////
 /// Destroy an existing context

CSFML/include/SFML/Window/VideoMode.h

@@ -49,7 +49,7 @@ typedef struct
 /// \return Current desktop video mode
 ///
 ////////////////////////////////////////////////////////////
-CSFML_API sfVideoMode sfVideoMode_GetDesktopMode();
+CSFML_API sfVideoMode sfVideoMode_GetDesktopMode(void);
 
 ////////////////////////////////////////////////////////////
 /// Get all the supported video modes for fullscreen mode.

CSFML/src/SFML/Audio/Listener.cpp

@@ -42,7 +42,7 @@ void sfListener_SetGlobalVolume(float volume)
 ////////////////////////////////////////////////////////////
 /// Get the current value of the global volume of all the sounds
 ////////////////////////////////////////////////////////////
-float sfListener_GetGlobalVolume()
+float sfListener_GetGlobalVolume(void)
 {
     return sf::Listener::GetGlobalVolume();
 }

CSFML/src/SFML/Audio/Sound.cpp

@@ -33,7 +33,7 @@
 ////////////////////////////////////////////////////////////
 /// Construct a new sound
 ////////////////////////////////////////////////////////////
-sfSound* sfSound_Create()
+sfSound* sfSound_Create(void)
 {
     return new sfSound;
 }

CSFML/src/SFML/Audio/SoundBufferRecorder.cpp

@@ -33,7 +33,7 @@
 ////////////////////////////////////////////////////////////
 /// Construct a new sound buffer recorder
 ////////////////////////////////////////////////////////////
-sfSoundBufferRecorder* sfSoundBufferRecorder_Create()
+sfSoundBufferRecorder* sfSoundBufferRecorder_Create(void)
 {
     return new sfSoundBufferRecorder;
 }

CSFML/src/SFML/Audio/SoundRecorder.cpp

@@ -84,7 +84,7 @@ unsigned int sfSoundRecorder_GetSampleRate(const sfSoundRecorder* soundRecorder)
 /// Tell if the system supports sound capture.
 /// If not, this class won't be usable
 ////////////////////////////////////////////////////////////
-sfBool sfSoundRecorder_IsAvailable()
+sfBool sfSoundRecorder_IsAvailable(void)
 {
     return sf::SoundRecorder::IsAvailable() ? sfTrue : sfFalse;
 }

CSFML/src/SFML/Graphics/Font.cpp

@@ -140,7 +140,7 @@ const sfImage* sfFont_GetImage(sfFont* font, unsigned int characterSize)
 ////////////////////////////////////////////////////////////
 /// Get the built-in default font (Arial)
 ////////////////////////////////////////////////////////////
-const sfFont* sfFont_GetDefaultFont()
+const sfFont* sfFont_GetDefaultFont(void)
 {
     static sfFont defaultFont = {sf::Font::GetDefaultFont(), std::map<unsigned int, sfImage>()};
 

CSFML/src/SFML/Graphics/Image.cpp

@@ -34,7 +34,7 @@
 ////////////////////////////////////////////////////////////
 /// Create a new empty image
 ////////////////////////////////////////////////////////////
-sfImage* sfImage_Create()
+sfImage* sfImage_Create(void)
 {
     return new sfImage;
 }

CSFML/src/SFML/Graphics/RenderImage.cpp

@@ -251,7 +251,7 @@ const sfImage* sfRenderImage_GetImage(const sfRenderImage* renderImage)
 ////////////////////////////////////////////////////////////
 /// Check whether the system supports render images or not
 ////////////////////////////////////////////////////////////
-sfBool sfRenderImage_IsAvailable()
+sfBool sfRenderImage_IsAvailable(void)
 {
     return sf::RenderImage::IsAvailable() ? sfTrue : sfFalse;
 }

CSFML/src/SFML/Graphics/Shader.cpp

@@ -151,7 +151,7 @@ void sfShader_Unbind(const sfShader* shader)
 ////////////////////////////////////////////////////////////
 /// Tell whether or not the system supports shaders
 ////////////////////////////////////////////////////////////
-sfBool sfShader_IsAvailable()
+sfBool sfShader_IsAvailable(void)
 {
     return sf::Shader::IsAvailable() ? sfTrue : sfFalse;
 }

CSFML/src/SFML/Graphics/Shape.cpp

@@ -34,7 +34,7 @@
 ////////////////////////////////////////////////////////////
 /// Create a new shape
 ////////////////////////////////////////////////////////////
-sfShape* sfShape_Create()
+sfShape* sfShape_Create(void)
 {
     return new sfShape;
 }

CSFML/src/SFML/Graphics/Sprite.cpp

@@ -35,7 +35,7 @@
 ////////////////////////////////////////////////////////////
 /// Create a new sprite
 ////////////////////////////////////////////////////////////
-sfSprite* sfSprite_Create()
+sfSprite* sfSprite_Create(void)
 {
     sfSprite* sprite       = new sfSprite;
     sprite->Image          = NULL;

CSFML/src/SFML/Graphics/Text.cpp

@@ -35,7 +35,7 @@
 ////////////////////////////////////////////////////////////
 /// Create a new text
 ////////////////////////////////////////////////////////////
-sfText* sfText_Create()
+sfText* sfText_Create(void)
 {
     sfText* text = new sfText;
     text->Font = sfFont_GetDefaultFont();

CSFML/src/SFML/Graphics/View.cpp

@@ -33,7 +33,7 @@
 ////////////////////////////////////////////////////////////
 /// Construct a default view (1000x1000)
 ////////////////////////////////////////////////////////////
-sfView* sfView_Create()
+sfView* sfView_Create(void)
 {
     return new sfView;
 }

CSFML/src/SFML/Network/Ftp.cpp

@@ -190,7 +190,7 @@ const char* sfFtpResponse_GetMessage(const sfFtpResponse* ftpResponse)
 ////////////////////////////////////////////////////////////
 /// Construct a new Ftp
 ////////////////////////////////////////////////////////////
-sfFtp* sfFtp_Create()
+sfFtp* sfFtp_Create(void)
 {
     return new sfFtp;
 }

CSFML/src/SFML/Network/Http.cpp

@@ -33,7 +33,7 @@
 ////////////////////////////////////////////////////////////
 /// Construct a new Http request
 ////////////////////////////////////////////////////////////
-sfHttpRequest* sfHttpRequest_Create()
+sfHttpRequest* sfHttpRequest_Create(void)
 {
     return new sfHttpRequest;
 }
@@ -169,7 +169,7 @@ const char* sfHttpResponse_GetBody(const sfHttpResponse* httpResponse)
 ////////////////////////////////////////////////////////////
 /// Construct a new Http object
 ////////////////////////////////////////////////////////////
-sfHttp* sfHttp_Create()
+sfHttp* sfHttp_Create(void)
 {
     return new sfHttp;
 }

CSFML/src/SFML/Network/IpAddress.cpp

@@ -102,7 +102,7 @@ sfUint32 sfIpAddress_ToInteger(sfIpAddress address)
 ////////////////////////////////////////////////////////////
 /// Get the computer's local IP address (from the LAN point of view)
 ////////////////////////////////////////////////////////////
-sfIpAddress sfIpAddress_GetLocalAddress()
+sfIpAddress sfIpAddress_GetLocalAddress(void)
 {
     return FromSFMLAddress(sf::IpAddress::GetLocalAddress());
 }
@@ -123,7 +123,7 @@ sfIpAddress sfIpAddress_GetPublicAddress(float timeout)
 ////////////////////////////////////////////////////////////
 /// Get the computer's loopback address
 ////////////////////////////////////////////////////////////
-sfIpAddress sfIpAddress_LocalHost()
+sfIpAddress sfIpAddress_LocalHost(void)
 {
     return FromSFMLAddress(sf::IpAddress::LocalHost);
 }
@@ -131,7 +131,7 @@ sfIpAddress sfIpAddress_LocalHost()
 ////////////////////////////////////////////////////////////
 /// Get the empty/invalid address
 ////////////////////////////////////////////////////////////
-sfIpAddress sfIpAddress_None()
+sfIpAddress sfIpAddress_None(void)
 {
     return FromSFMLAddress(sf::IpAddress::None);
 }

CSFML/src/SFML/Network/Packet.cpp

@@ -61,7 +61,7 @@ namespace
 ////////////////////////////////////////////////////////////
 /// Create a new empty packet
 ////////////////////////////////////////////////////////////
-sfPacket* sfPacket_Create()
+sfPacket* sfPacket_Create(void)
 {
     return new sfPacket;
 }

CSFML/src/SFML/Network/SocketSelector.cpp

@@ -36,7 +36,7 @@
 ////////////////////////////////////////////////////////////
 /// Create a new selector
 ////////////////////////////////////////////////////////////
-sfSocketSelector* sfSocketSelector_Create()
+sfSocketSelector* sfSocketSelector_Create(void)
 {
     return new sfSocketSelector;
 }

CSFML/src/SFML/Network/TcpListener.cpp

@@ -34,7 +34,7 @@
 ////////////////////////////////////////////////////////////
 /// Construct a new TCP socket
 ////////////////////////////////////////////////////////////
-sfTcpListener* sfTcpListener_Create()
+sfTcpListener* sfTcpListener_Create(void)
 {
     return new sfTcpListener;
 }

CSFML/src/SFML/Network/TcpSocket.cpp

@@ -36,7 +36,7 @@
 ////////////////////////////////////////////////////////////
 /// Construct a new TCP socket
 ////////////////////////////////////////////////////////////
-sfTcpSocket* sfTcpSocket_Create()
+sfTcpSocket* sfTcpSocket_Create(void)
 {
     return new sfTcpSocket;
 }

CSFML/src/SFML/Network/UdpSocket.cpp

@@ -36,7 +36,7 @@
 ////////////////////////////////////////////////////////////
 /// Construct a new UDP socket
 ////////////////////////////////////////////////////////////
-sfUdpSocket* sfUdpSocket_Create()
+sfUdpSocket* sfUdpSocket_Create(void)
 {
     return new sfUdpSocket;
 }

CSFML/src/SFML/System/Clock.cpp

@@ -33,7 +33,7 @@
 ////////////////////////////////////////////////////////////
 /// Create a new clock and start it
 ////////////////////////////////////////////////////////////
-sfClock* sfClock_Create()
+sfClock* sfClock_Create(void)
 {
     return new sfClock;
 }

CSFML/src/SFML/System/Mutex.cpp

@@ -33,7 +33,7 @@
 ////////////////////////////////////////////////////////////
 /// Create a new mutex
 ////////////////////////////////////////////////////////////
-sfMutex* sfMutex_Create()
+sfMutex* sfMutex_Create(void)
 {
     return new sfMutex;
 }

CSFML/src/SFML/System/Randomizer.cpp

@@ -43,7 +43,7 @@ void sfRandom_SetSeed(unsigned int seed)
 ////////////////////////////////////////////////////////////
 /// Get the seed used to generate random numbers the generator
 ////////////////////////////////////////////////////////////
-unsigned int sfRandom_GetSeed()
+unsigned int sfRandom_GetSeed(void)
 {
     return sf::Randomizer::GetSeed();
 }

CSFML/src/SFML/Window/Context.cpp

@@ -33,7 +33,7 @@
 ////////////////////////////////////////////////////////////
 /// Construct a new context
 ////////////////////////////////////////////////////////////
-sfContext* sfContext_Create()
+sfContext* sfContext_Create(void)
 {
     return new sfContext;
 }

CSFML/src/SFML/Window/VideoMode.cpp

@@ -33,7 +33,7 @@
 ////////////////////////////////////////////////////////////
 /// Get the current desktop video mode
 ////////////////////////////////////////////////////////////
-sfVideoMode sfVideoMode_GetDesktopMode()
+sfVideoMode sfVideoMode_GetDesktopMode(void)
 {
     sf::VideoMode desktop = sf::VideoMode::GetDesktopMode();
     sfVideoMode ret;