wok-stable rev 7031

Add: visualboyadvance & visualboyadvance-gtk (1.7.2)
author Antoine Bodin <gokhlayeh@slitaz.org>
date Sun Oct 31 23:23:34 2010 +0100 (2010-10-31)
parents 28c40f5c21f5
children 79077110c5c7
files visualboyadvance-gtk/receipt visualboyadvance-gtk/stuff/visualboyadvance-gtk.desktop visualboyadvance/receipt visualboyadvance/stuff/1.7.2-deprecatedsigc++.patch visualboyadvance/stuff/1.7.2-gcc34.patch visualboyadvance/stuff/1.7.2-gcc41.patch visualboyadvance/stuff/1.7.2-glibc.patch visualboyadvance/stuff/1.7.2-homedir.patch visualboyadvance/stuff/1.7.2-uninit.patch
line diff
     1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/visualboyadvance-gtk/receipt	Sun Oct 31 23:23:34 2010 +0100
     1.3 @@ -0,0 +1,21 @@
     1.4 +# SliTaz package receipt.
     1.5 +
     1.6 +PACKAGE="visualboyadvance-gtk"
     1.7 +VERSION="1.7.2"
     1.8 +CATEGORY="games"
     1.9 +SHORT_DESC="An emulator for Gameboy and Gameboy Advance systems (GTK frontend)."
    1.10 +MAINTAINER="gokhlayeh@slitaz.org"
    1.11 +WANTED="visualboyadvance"
    1.12 +DEPENDS="libglademm visualboyadvance"
    1.13 +WEB_SITE="http://vba.ngemu.com/"
    1.14 +
    1.15 +# Rules to gen a SliTaz package suitable for Tazpkg.
    1.16 +genpkg_rules()
    1.17 +{
    1.18 +	mkdir -p $fs/usr/bin $fs/usr/games $fs/usr/share/applications
    1.19 +	cp -a stuff/*.desktop $fs/usr/share/applications
    1.20 +	_pkg=${_pkg/$WANTED-$VERSION/VisualBoyAdvance-$VERSION}
    1.21 +	cp -a $_pkg/usr/bin/gvba $fs/usr/bin
    1.22 +	cp -a $_pkg/usr/games/* $fs/usr/games
    1.23 +}
    1.24 +
     2.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.2 +++ b/visualboyadvance-gtk/stuff/visualboyadvance-gtk.desktop	Sun Oct 31 23:23:34 2010 +0100
     2.3 @@ -0,0 +1,9 @@
     2.4 +[Desktop Entry]
     2.5 +Name=Visual Boy Advance GTK+
     2.6 +Comment=An emulator for Gameboy and Gameboy Advance systems
     2.7 +Exec=/usr/bin/gvba
     2.8 +Icon=/usr/games/VisualBoyAdvance/vba-64.png
     2.9 +Terminal=false
    2.10 +Type=Application
    2.11 +Categories=Game;
    2.12 +StartupNotify=false
     3.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     3.2 +++ b/visualboyadvance/receipt	Sun Oct 31 23:23:34 2010 +0100
     3.3 @@ -0,0 +1,41 @@
     3.4 +# SliTaz package receipt.
     3.5 +
     3.6 +PACKAGE="visualboyadvance"
     3.7 +VERSION="1.7.2"
     3.8 +CATEGORY="games"
     3.9 +SHORT_DESC="An emulator for Gameboy and Gameboy Advance systems."
    3.10 +MAINTAINER="gokhlayeh@slitaz.org"
    3.11 +DEPENDS="libsdl"
    3.12 +BUILD_DEPENDS="libglademm-dev libglademm libsdl-dev patch nasm gtk+-dev gtkmm-dev cairomm-dev libglade-dev libxml2-dev zlib-dev"
    3.13 +SOURCE="VisualBoyAdvance"
    3.14 +TARBALL="$SOURCE-src-$VERSION.tar.gz"
    3.15 +CONFIG_FILES="'/etc/VisualBoyAdvance.cfg"
    3.16 +WEB_SITE="http://vba.ngemu.com/"
    3.17 +WGET_URL="http://downloads.sourceforge.net/sourceforge/vba/$TARBALL"
    3.18 +
    3.19 +# Rules to configure and make the package.
    3.20 +compile_rules()
    3.21 +{
    3.22 +	cd $src
    3.23 +	for i in ../stuff/$VERSION-*.patch; do
    3.24 +		patch -Np0 < $i
    3.25 +	done
    3.26 +	./configure \
    3.27 +		--prefix=/usr \
    3.28 +		--infodir=/usr/share/info \
    3.29 +		--mandir=/usr/share/man \
    3.30 +		--sysconfdir=/etc \
    3.31 +		--datadir=/usr/games \
    3.32 +		--enable-gtk=2.4 \
    3.33 +		$CONFIGURE_ARGS &&
    3.34 +	make -j 4 && make DESTDIR=$PWD/_pkg install
    3.35 +}
    3.36 +
    3.37 +# Rules to gen a SliTaz package suitable for Tazpkg.
    3.38 +genpkg_rules()
    3.39 +{
    3.40 +	mkdir -p $fs/usr/bin
    3.41 +	cp -a $_pkg/etc $fs
    3.42 +	cp -a $_pkg/usr/bin/VisualBoyAdvance $fs/usr/bin
    3.43 +}
    3.44 +
     4.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     4.2 +++ b/visualboyadvance/stuff/1.7.2-deprecatedsigc++.patch	Sun Oct 31 23:23:34 2010 +0100
     4.3 @@ -0,0 +1,692 @@
     4.4 +--- src/gtk/sigccompat.h.old	2008-05-02 10:46:45.000000000 +0200
     4.5 ++++ src/gtk/sigccompat.h	2008-05-02 10:47:08.000000000 +0200
     4.6 +@@ -20,7 +20,7 @@
     4.7 + #ifndef __VBA_SIGCCOMPAT_H__
     4.8 + #define __VBA_SIGCCOMPAT_H__
     4.9 + 
    4.10 +-#undef LIBSIGC_DISABLE_DEPRECATED
    4.11 ++#define LIBSIGC_DISABLE_DEPRECATED
    4.12 + #include <sigc++/bind.h>
    4.13 + #include <sigc++/connection.h>
    4.14 + 
    4.15 +@@ -28,9 +28,679 @@
    4.16 + #include <sigc++/object.h>
    4.17 + #include <sigc++/functors/mem_fun.h>
    4.18 + 
    4.19 +-namespace SigC
    4.20 ++
    4.21 ++// From sigc++/bind.h
    4.22 ++namespace SigC {
    4.23 ++
    4.24 ++template <class T_bound1, class T_functor>
    4.25 ++inline ::sigc::bind_functor<-1, T_functor,
    4.26 ++                            typename ::sigc::unwrap_reference<T_bound1>::type>
    4.27 ++bind(const T_functor& _A_functor, T_bound1 _A_b1)
    4.28 ++{ return ::sigc::bind_functor<-1, T_functor,
    4.29 ++                              typename ::sigc::unwrap_reference<T_bound1>::type>
    4.30 ++                              (_A_functor, _A_b1);
    4.31 ++}
    4.32 ++
    4.33 ++template <class T_bound1, class T_bound2, class T_functor>
    4.34 ++inline ::sigc::bind_functor<-1, T_functor,
    4.35 ++                            typename ::sigc::unwrap_reference<T_bound1>::type,
    4.36 ++                            typename ::sigc::unwrap_reference<T_bound2>::type>
    4.37 ++bind(const T_functor& _A_functor, T_bound1 _A_b1, T_bound2 _A_b2)
    4.38 ++{ return ::sigc::bind_functor<-1, T_functor,
    4.39 ++                              typename ::sigc::unwrap_reference<T_bound1>::type,
    4.40 ++                              typename ::sigc::unwrap_reference<T_bound2>::type>
    4.41 ++                              (_A_functor, _A_b1, _A_b2); 
    4.42 ++}
    4.43 ++
    4.44 ++template <class T_bound1, class T_bound2, class T_bound3, class T_functor>
    4.45 ++inline ::sigc::bind_functor<-1, T_functor,
    4.46 ++                            typename ::sigc::unwrap_reference<T_bound1>::type,
    4.47 ++                            typename ::sigc::unwrap_reference<T_bound2>::type,
    4.48 ++                            typename ::sigc::unwrap_reference<T_bound3>::type>
    4.49 ++bind(const T_functor& _A_functor, T_bound1 _A_b1, T_bound2 _A_b2,T_bound3 _A_b3)
    4.50 ++{ return ::sigc::bind_functor<-1, T_functor,
    4.51 ++                              typename ::sigc::unwrap_reference<T_bound1>::type,
    4.52 ++                              typename ::sigc::unwrap_reference<T_bound2>::type,
    4.53 ++                              typename ::sigc::unwrap_reference<T_bound3>::type>
    4.54 ++                              (_A_functor, _A_b1, _A_b2, _A_b3);
    4.55 ++}
    4.56 ++
    4.57 ++}
    4.58 ++
    4.59 ++// From sigc++/connection.h
    4.60 ++namespace SigC {
    4.61 ++
    4.62 ++/** Convinience class for safe disconnection.
    4.63 ++ * Iterators must not be used beyond the lifetime of the list
    4.64 ++ * they work on. A connection object can be created from a
    4.65 ++ * slot list iterator and may safely be used to disconnect
    4.66 ++ * the referred slot at any time (disconnect()). If the slot
    4.67 ++ * has already been destroyed, disconnect() does nothing. empty() or
    4.68 ++ * operator bool() can be used to test whether the connection is
    4.69 ++ * still active. The connection can be blocked (block(), unblock()).
    4.70 ++ *
    4.71 ++ * This is possible because the connection object gets notified
    4.72 ++ * when the referred slot dies (notify()).
    4.73 ++ *
    4.74 ++ * @deprecated Use sigc::connection instead.
    4.75 ++ * @ingroup compat
    4.76 ++ */
    4.77 ++typedef ::sigc::connection Connection;
    4.78 ++
    4.79 ++}
    4.80 ++
    4.81 ++// From sigc++/slot.h
    4.82 ++namespace SigC {
    4.83 ++
    4.84 ++// SlotN
    4.85 ++/** Converts an arbitrary functor to a unified type which is opaque.
    4.86 ++ * Slot0 itself is a functor or to be more precise a closure. It contains
    4.87 ++ * a single, arbitrary functor (or closure) that is executed in operator()().
    4.88 ++ *
    4.89 ++ * The template arguments determine the function signature of operator()():
    4.90 ++ * - @e T_return The return type of operator()().
    4.91 ++ *
    4.92 ++ * To use simply assign the slot to the desired functor. If the functor
    4.93 ++ * is not compatible with the parameter list defined with the template
    4.94 ++ * arguments compiler errors are triggered. When called the slot
    4.95 ++ * will invoke the functor with minimal copies.
    4.96 ++ * block() and unblock() can be used to block the functor's invocation
    4.97 ++ * from operator()() temporarily.
    4.98 ++ *
    4.99 ++ * @par Example:
   4.100 ++ *   @code
   4.101 ++ *   #include <sigc++/slot.h>
   4.102 ++ *   void foo(int) {}
   4.103 ++ *   SigC::Slot1<void, long> s = SigC::slot(&foo);
   4.104 ++ *   s(19);
   4.105 ++ *   @endcode
   4.106 ++ *
   4.107 ++ * @deprecated Use the unnumbered template sigc::slot instead.
   4.108 ++ * @ingroup compat
   4.109 ++ */
   4.110 ++template <class T_return>
   4.111 ++class Slot0
   4.112 ++  : public ::sigc::slot<T_return>
   4.113 ++{
   4.114 ++public:
   4.115 ++  typedef ::sigc::slot<T_return> parent_type;
   4.116 ++
   4.117 ++  /// Constructs an empty slot.
   4.118 ++  Slot0() {}
   4.119 ++
   4.120 ++  /** Constructs a slot from an arbitrary functor.
   4.121 ++   * @param _A_func The desired functor the new slot should be assigned to.
   4.122 ++   */
   4.123 ++  template <class T_functor>
   4.124 ++  Slot0(const T_functor& _A_func)
   4.125 ++    : ::sigc::slot<T_return>(_A_func) {}
   4.126 ++
   4.127 ++  /** Constructs a slot, copying an existing one.
   4.128 ++   * @param src The existing slot to copy.
   4.129 ++   */
   4.130 ++  Slot0(const parent_type& src)
   4.131 ++    : parent_type(src) {}
   4.132 ++
   4.133 ++  /** Overrides this slot making a copy from another slot.
   4.134 ++   * @param src The slot from which to make a copy.
   4.135 ++   * @return @p this.
   4.136 ++   */
   4.137 ++  Slot0& operator=(const parent_type& src)
   4.138 ++    { parent_type::operator=(src); return *this; }
   4.139 ++};
   4.140 ++
   4.141 ++/** Converts an arbitrary functor to a unified type which is opaque.
   4.142 ++ * Slot1 itself is a functor or to be more precise a closure. It contains
   4.143 ++ * a single, arbitrary functor (or closure) that is executed in operator()().
   4.144 ++ *
   4.145 ++ * The template arguments determine the function signature of operator()():
   4.146 ++ * - @e T_return The return type of operator()().
   4.147 ++ * - @e T_arg1 Argument type used in the definition of operator()().
   4.148 ++ *
   4.149 ++ * To use simply assign the slot to the desired functor. If the functor
   4.150 ++ * is not compatible with the parameter list defined with the template
   4.151 ++ * arguments compiler errors are triggered. When called the slot
   4.152 ++ * will invoke the functor with minimal copies.
   4.153 ++ * block() and unblock() can be used to block the functor's invocation
   4.154 ++ * from operator()() temporarily.
   4.155 ++ *
   4.156 ++ * @par Example:
   4.157 ++ *   @code
   4.158 ++ *   #include <sigc++/slot.h>
   4.159 ++ *   void foo(int) {}
   4.160 ++ *   SigC::Slot1<void, long> s = SigC::slot(&foo);
   4.161 ++ *   s(19);
   4.162 ++ *   @endcode
   4.163 ++ *
   4.164 ++ * @deprecated Use the unnumbered template sigc::slot instead.
   4.165 ++ * @ingroup compat
   4.166 ++ */
   4.167 ++template <class T_return, class T_arg1>
   4.168 ++class Slot1
   4.169 ++  : public ::sigc::slot<T_return, T_arg1>
   4.170 ++{
   4.171 ++public:
   4.172 ++  typedef ::sigc::slot<T_return, T_arg1> parent_type;
   4.173 ++
   4.174 ++  /// Constructs an empty slot.
   4.175 ++  Slot1() {}
   4.176 ++
   4.177 ++  /** Constructs a slot from an arbitrary functor.
   4.178 ++   * @param _A_func The desired functor the new slot should be assigned to.
   4.179 ++   */
   4.180 ++  template <class T_functor>
   4.181 ++  Slot1(const T_functor& _A_func)
   4.182 ++    : ::sigc::slot<T_return, T_arg1>(_A_func) {}
   4.183 ++
   4.184 ++  /** Constructs a slot, copying an existing one.
   4.185 ++   * @param src The existing slot to copy.
   4.186 ++   */
   4.187 ++  Slot1(const parent_type& src)
   4.188 ++    : parent_type(src) {}
   4.189 ++
   4.190 ++  /** Overrides this slot making a copy from another slot.
   4.191 ++   * @param src The slot from which to make a copy.
   4.192 ++   * @return @p this.
   4.193 ++   */
   4.194 ++  Slot1& operator=(const parent_type& src)
   4.195 ++    { parent_type::operator=(src); return *this; }
   4.196 ++};
   4.197 ++
   4.198 ++/** Converts an arbitrary functor to a unified type which is opaque.
   4.199 ++ * Slot2 itself is a functor or to be more precise a closure. It contains
   4.200 ++ * a single, arbitrary functor (or closure) that is executed in operator()().
   4.201 ++ *
   4.202 ++ * The template arguments determine the function signature of operator()():
   4.203 ++ * - @e T_return The return type of operator()().
   4.204 ++ * - @e T_arg1 Argument type used in the definition of operator()().
   4.205 ++ * - @e T_arg2 Argument type used in the definition of operator()().
   4.206 ++ *
   4.207 ++ * To use simply assign the slot to the desired functor. If the functor
   4.208 ++ * is not compatible with the parameter list defined with the template
   4.209 ++ * arguments compiler errors are triggered. When called the slot
   4.210 ++ * will invoke the functor with minimal copies.
   4.211 ++ * block() and unblock() can be used to block the functor's invocation
   4.212 ++ * from operator()() temporarily.
   4.213 ++ *
   4.214 ++ * @par Example:
   4.215 ++ *   @code
   4.216 ++ *   #include <sigc++/slot.h>
   4.217 ++ *   void foo(int) {}
   4.218 ++ *   SigC::Slot1<void, long> s = SigC::slot(&foo);
   4.219 ++ *   s(19);
   4.220 ++ *   @endcode
   4.221 ++ *
   4.222 ++ * @deprecated Use the unnumbered template sigc::slot instead.
   4.223 ++ * @ingroup compat
   4.224 ++ */
   4.225 ++template <class T_return, class T_arg1,class T_arg2>
   4.226 ++class Slot2
   4.227 ++  : public ::sigc::slot<T_return, T_arg1,T_arg2>
   4.228 ++{
   4.229 ++public:
   4.230 ++  typedef ::sigc::slot<T_return, T_arg1,T_arg2> parent_type;
   4.231 ++
   4.232 ++  /// Constructs an empty slot.
   4.233 ++  Slot2() {}
   4.234 ++
   4.235 ++  /** Constructs a slot from an arbitrary functor.
   4.236 ++   * @param _A_func The desired functor the new slot should be assigned to.
   4.237 ++   */
   4.238 ++  template <class T_functor>
   4.239 ++  Slot2(const T_functor& _A_func)
   4.240 ++    : ::sigc::slot<T_return, T_arg1,T_arg2>(_A_func) {}
   4.241 ++
   4.242 ++  /** Constructs a slot, copying an existing one.
   4.243 ++   * @param src The existing slot to copy.
   4.244 ++   */
   4.245 ++  Slot2(const parent_type& src)
   4.246 ++    : parent_type(src) {}
   4.247 ++
   4.248 ++  /** Overrides this slot making a copy from another slot.
   4.249 ++   * @param src The slot from which to make a copy.
   4.250 ++   * @return @p this.
   4.251 ++   */
   4.252 ++  Slot2& operator=(const parent_type& src)
   4.253 ++    { parent_type::operator=(src); return *this; }
   4.254 ++};
   4.255 ++
   4.256 ++/** Converts an arbitrary functor to a unified type which is opaque.
   4.257 ++ * Slot3 itself is a functor or to be more precise a closure. It contains
   4.258 ++ * a single, arbitrary functor (or closure) that is executed in operator()().
   4.259 ++ *
   4.260 ++ * The template arguments determine the function signature of operator()():
   4.261 ++ * - @e T_return The return type of operator()().
   4.262 ++ * - @e T_arg1 Argument type used in the definition of operator()().
   4.263 ++ * - @e T_arg2 Argument type used in the definition of operator()().
   4.264 ++ * - @e T_arg3 Argument type used in the definition of operator()().
   4.265 ++ *
   4.266 ++ * To use simply assign the slot to the desired functor. If the functor
   4.267 ++ * is not compatible with the parameter list defined with the template
   4.268 ++ * arguments compiler errors are triggered. When called the slot
   4.269 ++ * will invoke the functor with minimal copies.
   4.270 ++ * block() and unblock() can be used to block the functor's invocation
   4.271 ++ * from operator()() temporarily.
   4.272 ++ *
   4.273 ++ * @par Example:
   4.274 ++ *   @code
   4.275 ++ *   #include <sigc++/slot.h>
   4.276 ++ *   void foo(int) {}
   4.277 ++ *   SigC::Slot1<void, long> s = SigC::slot(&foo);
   4.278 ++ *   s(19);
   4.279 ++ *   @endcode
   4.280 ++ *
   4.281 ++ * @deprecated Use the unnumbered template sigc::slot instead.
   4.282 ++ * @ingroup compat
   4.283 ++ */
   4.284 ++template <class T_return, class T_arg1,class T_arg2,class T_arg3>
   4.285 ++class Slot3
   4.286 ++  : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3>
   4.287 ++{
   4.288 ++public:
   4.289 ++  typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3> parent_type;
   4.290 ++
   4.291 ++  /// Constructs an empty slot.
   4.292 ++  Slot3() {}
   4.293 ++
   4.294 ++  /** Constructs a slot from an arbitrary functor.
   4.295 ++   * @param _A_func The desired functor the new slot should be assigned to.
   4.296 ++   */
   4.297 ++  template <class T_functor>
   4.298 ++  Slot3(const T_functor& _A_func)
   4.299 ++    : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3>(_A_func) {}
   4.300 ++
   4.301 ++  /** Constructs a slot, copying an existing one.
   4.302 ++   * @param src The existing slot to copy.
   4.303 ++   */
   4.304 ++  Slot3(const parent_type& src)
   4.305 ++    : parent_type(src) {}
   4.306 ++
   4.307 ++  /** Overrides this slot making a copy from another slot.
   4.308 ++   * @param src The slot from which to make a copy.
   4.309 ++   * @return @p this.
   4.310 ++   */
   4.311 ++  Slot3& operator=(const parent_type& src)
   4.312 ++    { parent_type::operator=(src); return *this; }
   4.313 ++};
   4.314 ++
   4.315 ++/** Converts an arbitrary functor to a unified type which is opaque.
   4.316 ++ * Slot4 itself is a functor or to be more precise a closure. It contains
   4.317 ++ * a single, arbitrary functor (or closure) that is executed in operator()().
   4.318 ++ *
   4.319 ++ * The template arguments determine the function signature of operator()():
   4.320 ++ * - @e T_return The return type of operator()().
   4.321 ++ * - @e T_arg1 Argument type used in the definition of operator()().
   4.322 ++ * - @e T_arg2 Argument type used in the definition of operator()().
   4.323 ++ * - @e T_arg3 Argument type used in the definition of operator()().
   4.324 ++ * - @e T_arg4 Argument type used in the definition of operator()().
   4.325 ++ *
   4.326 ++ * To use simply assign the slot to the desired functor. If the functor
   4.327 ++ * is not compatible with the parameter list defined with the template
   4.328 ++ * arguments compiler errors are triggered. When called the slot
   4.329 ++ * will invoke the functor with minimal copies.
   4.330 ++ * block() and unblock() can be used to block the functor's invocation
   4.331 ++ * from operator()() temporarily.
   4.332 ++ *
   4.333 ++ * @par Example:
   4.334 ++ *   @code
   4.335 ++ *   #include <sigc++/slot.h>
   4.336 ++ *   void foo(int) {}
   4.337 ++ *   SigC::Slot1<void, long> s = SigC::slot(&foo);
   4.338 ++ *   s(19);
   4.339 ++ *   @endcode
   4.340 ++ *
   4.341 ++ * @deprecated Use the unnumbered template sigc::slot instead.
   4.342 ++ * @ingroup compat
   4.343 ++ */
   4.344 ++template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   4.345 ++class Slot4
   4.346 ++  : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4>
   4.347 ++{
   4.348 ++public:
   4.349 ++  typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4> parent_type;
   4.350 ++
   4.351 ++  /// Constructs an empty slot.
   4.352 ++  Slot4() {}
   4.353 ++
   4.354 ++  /** Constructs a slot from an arbitrary functor.
   4.355 ++   * @param _A_func The desired functor the new slot should be assigned to.
   4.356 ++   */
   4.357 ++  template <class T_functor>
   4.358 ++  Slot4(const T_functor& _A_func)
   4.359 ++    : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4>(_A_func) {}
   4.360 ++
   4.361 ++  /** Constructs a slot, copying an existing one.
   4.362 ++   * @param src The existing slot to copy.
   4.363 ++   */
   4.364 ++  Slot4(const parent_type& src)
   4.365 ++    : parent_type(src) {}
   4.366 ++
   4.367 ++  /** Overrides this slot making a copy from another slot.
   4.368 ++   * @param src The slot from which to make a copy.
   4.369 ++   * @return @p this.
   4.370 ++   */
   4.371 ++  Slot4& operator=(const parent_type& src)
   4.372 ++    { parent_type::operator=(src); return *this; }
   4.373 ++};
   4.374 ++
   4.375 ++/** Converts an arbitrary functor to a unified type which is opaque.
   4.376 ++ * Slot5 itself is a functor or to be more precise a closure. It contains
   4.377 ++ * a single, arbitrary functor (or closure) that is executed in operator()().
   4.378 ++ *
   4.379 ++ * The template arguments determine the function signature of operator()():
   4.380 ++ * - @e T_return The return type of operator()().
   4.381 ++ * - @e T_arg1 Argument type used in the definition of operator()().
   4.382 ++ * - @e T_arg2 Argument type used in the definition of operator()().
   4.383 ++ * - @e T_arg3 Argument type used in the definition of operator()().
   4.384 ++ * - @e T_arg4 Argument type used in the definition of operator()().
   4.385 ++ * - @e T_arg5 Argument type used in the definition of operator()().
   4.386 ++ *
   4.387 ++ * To use simply assign the slot to the desired functor. If the functor
   4.388 ++ * is not compatible with the parameter list defined with the template
   4.389 ++ * arguments compiler errors are triggered. When called the slot
   4.390 ++ * will invoke the functor with minimal copies.
   4.391 ++ * block() and unblock() can be used to block the functor's invocation
   4.392 ++ * from operator()() temporarily.
   4.393 ++ *
   4.394 ++ * @par Example:
   4.395 ++ *   @code
   4.396 ++ *   #include <sigc++/slot.h>
   4.397 ++ *   void foo(int) {}
   4.398 ++ *   SigC::Slot1<void, long> s = SigC::slot(&foo);
   4.399 ++ *   s(19);
   4.400 ++ *   @endcode
   4.401 ++ *
   4.402 ++ * @deprecated Use the unnumbered template sigc::slot instead.
   4.403 ++ * @ingroup compat
   4.404 ++ */
   4.405 ++template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   4.406 ++class Slot5
   4.407 ++  : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
   4.408 ++{
   4.409 ++public:
   4.410 ++  typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> parent_type;
   4.411 ++
   4.412 ++  /// Constructs an empty slot.
   4.413 ++  Slot5() {}
   4.414 ++
   4.415 ++  /** Constructs a slot from an arbitrary functor.
   4.416 ++   * @param _A_func The desired functor the new slot should be assigned to.
   4.417 ++   */
   4.418 ++  template <class T_functor>
   4.419 ++  Slot5(const T_functor& _A_func)
   4.420 ++    : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(_A_func) {}
   4.421 ++
   4.422 ++  /** Constructs a slot, copying an existing one.
   4.423 ++   * @param src The existing slot to copy.
   4.424 ++   */
   4.425 ++  Slot5(const parent_type& src)
   4.426 ++    : parent_type(src) {}
   4.427 ++
   4.428 ++  /** Overrides this slot making a copy from another slot.
   4.429 ++   * @param src The slot from which to make a copy.
   4.430 ++   * @return @p this.
   4.431 ++   */
   4.432 ++  Slot5& operator=(const parent_type& src)
   4.433 ++    { parent_type::operator=(src); return *this; }
   4.434 ++};
   4.435 ++
   4.436 ++/** Converts an arbitrary functor to a unified type which is opaque.
   4.437 ++ * Slot6 itself is a functor or to be more precise a closure. It contains
   4.438 ++ * a single, arbitrary functor (or closure) that is executed in operator()().
   4.439 ++ *
   4.440 ++ * The template arguments determine the function signature of operator()():
   4.441 ++ * - @e T_return The return type of operator()().
   4.442 ++ * - @e T_arg1 Argument type used in the definition of operator()().
   4.443 ++ * - @e T_arg2 Argument type used in the definition of operator()().
   4.444 ++ * - @e T_arg3 Argument type used in the definition of operator()().
   4.445 ++ * - @e T_arg4 Argument type used in the definition of operator()().
   4.446 ++ * - @e T_arg5 Argument type used in the definition of operator()().
   4.447 ++ * - @e T_arg6 Argument type used in the definition of operator()().
   4.448 ++ *
   4.449 ++ * To use simply assign the slot to the desired functor. If the functor
   4.450 ++ * is not compatible with the parameter list defined with the template
   4.451 ++ * arguments compiler errors are triggered. When called the slot
   4.452 ++ * will invoke the functor with minimal copies.
   4.453 ++ * block() and unblock() can be used to block the functor's invocation
   4.454 ++ * from operator()() temporarily.
   4.455 ++ *
   4.456 ++ * @par Example:
   4.457 ++ *   @code
   4.458 ++ *   #include <sigc++/slot.h>
   4.459 ++ *   void foo(int) {}
   4.460 ++ *   SigC::Slot1<void, long> s = SigC::slot(&foo);
   4.461 ++ *   s(19);
   4.462 ++ *   @endcode
   4.463 ++ *
   4.464 ++ * @deprecated Use the unnumbered template sigc::slot instead.
   4.465 ++ * @ingroup compat
   4.466 ++ */
   4.467 ++template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   4.468 ++class Slot6
   4.469 ++  : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
   4.470 ++{
   4.471 ++public:
   4.472 ++  typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> parent_type;
   4.473 ++
   4.474 ++  /// Constructs an empty slot.
   4.475 ++  Slot6() {}
   4.476 ++
   4.477 ++  /** Constructs a slot from an arbitrary functor.
   4.478 ++   * @param _A_func The desired functor the new slot should be assigned to.
   4.479 ++   */
   4.480 ++  template <class T_functor>
   4.481 ++  Slot6(const T_functor& _A_func)
   4.482 ++    : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(_A_func) {}
   4.483 ++
   4.484 ++  /** Constructs a slot, copying an existing one.
   4.485 ++   * @param src The existing slot to copy.
   4.486 ++   */
   4.487 ++  Slot6(const parent_type& src)
   4.488 ++    : parent_type(src) {}
   4.489 ++
   4.490 ++  /** Overrides this slot making a copy from another slot.
   4.491 ++   * @param src The slot from which to make a copy.
   4.492 ++   * @return @p this.
   4.493 ++   */
   4.494 ++  Slot6& operator=(const parent_type& src)
   4.495 ++    { parent_type::operator=(src); return *this; }
   4.496 ++};
   4.497 ++
   4.498 ++/** Converts an arbitrary functor to a unified type which is opaque.
   4.499 ++ * Slot7 itself is a functor or to be more precise a closure. It contains
   4.500 ++ * a single, arbitrary functor (or closure) that is executed in operator()().
   4.501 ++ *
   4.502 ++ * The template arguments determine the function signature of operator()():
   4.503 ++ * - @e T_return The return type of operator()().
   4.504 ++ * - @e T_arg1 Argument type used in the definition of operator()().
   4.505 ++ * - @e T_arg2 Argument type used in the definition of operator()().
   4.506 ++ * - @e T_arg3 Argument type used in the definition of operator()().
   4.507 ++ * - @e T_arg4 Argument type used in the definition of operator()().
   4.508 ++ * - @e T_arg5 Argument type used in the definition of operator()().
   4.509 ++ * - @e T_arg6 Argument type used in the definition of operator()().
   4.510 ++ * - @e T_arg7 Argument type used in the definition of operator()().
   4.511 ++ *
   4.512 ++ * To use simply assign the slot to the desired functor. If the functor
   4.513 ++ * is not compatible with the parameter list defined with the template
   4.514 ++ * arguments compiler errors are triggered. When called the slot
   4.515 ++ * will invoke the functor with minimal copies.
   4.516 ++ * block() and unblock() can be used to block the functor's invocation
   4.517 ++ * from operator()() temporarily.
   4.518 ++ *
   4.519 ++ * @par Example:
   4.520 ++ *   @code
   4.521 ++ *   #include <sigc++/slot.h>
   4.522 ++ *   void foo(int) {}
   4.523 ++ *   SigC::Slot1<void, long> s = SigC::slot(&foo);
   4.524 ++ *   s(19);
   4.525 ++ *   @endcode
   4.526 ++ *
   4.527 ++ * @deprecated Use the unnumbered template sigc::slot instead.
   4.528 ++ * @ingroup compat
   4.529 ++ */
   4.530 ++template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   4.531 ++class Slot7
   4.532 ++  : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
   4.533 + {
   4.534 ++public:
   4.535 ++  typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> parent_type;
   4.536 ++
   4.537 ++  /// Constructs an empty slot.
   4.538 ++  Slot7() {}
   4.539 ++
   4.540 ++  /** Constructs a slot from an arbitrary functor.
   4.541 ++   * @param _A_func The desired functor the new slot should be assigned to.
   4.542 ++   */
   4.543 ++  template <class T_functor>
   4.544 ++  Slot7(const T_functor& _A_func)
   4.545 ++    : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(_A_func) {}
   4.546 ++
   4.547 ++  /** Constructs a slot, copying an existing one.
   4.548 ++   * @param src The existing slot to copy.
   4.549 ++   */
   4.550 ++  Slot7(const parent_type& src)
   4.551 ++    : parent_type(src) {}
   4.552 ++
   4.553 ++  /** Overrides this slot making a copy from another slot.
   4.554 ++   * @param src The slot from which to make a copy.
   4.555 ++   * @return @p this.
   4.556 ++   */
   4.557 ++  Slot7& operator=(const parent_type& src)
   4.558 ++    { parent_type::operator=(src); return *this; }
   4.559 ++};
   4.560 ++
   4.561 ++
   4.562 ++
   4.563 ++#ifndef DOXYGEN_SHOULD_SKIP_THIS
   4.564 ++/* gcc 3.2 reports a strange conflict between SigC::slot() and sigc::slot<>
   4.565 ++ * when "using namespace SigC" and later using a slot(obj,func) overload
   4.566 ++ * without the prefix "SigC::". Probably a compiler bug. I will investigate.
   4.567 ++ *
   4.568 ++ * This ugly hack avoids the error:
   4.569 ++ */
   4.570 ++// #define slot(...) make_slot(__VA_ARGS__) /* only works for gcc */
   4.571 ++#endif
   4.572 + 
   4.573 ++
   4.574 ++// slot()
   4.575 ++/** Creates a functor of type SigC::Slot0 that wraps an existing non-member function.
   4.576 ++ *
   4.577 ++ * @param _A_func Pointer to function that should be wrapped.
   4.578 ++ * @return Functor that executes _A_func on invokation.
   4.579 ++ *
   4.580 ++ * @deprecated Use sigc::ptr_fun() instead.
   4.581 ++ * @ingroup compat
   4.582 ++ */
   4.583 ++template <class T_return>
   4.584 ++inline Slot0<T_return>
   4.585 ++slot(T_return (*_A_func)())
   4.586 ++{ return Slot0<T_return>(_A_func); }
   4.587 ++
   4.588 ++/** Creates a functor of type SigC::Slot1 that wraps an existing non-member function.
   4.589 ++ *
   4.590 ++ * @param _A_func Pointer to function that should be wrapped.
   4.591 ++ * @return Functor that executes _A_func on invokation.
   4.592 ++ *
   4.593 ++ * @deprecated Use sigc::ptr_fun() instead.
   4.594 ++ * @ingroup compat
   4.595 ++ */
   4.596 ++template <class T_return, class T_arg1>
   4.597 ++inline Slot1<T_return, T_arg1>
   4.598 ++slot(T_return (*_A_func)(T_arg1))
   4.599 ++{ return Slot1<T_return, T_arg1>(_A_func); }
   4.600 ++
   4.601 ++/** Creates a functor of type SigC::Slot2 that wraps an existing non-member function.
   4.602 ++ *
   4.603 ++ * @param _A_func Pointer to function that should be wrapped.
   4.604 ++ * @return Functor that executes _A_func on invokation.
   4.605 ++ *
   4.606 ++ * @deprecated Use sigc::ptr_fun() instead.
   4.607 ++ * @ingroup compat
   4.608 ++ */
   4.609 ++template <class T_return, class T_arg1,class T_arg2>
   4.610 ++inline Slot2<T_return, T_arg1,T_arg2>
   4.611 ++slot(T_return (*_A_func)(T_arg1,T_arg2))
   4.612 ++{ return Slot2<T_return, T_arg1,T_arg2>(_A_func); }
   4.613 ++
   4.614 ++/** Creates a functor of type SigC::Slot3 that wraps an existing non-member function.
   4.615 ++ *
   4.616 ++ * @param _A_func Pointer to function that should be wrapped.
   4.617 ++ * @return Functor that executes _A_func on invokation.
   4.618 ++ *
   4.619 ++ * @deprecated Use sigc::ptr_fun() instead.
   4.620 ++ * @ingroup compat
   4.621 ++ */
   4.622 ++template <class T_return, class T_arg1,class T_arg2,class T_arg3>
   4.623 ++inline Slot3<T_return, T_arg1,T_arg2,T_arg3>
   4.624 ++slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3))
   4.625 ++{ return Slot3<T_return, T_arg1,T_arg2,T_arg3>(_A_func); }
   4.626 ++
   4.627 ++/** Creates a functor of type SigC::Slot4 that wraps an existing non-member function.
   4.628 ++ *
   4.629 ++ * @param _A_func Pointer to function that should be wrapped.
   4.630 ++ * @return Functor that executes _A_func on invokation.
   4.631 ++ *
   4.632 ++ * @deprecated Use sigc::ptr_fun() instead.
   4.633 ++ * @ingroup compat
   4.634 ++ */
   4.635 ++template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   4.636 ++inline Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4>
   4.637 ++slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4))
   4.638 ++{ return Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4>(_A_func); }
   4.639 ++
   4.640 ++/** Creates a functor of type SigC::Slot5 that wraps an existing non-member function.
   4.641 ++ *
   4.642 ++ * @param _A_func Pointer to function that should be wrapped.
   4.643 ++ * @return Functor that executes _A_func on invokation.
   4.644 ++ *
   4.645 ++ * @deprecated Use sigc::ptr_fun() instead.
   4.646 ++ * @ingroup compat
   4.647 ++ */
   4.648 ++template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   4.649 ++inline Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
   4.650 ++slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5))
   4.651 ++{ return Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(_A_func); }
   4.652 ++
   4.653 ++/** Creates a functor of type SigC::Slot6 that wraps an existing non-member function.
   4.654 ++ *
   4.655 ++ * @param _A_func Pointer to function that should be wrapped.
   4.656 ++ * @return Functor that executes _A_func on invokation.
   4.657 ++ *
   4.658 ++ * @deprecated Use sigc::ptr_fun() instead.
   4.659 ++ * @ingroup compat
   4.660 ++ */
   4.661 ++template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   4.662 ++inline Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
   4.663 ++slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6))
   4.664 ++{ return Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(_A_func); }
   4.665 ++
   4.666 ++/** Creates a functor of type SigC::Slot7 that wraps an existing non-member function.
   4.667 ++ *
   4.668 ++ * @param _A_func Pointer to function that should be wrapped.
   4.669 ++ * @return Functor that executes _A_func on invokation.
   4.670 ++ *
   4.671 ++ * @deprecated Use sigc::ptr_fun() instead.
   4.672 ++ * @ingroup compat
   4.673 ++ */
   4.674 ++template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   4.675 ++inline Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
   4.676 ++slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7))
   4.677 ++{ return Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(_A_func); }
   4.678 ++
   4.679 ++
   4.680 ++
   4.681 ++}
   4.682 ++
   4.683 ++// From sigc++/object.h
   4.684 ++namespace SigC {
   4.685 ++
   4.686 ++// Object
   4.687 ++typedef ::sigc::trackable Object;
   4.688 ++
   4.689 ++}
   4.690 ++
   4.691 ++namespace SigC
   4.692 ++{
   4.693 + template <class T_return, class T_obj1, class T_obj2>
   4.694 + inline Slot0<T_return>
   4.695 + slot( T_obj1& _A_obj, T_return (T_obj2::*_A_func)() )
     5.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     5.2 +++ b/visualboyadvance/stuff/1.7.2-gcc34.patch	Sun Oct 31 23:23:34 2010 +0100
     5.3 @@ -0,0 +1,41 @@
     5.4 +diff -ur src/gtk/joypadconfig.h src/gtk/joypadconfig.h
     5.5 +--- src/gtk/joypadconfig.h	2004-05-10 16:43:21.000000000 +0200
     5.6 ++++ src/gtk/joypadconfig.h	2004-08-12 22:30:20.838039064 +0200
     5.7 +@@ -22,8 +22,8 @@
     5.8 + 
     5.9 + #include <vector>
    5.10 + 
    5.11 +-#include <libglademm.h>
    5.12 + #include <gtkmm.h>
    5.13 ++#include <libglademm.h>
    5.14 + 
    5.15 + #ifndef GTKMM20
    5.16 + # include "sigccompat.h"
    5.17 +diff -ur src/gtk/main.cpp src/gtk/main.cpp
    5.18 +--- src/gtk/main.cpp	2004-05-21 18:02:35.000000000 +0200
    5.19 ++++ src/gtk/main.cpp	2004-08-12 22:39:08.633801912 +0200
    5.20 +@@ -22,10 +22,10 @@
    5.21 + 
    5.22 + #include <list>
    5.23 + 
    5.24 +-#include <libglademm.h>
    5.25 + #include <gtkmm/main.h>
    5.26 + #include <gtkmm/window.h>
    5.27 + #include <gtkmm/messagedialog.h>
    5.28 ++#include <libglademm.h>
    5.29 + 
    5.30 + #include "images/vba-wm-pixbufs.h"
    5.31 + 
    5.32 +diff -ur src/gtk/window.h src/gtk/window.h
    5.33 +--- src/gtk/window.h	2004-05-21 15:25:41.000000000 +0200
    5.34 ++++ src/gtk/window.h	2004-08-12 22:30:58.650290728 +0200
    5.35 +@@ -23,8 +23,8 @@
    5.36 + #include <sys/types.h>
    5.37 + #include <stdarg.h>
    5.38 + 
    5.39 +-#include <libglademm.h>
    5.40 + #include <gtkmm.h>
    5.41 ++#include <libglademm.h>
    5.42 + 
    5.43 + #ifndef GTKMM20
    5.44 + # include "sigccompat.h"
     6.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     6.2 +++ b/visualboyadvance/stuff/1.7.2-gcc41.patch	Sun Oct 31 23:23:34 2010 +0100
     6.3 @@ -0,0 +1,27 @@
     6.4 +diff -ru src/prof/prof.cpp src/prof/prof.cpp
     6.5 +--- src/prof/prof.cpp	2004-05-14 00:31:58.000000000 +1000
     6.6 ++++ src/prof/prof.cpp	2006-06-03 13:49:41.000000000 +1000
     6.7 +@@ -266,7 +266,7 @@
     6.8 +     for (toindex=froms[fromindex]; toindex!=0; toindex=tos[toindex].link) {
     6.9 +       if(profWrite8(fd, GMON_TAG_CG_ARC) ||
    6.10 +          profWrite32(fd, (u32)frompc) ||
    6.11 +-         profWrite32(fd, (u32)tos[toindex].selfpc) ||
    6.12 ++         profWrite32(fd, (u32)(intptr_t)tos[toindex].selfpc) ||
    6.13 +          profWrite32(fd, tos[toindex].count)) {
    6.14 +         systemMessage(0, "mcount: arc");
    6.15 +         fclose(fd);
    6.16 +diff -ru src/sdl/debugger.cpp src/sdl/debugger.cpp
    6.17 +--- src/sdl/debugger.cpp	2004-05-14 00:13:14.000000000 +1000
    6.18 ++++ src/sdl/debugger.cpp	2006-06-03 13:49:57.000000000 +1000
    6.19 +@@ -950,9 +950,9 @@
    6.20 + {
    6.21 +   u32 address = 0;
    6.22 +   if(mem >= (u32*)&workRAM[0] && mem <= (u32*)&workRAM[0x3ffff])
    6.23 +-    address = 0x2000000 + ((u32)mem - (u32)&workRAM[0]);
    6.24 ++    address = 0x2000000 + ((u32)(intptr_t)mem - (u32)(intptr_t)&workRAM[0]);
    6.25 +   else
    6.26 +-    address = 0x3000000 + ((u32)mem - (u32)&internalRAM[0]);
    6.27 ++    address = 0x3000000 + ((u32)(intptr_t)mem - (u32)(intptr_t)&internalRAM[0]);
    6.28 + 
    6.29 +   if(size == 2)
    6.30 +     printf("Breakpoint (on write) address %08x old:%08x new:%08x\n", 
     7.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     7.2 +++ b/visualboyadvance/stuff/1.7.2-glibc.patch	Sun Oct 31 23:23:34 2010 +0100
     7.3 @@ -0,0 +1,76 @@
     7.4 +--- src/GBA.cpp
     7.5 ++++ src/GBA.cpp
     7.6 +@@ -1130,7 +1130,7 @@
     7.7 + bool CPUIsZipFile(const char * file)
     7.8 + {
     7.9 +   if(strlen(file) > 4) {
    7.10 +-    char * p = strrchr(file,'.');
    7.11 ++    const char * p = strrchr(file,'.');
    7.12 + 
    7.13 +     if(p != NULL) {
    7.14 +       if(_stricmp(p, ".zip") == 0)
    7.15 +@@ -1145,7 +1145,7 @@
    7.16 + {
    7.17 +   cpuIsMultiBoot = false;
    7.18 +   if(strlen(file) > 4) {
    7.19 +-    char * p = strrchr(file,'.');
    7.20 ++    const char * p = strrchr(file,'.');
    7.21 + 
    7.22 +     if(p != NULL) {
    7.23 +       if(_stricmp(p, ".gba") == 0)
    7.24 +@@ -1169,7 +1169,7 @@
    7.25 + bool CPUIsGBABios(const char * file)
    7.26 + {
    7.27 +   if(strlen(file) > 4) {
    7.28 +-    char * p = strrchr(file,'.');
    7.29 ++    const char * p = strrchr(file,'.');
    7.30 + 
    7.31 +     if(p != NULL) {
    7.32 +       if(_stricmp(p, ".gba") == 0)
    7.33 +@@ -1189,7 +1189,7 @@
    7.34 + bool CPUIsELF(const char *file)
    7.35 + {
    7.36 +   if(strlen(file) > 4) {
    7.37 +-    char * p = strrchr(file,'.');
    7.38 ++    const char * p = strrchr(file,'.');
    7.39 +     
    7.40 +     if(p != NULL) {
    7.41 +       if(_stricmp(p, ".elf") == 0)
    7.42 +--- src/Util.cpp
    7.43 ++++ src/Util.cpp
    7.44 +@@ -478,7 +478,7 @@
    7.45 + {
    7.46 +   cpuIsMultiBoot = false;
    7.47 +   if(strlen(file) > 4) {
    7.48 +-    char * p = strrchr(file,'.');
    7.49 ++    const char * p = strrchr(file,'.');
    7.50 + 
    7.51 +     if(p != NULL) {
    7.52 +       if(_stricmp(p, ".gba") == 0)
    7.53 +@@ -502,7 +502,7 @@
    7.54 + bool utilIsGBImage(const char * file)
    7.55 + {
    7.56 +   if(strlen(file) > 4) {
    7.57 +-    char * p = strrchr(file,'.');
    7.58 ++    const char * p = strrchr(file,'.');
    7.59 + 
    7.60 +     if(p != NULL) {
    7.61 +       if(_stricmp(p, ".gb") == 0)
    7.62 +@@ -522,7 +522,7 @@
    7.63 + bool utilIsZipFile(const char *file)
    7.64 + {
    7.65 +   if(strlen(file) > 4) {
    7.66 +-    char * p = strrchr(file,'.');
    7.67 ++    const char * p = strrchr(file,'.');
    7.68 + 
    7.69 +     if(p != NULL) {
    7.70 +       if(_stricmp(p, ".zip") == 0)
    7.71 +@@ -552,7 +552,7 @@
    7.72 + bool utilIsGzipFile(const char *file)
    7.73 + {
    7.74 +   if(strlen(file) > 3) {
    7.75 +-    char * p = strrchr(file,'.');
    7.76 ++    const char * p = strrchr(file,'.');
    7.77 + 
    7.78 +     if(p != NULL) {
    7.79 +       if(_stricmp(p, ".gz") == 0)
     8.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.2 +++ b/visualboyadvance/stuff/1.7.2-homedir.patch	Sun Oct 31 23:23:34 2010 +0100
     8.3 @@ -0,0 +1,11 @@
     8.4 +--- src/sdl/SDL.cpp.orig	2004-08-15 02:43:28.232750688 -0400
     8.5 ++++ src/sdl/SDL.cpp	2004-08-15 02:44:01.557684528 -0400
     8.6 +@@ -887,7 +887,7 @@
     8.7 + 
     8.8 +   if(home != NULL) {
     8.9 +     fprintf(stderr, "Searching home directory: %s\n", home);
    8.10 +-    sprintf(path, "%s%c%s", home, FILE_SEP, name);
    8.11 ++    sprintf(path, "%s%c.%s%c%s", home, FILE_SEP, EXE_NAME, FILE_SEP, name);
    8.12 +     f = fopen(path, "r");
    8.13 +     if(f != NULL)
    8.14 +       return f;
     9.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     9.2 +++ b/visualboyadvance/stuff/1.7.2-uninit.patch	Sun Oct 31 23:23:34 2010 +0100
     9.3 @@ -0,0 +1,13 @@
     9.4 +diff -ru src/gtk/window.cpp src/gtk/window.cpp
     9.5 +--- src/gtk/window.cpp	2004-05-14 00:31:58.000000000 +1000
     9.6 ++++ src/gtk/window.cpp	2007-03-17 14:57:22.000000000 -0500
     9.7 +@@ -91,7 +91,8 @@
     9.8 +   m_iFilterIBMin    (FirstFilterIB),
     9.9 +   m_iFilterIBMax    (LastFilterIB),
    9.10 +   m_iJoypadMin      (1),
    9.11 +-  m_iJoypadMax      (4)
    9.12 ++  m_iJoypadMax      (4),
    9.13 ++  m_poKeymap        (NULL)
    9.14 + {
    9.15 +   m_poXml            = _poXml;
    9.16 +   m_poFileOpenDialog = NULL;