Compare commits
1 Commits
wxPy_2_3_2
...
v2.2.0
Author | SHA1 | Date | |
---|---|---|---|
|
4a91d93c0b |
13
.cvsignore
13
.cvsignore
@@ -25,10 +25,6 @@ Release
|
||||
Debug
|
||||
ReleaseDLL
|
||||
DebugDLL
|
||||
UnivRelease
|
||||
UnivDebug
|
||||
BaseRelease
|
||||
BaseDebug
|
||||
robert
|
||||
stamp-h.in
|
||||
Makefile
|
||||
@@ -41,17 +37,8 @@ base
|
||||
gtk
|
||||
motif
|
||||
win32
|
||||
univ
|
||||
univ-debug
|
||||
univ-release
|
||||
base-debug
|
||||
gtk-debug
|
||||
motif-debug
|
||||
win32-debug
|
||||
base-release
|
||||
gtk-release
|
||||
motif-release
|
||||
win32-release
|
||||
*tags
|
||||
log
|
||||
univtags.cmd
|
||||
|
76
BuildCVS.txt
76
BuildCVS.txt
@@ -2,9 +2,6 @@
|
||||
How to build the sources from CVS
|
||||
------------------------------------------------------------------------
|
||||
|
||||
Please use the install.txt files in docs/gtk, docs/msw, docs/motif, docs/mac
|
||||
etc. alongside these instructions.
|
||||
|
||||
I) Windows using plain makefiles
|
||||
----------------------------------------
|
||||
|
||||
@@ -118,42 +115,9 @@ ftp server at ftp://sourceware.cygnus.com/pub/cygwin/.
|
||||
Of course, you can also build the library using plain makefiles (see
|
||||
section I).
|
||||
|
||||
IV) Classic MacOS using CodeWarrior (eg MacOS 8.x/9.x)
|
||||
V) MacOS
|
||||
----------------------------------------
|
||||
|
||||
Refer to the readme.txt and install.txt files in docs/mac to build
|
||||
wxWindows under Classic Mac OS using CodeWarrior.
|
||||
|
||||
If you are checking out the CVS sources using cvs under Mac OS X and
|
||||
compiling under Classic Mac OS:
|
||||
|
||||
- make sure that all text files have a Mac OS type of 'TEXT' otherwise
|
||||
CodeWarrior may ignore them. Checking out the CVS sources using cvs
|
||||
under Mac OS X creates untyped files which can lead to compilation
|
||||
errors under CodeWarrior which are hard to track down.
|
||||
|
||||
- convert the xml files to CodeWarrior binary projects using the supplied
|
||||
AppleScript in docs/mac (M5xml2mcp.applescript for CodeWarrior 5.3)
|
||||
|
||||
V) MacOS X using configure and the Developer Tools
|
||||
----------------------------------------
|
||||
|
||||
You need to have the Developer Tools installed. If this is not the case,
|
||||
you will need to register at the Apple Developer web site (this is a free
|
||||
registration) in order to download the Developer Tools installer.
|
||||
|
||||
In order to create configure, you need to have the
|
||||
GNU autoconf package (version 2.13 or 2.14) installed
|
||||
on your system and type run "autoconf" in the base
|
||||
directory (or run the autogen.sh script in the same
|
||||
directory, which just calls autoconf).
|
||||
|
||||
-> type: mkdir macbuild
|
||||
-> type: cd macbuild
|
||||
-> type: ../configure --with-mac
|
||||
or type: ../configure
|
||||
-> type: make
|
||||
|
||||
VI) OS/2
|
||||
----------------------------------------
|
||||
|
||||
@@ -162,10 +126,8 @@ VII) Unix->Windows cross-compiling using configure
|
||||
|
||||
First you'll need a cross-compiler; linux glibc binaries of mingw32 and
|
||||
cygwin32 (both based on egcs) can be found at
|
||||
ftp://ftp.objsw.com/pub/crossgcc/linux-x-win32. Alternative binaries,
|
||||
based on the latest MinGW release can be found at
|
||||
http://members.telering.at/jessich/mingw/mingwcross/mingw_cross.html
|
||||
Otherwise you can compile one yourself.
|
||||
ftp://ftp.objsw.com/pub/crossgcc/linux-x-win32. Otherwise you can
|
||||
compile one yourself. Check the relevant FAQs.
|
||||
|
||||
[ A Note about cygwin32 and mingw32: the main difference is that cygwin32
|
||||
binaries are always linked against cygwin.dll. This dll encapsulates most
|
||||
@@ -185,7 +147,8 @@ To cross compile the windows library, do
|
||||
-> cd win32
|
||||
(or whatever you called it)
|
||||
Now run configure. There are two ways to do this
|
||||
-> ../configure --host=i586-mingw32 --build=i586-linux --with-mingw
|
||||
-> ../configure --host=i586-mingw32 --build=i586-linux --with-mingw \
|
||||
--enable-dnd=no --without-odbc
|
||||
where --build= should read whatever platform you're building on. Configure
|
||||
will notice that build and host platforms differ, and automatically prepend
|
||||
i586-mingw32- to gcc, ar, ld, etc (make sure they're in the PATH!).
|
||||
@@ -193,22 +156,29 @@ The other way to run configure is by specifying the names of the binaries
|
||||
yourself:
|
||||
-> CC=i586-mingw32-gcc CXX=i586-mingw32-g++ RANLIB=i586-mingw32-ranlib \
|
||||
DLLTOOL=i586-mingw32-dlltool LD=i586-mingw32-ld NM=i586-mingw32-nm \
|
||||
../configure --host=i586-mingw32 --with-mingw
|
||||
../configure --host=i586-mingw32 --with-mingw --enable-dnd=no
|
||||
|
||||
(all assuming you're using mingw32)
|
||||
By default this will compile a DLL, if you want a static library,
|
||||
specify --disable-shared.
|
||||
Drag'n'drop is disabled because mingw32 lacks (AFAIK) OLE headers.
|
||||
|
||||
[ Update: some new mingw32 versions now have a new set of windows header
|
||||
files, which apparently can handle ole. Untested at the moment ]
|
||||
|
||||
ODBC files don't compile as of 13.10.99 - may be this will be fixed by the
|
||||
moment you're reading these lines.
|
||||
|
||||
Configure will conclude that shared libraries are out of the question and
|
||||
opt for a static one. I haven't looked into DLL creation yet.
|
||||
|
||||
Type
|
||||
-> make
|
||||
and wait, wait, wait. Don't leave the room, because the minute you do there
|
||||
will be a compile error :-)
|
||||
|
||||
NB: if you are using a very old compiler you risk to get quite a few warnings
|
||||
about "ANSI C++ forbids implicit conversion from 'void *'" in all places
|
||||
where va_arg macro is used. This is due to a bug in (some versions of)
|
||||
mingw32 headers which may be corrected by upgrading your compier,
|
||||
otherwise you might edit the file
|
||||
NB: you risk to get quite a few warnings about "ANSI C++ forbids implicit
|
||||
conversion from 'void *'" in all places where va_arg macro is used. This
|
||||
is due to a bug in (some versions of) mingw32 headers which may be
|
||||
corrected by editing the file
|
||||
|
||||
${install_prefix}/lib/gcc-lib/i586-mingw32/egcs-2.91.57/include/stdarg.h
|
||||
|
||||
@@ -229,9 +199,8 @@ typedef void *__gnuc_va_list;
|
||||
and adding "|| defined(_WIN32)" to the list of platforms on which
|
||||
__gnuc_va_list is char *.
|
||||
|
||||
If this is successful, you end up with a wx23_2.dll/libwx23_2.a in win32/lib
|
||||
( or just libwx_msw.a if you opted for a static build ).
|
||||
Now try building the minimal sample:
|
||||
If this is successful, you end up with a libwx_msw.a in win32/lib. Now try
|
||||
building the minimal sample:
|
||||
|
||||
-> cd samples/minimal
|
||||
-> make
|
||||
@@ -251,5 +220,6 @@ Cross-compiling TODO:
|
||||
- resource compiling must be done manually for now (should/can we link the
|
||||
default wx resources into libwx_msw.a?) [ No we can't; the linker won't
|
||||
link it in... you have to supply an object file ]
|
||||
- dynamic libraries
|
||||
- static executables are HUGE -- there must be room for improvement.
|
||||
|
||||
|
594
Makefile.in
594
Makefile.in
File diff suppressed because it is too large
Load Diff
289
aclocal.m4
vendored
289
aclocal.m4
vendored
@@ -1,289 +0,0 @@
|
||||
dnl aclocal.m4 generated automatically by aclocal 1.4
|
||||
|
||||
dnl Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc.
|
||||
dnl This file is free software; the Free Software Foundation
|
||||
dnl gives unlimited permission to copy and/or distribute it,
|
||||
dnl with or without modifications, as long as this notice is preserved.
|
||||
|
||||
dnl This program is distributed in the hope that it will be useful,
|
||||
dnl but WITHOUT ANY WARRANTY, to the extent permitted by law; without
|
||||
dnl even the implied warranty of MERCHANTABILITY or FITNESS FOR A
|
||||
dnl PARTICULAR PURPOSE.
|
||||
|
||||
# Configure paths for GTK+
|
||||
# Owen Taylor 97-11-3
|
||||
|
||||
dnl AM_PATH_GTK([MINIMUM-VERSION, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]]])
|
||||
dnl Test for GTK, and define GTK_CFLAGS and GTK_LIBS. Uses variables
|
||||
dnl gtk_config_prefix and/or gtk_config_exec_prefix if defined.
|
||||
AC_DEFUN(AM_PATH_GTK,
|
||||
[
|
||||
if test x$gtk_config_exec_prefix != x ; then
|
||||
gtk_config_args="$gtk_config_args --exec-prefix=$gtk_config_exec_prefix"
|
||||
if test x${GTK_CONFIG+set} != xset ; then
|
||||
GTK_CONFIG=$gtk_config_exec_prefix/bin/gtk-config
|
||||
fi
|
||||
fi
|
||||
if test x$gtk_config_prefix != x ; then
|
||||
gtk_config_args="$gtk_config_args --prefix=$gtk_config_prefix"
|
||||
if test x${GTK_CONFIG+set} != xset ; then
|
||||
GTK_CONFIG=$gtk_config_prefix/bin/gtk-config
|
||||
fi
|
||||
fi
|
||||
|
||||
AC_PATH_PROG(GTK_CONFIG, gtk-config, no)
|
||||
min_gtk_version=ifelse([$1], ,0.99.7,$1)
|
||||
AC_MSG_CHECKING(for GTK - version >= $min_gtk_version)
|
||||
no_gtk=""
|
||||
if test "$GTK_CONFIG" != "no" ; then
|
||||
GTK_CFLAGS=`$GTK_CONFIG --cflags`
|
||||
GTK_LIBS=`$GTK_CONFIG --libs gthread`
|
||||
ac_save_CFLAGS="$CFLAGS"
|
||||
ac_save_LIBS="$LIBS"
|
||||
CFLAGS="$CFLAGS $GTK_CFLAGS"
|
||||
LIBS="$LIBS $GTK_LIBS"
|
||||
dnl
|
||||
dnl Now check if the installed GTK is sufficiently new. (Also sanity
|
||||
dnl checks the results of gtk-config to some extent)
|
||||
dnl
|
||||
AC_TRY_RUN([
|
||||
#include <gtk/gtk.h>
|
||||
#include <gtk/gtkfeatures.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
int
|
||||
main ()
|
||||
{
|
||||
int major, minor, micro;
|
||||
|
||||
if (sscanf("$min_gtk_version", "%d.%d.%d", &major, &minor, µ) != 3) {
|
||||
printf("%s, bad version string\n", "$min_gtk_version");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
if ((GTK_MAJOR_VERSION != gtk_major_version) ||
|
||||
(GTK_MINOR_VERSION != gtk_minor_version) ||
|
||||
(GTK_MICRO_VERSION != gtk_micro_version)) {
|
||||
printf("Headers vs. library version mismatch!\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
if (gtk_minor_version == 1) return FALSE;
|
||||
|
||||
return !((gtk_major_version > major) ||
|
||||
((gtk_major_version == major) && (gtk_minor_version > minor)) ||
|
||||
((gtk_major_version == major) && (gtk_minor_version == minor) && (gtk_micro_version >= micro)));
|
||||
}
|
||||
],, no_gtk=yes,[echo $ac_n "cross compiling; assumed OK... $ac_c"])
|
||||
CFLAGS="$ac_save_CFLAGS"
|
||||
LIBS="$ac_save_LIBS"
|
||||
else
|
||||
no_gtk=yes
|
||||
fi
|
||||
if test "x$no_gtk" = x ; then
|
||||
AC_MSG_RESULT(yes)
|
||||
ifelse([$2], , :, [$2])
|
||||
else
|
||||
AC_MSG_RESULT(no)
|
||||
GTK_CFLAGS=""
|
||||
GTK_LIBS=""
|
||||
ifelse([$3], , :, [$3])
|
||||
fi
|
||||
AC_SUBST(GTK_CFLAGS)
|
||||
AC_SUBST(GTK_LIBS)
|
||||
])
|
||||
|
||||
dnl AM_PATH_GTK_2_0([MINIMUM-VERSION, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND [, MODULES]]]])
|
||||
dnl Test for GTK, and define GTK_CFLAGS and GTK_LIBS
|
||||
dnl
|
||||
AC_DEFUN(AM_PATH_GTK_2_0,
|
||||
[dnl
|
||||
dnl Get the cflags and libraries from the gtk-config-2.0 script
|
||||
dnl
|
||||
AC_ARG_WITH(gtk-prefix,[ --with-gtk-prefix=PFX Prefix where GTK is installed (optional)],
|
||||
gtk_config_prefix="$withval", gtk_config_prefix="")
|
||||
AC_ARG_WITH(gtk-exec-prefix,[ --with-gtk-exec-prefix=PFX Exec prefix where GTK is installed (optional)],
|
||||
gtk_config_exec_prefix="$withval", gtk_config_exec_prefix="")
|
||||
AC_ARG_ENABLE(gtktest, [ --disable-gtktest Do not try to compile and run a test GTK program],
|
||||
, enable_gtktest=yes)
|
||||
|
||||
for module in . $4
|
||||
do
|
||||
case "$module" in
|
||||
gthread)
|
||||
gtk_config_args="$gtk_config_args gthread"
|
||||
;;
|
||||
esac
|
||||
done
|
||||
|
||||
if test x$gtk_config_exec_prefix != x ; then
|
||||
gtk_config_args="$gtk_config_args --exec-prefix=$gtk_config_exec_prefix"
|
||||
if test x${GTK_CONFIG_2_0+set} != xset ; then
|
||||
GTK_CONFIG_2_0=$gtk_config_exec_prefix/bin/gtk-config-2.0
|
||||
fi
|
||||
fi
|
||||
if test x$gtk_config_prefix != x ; then
|
||||
gtk_config_args="$gtk_config_args --prefix=$gtk_config_prefix"
|
||||
if test x${GTK_CONFIG_2_0+set} != xset ; then
|
||||
GTK_CONFIG_2_0=$gtk_config_prefix/bin/gtk-config-2.0
|
||||
fi
|
||||
fi
|
||||
|
||||
AC_PATH_PROG(GTK_CONFIG_2_0, gtk-config-2.0, no)
|
||||
min_gtk_version=ifelse([$1], ,1.3.1,$1)
|
||||
AC_MSG_CHECKING(for GTK - version >= $min_gtk_version)
|
||||
no_gtk=""
|
||||
if test "$GTK_CONFIG_2_0" = "no" ; then
|
||||
no_gtk=yes
|
||||
else
|
||||
GTK_CFLAGS=`$GTK_CONFIG_2_0 $gtk_config_args --cflags`
|
||||
GTK_LIBS=`$GTK_CONFIG_2_0 $gtk_config_args --libs`
|
||||
gtk_config_major_version=`$GTK_CONFIG_2_0 $gtk_config_args --version | \
|
||||
sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\1/'`
|
||||
gtk_config_minor_version=`$GTK_CONFIG_2_0 $gtk_config_args --version | \
|
||||
sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\2/'`
|
||||
gtk_config_micro_version=`$GTK_CONFIG_2_0 $gtk_config_args --version | \
|
||||
sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\3/'`
|
||||
if test "x$enable_gtktest" = "xyes" ; then
|
||||
ac_save_CFLAGS="$CFLAGS"
|
||||
ac_save_LIBS="$LIBS"
|
||||
CFLAGS="$CFLAGS $GTK_CFLAGS"
|
||||
LIBS="$GTK_LIBS $LIBS"
|
||||
dnl
|
||||
dnl Now check if the installed GTK is sufficiently new. (Also sanity
|
||||
dnl checks the results of gtk-config-2.0 to some extent
|
||||
dnl
|
||||
rm -f conf.gtktest
|
||||
AC_TRY_RUN([
|
||||
#include <gtk/gtk.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
int
|
||||
main ()
|
||||
{
|
||||
int major, minor, micro;
|
||||
char *tmp_version;
|
||||
|
||||
system ("touch conf.gtktest");
|
||||
|
||||
/* HP/UX 9 (%@#!) writes to sscanf strings */
|
||||
tmp_version = g_strdup("$min_gtk_version");
|
||||
if (sscanf(tmp_version, "%d.%d.%d", &major, &minor, µ) != 3) {
|
||||
printf("%s, bad version string\n", "$min_gtk_version");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
if ((gtk_major_version != $gtk_config_major_version) ||
|
||||
(gtk_minor_version != $gtk_config_minor_version) ||
|
||||
(gtk_micro_version != $gtk_config_micro_version))
|
||||
{
|
||||
printf("\n*** 'gtk-config-2.0 --version' returned %d.%d.%d, but GTK+ (%d.%d.%d)\n",
|
||||
$gtk_config_major_version, $gtk_config_minor_version, $gtk_config_micro_version,
|
||||
gtk_major_version, gtk_minor_version, gtk_micro_version);
|
||||
printf ("*** was found! If gtk-config-2.0 was correct, then it is best\n");
|
||||
printf ("*** to remove the old version of GTK+. You may also be able to fix the error\n");
|
||||
printf("*** by modifying your LD_LIBRARY_PATH enviroment variable, or by editing\n");
|
||||
printf("*** /etc/ld.so.conf. Make sure you have run ldconfig if that is\n");
|
||||
printf("*** required on your system.\n");
|
||||
printf("*** If gtk-config-2.0 was wrong, set the environment variable GTK_CONFIG_2_0\n");
|
||||
printf("*** to point to the correct copy of gtk-config-2.0, and remove the file config.cache\n");
|
||||
printf("*** before re-running configure\n");
|
||||
}
|
||||
#if defined (GTK_MAJOR_VERSION) && defined (GTK_MINOR_VERSION) && defined (GTK_MICRO_VERSION)
|
||||
else if ((gtk_major_version != GTK_MAJOR_VERSION) ||
|
||||
(gtk_minor_version != GTK_MINOR_VERSION) ||
|
||||
(gtk_micro_version != GTK_MICRO_VERSION))
|
||||
{
|
||||
printf("*** GTK+ header files (version %d.%d.%d) do not match\n",
|
||||
GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION);
|
||||
printf("*** library (version %d.%d.%d)\n",
|
||||
gtk_major_version, gtk_minor_version, gtk_micro_version);
|
||||
}
|
||||
#endif /* defined (GTK_MAJOR_VERSION) ... */
|
||||
else
|
||||
{
|
||||
if ((gtk_major_version > major) ||
|
||||
((gtk_major_version == major) && (gtk_minor_version > minor)) ||
|
||||
((gtk_major_version == major) && (gtk_minor_version == minor) && (gtk_micro_version >= micro)))
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("\n*** An old version of GTK+ (%d.%d.%d) was found.\n",
|
||||
gtk_major_version, gtk_minor_version, gtk_micro_version);
|
||||
printf("*** You need a version of GTK+ newer than %d.%d.%d. The latest version of\n",
|
||||
major, minor, micro);
|
||||
printf("*** GTK+ is always available from ftp://ftp.gtk.org.\n");
|
||||
printf("***\n");
|
||||
printf("*** If you have already installed a sufficiently new version, this error\n");
|
||||
printf("*** probably means that the wrong copy of the gtk-config-2.0 shell script is\n");
|
||||
printf("*** being found. The easiest way to fix this is to remove the old version\n");
|
||||
printf("*** of GTK+, but you can also set the GTK_CONFIG_2_0 environment to point to the\n");
|
||||
printf("*** correct copy of gtk-config-2.0. (In this case, you will have to\n");
|
||||
printf("*** modify your LD_LIBRARY_PATH enviroment variable, or edit /etc/ld.so.conf\n");
|
||||
printf("*** so that the correct libraries are found at run-time))\n");
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
],, no_gtk=yes,[echo $ac_n "cross compiling; assumed OK... $ac_c"])
|
||||
CFLAGS="$ac_save_CFLAGS"
|
||||
LIBS="$ac_save_LIBS"
|
||||
fi
|
||||
fi
|
||||
if test "x$no_gtk" = x ; then
|
||||
AC_MSG_RESULT(yes (version $gtk_config_major_version.$gtk_config_minor_version.$gtk_config_micro_version))
|
||||
ifelse([$2], , :, [$2])
|
||||
else
|
||||
AC_MSG_RESULT(no)
|
||||
if test "$GTK_CONFIG_2_0" = "no" ; then
|
||||
echo "*** The gtk-config-2.0 script installed by GTK could not be found"
|
||||
echo "*** If GTK was installed in PREFIX, make sure PREFIX/bin is in"
|
||||
echo "*** your path, or set the GTK_CONFIG_2_0 environment variable to the"
|
||||
echo "*** full path to gtk-config-2.0."
|
||||
else
|
||||
if test -f conf.gtktest ; then
|
||||
:
|
||||
else
|
||||
echo "*** Could not run GTK test program, checking why..."
|
||||
CFLAGS="$CFLAGS $GTK_CFLAGS"
|
||||
LIBS="$LIBS $GTK_LIBS"
|
||||
AC_TRY_LINK([
|
||||
#include <gtk/gtk.h>
|
||||
#include <stdio.h>
|
||||
], [ return ((gtk_major_version) || (gtk_minor_version) || (gtk_micro_version)); ],
|
||||
[ echo "*** The test program compiled, but did not run. This usually means"
|
||||
echo "*** that the run-time linker is not finding GTK or finding the wrong"
|
||||
echo "*** version of GTK. If it is not finding GTK, you'll need to set your"
|
||||
echo "*** LD_LIBRARY_PATH environment variable, or edit /etc/ld.so.conf to point"
|
||||
echo "*** to the installed location Also, make sure you have run ldconfig if that"
|
||||
echo "*** is required on your system"
|
||||
echo "***"
|
||||
echo "*** If you have an old version installed, it is best to remove it, although"
|
||||
echo "*** you may also be able to get things to work by modifying LD_LIBRARY_PATH"
|
||||
echo "***"
|
||||
echo "*** If you have a RedHat 5.0 system, you should remove the GTK package that"
|
||||
echo "*** came with the system with the command"
|
||||
echo "***"
|
||||
echo "*** rpm --erase --nodeps gtk gtk-devel" ],
|
||||
[ echo "*** The test program failed to compile or link. See the file config.log for the"
|
||||
echo "*** exact error that occured. This usually means GTK was incorrectly installed"
|
||||
echo "*** or that you have moved GTK since it was installed. In the latter case, you"
|
||||
echo "*** may want to edit the gtk-config-2.0 script: $GTK_CONFIG_2_0" ])
|
||||
CFLAGS="$ac_save_CFLAGS"
|
||||
LIBS="$ac_save_LIBS"
|
||||
fi
|
||||
fi
|
||||
GTK_CFLAGS=""
|
||||
GTK_LIBS=""
|
||||
ifelse([$3], , :, [$3])
|
||||
fi
|
||||
AC_SUBST(GTK_CFLAGS)
|
||||
AC_SUBST(GTK_LIBS)
|
||||
rm -f conf.gtktest
|
||||
])
|
||||
|
||||
|
776
config.guess
vendored
776
config.guess
vendored
File diff suppressed because it is too large
Load Diff
372
config.sub
vendored
372
config.sub
vendored
@@ -1,10 +1,6 @@
|
||||
#! /bin/sh
|
||||
# Configuration validation subroutine script.
|
||||
# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
|
||||
# Free Software Foundation, Inc.
|
||||
|
||||
timestamp='2001-09-07'
|
||||
|
||||
# Configuration validation subroutine script, version 1.1.
|
||||
# Copyright (C) 1991, 92-97, 1998, 1999 Free Software Foundation, Inc.
|
||||
# This file is (in principle) common to ALL GNU software.
|
||||
# The presence of a machine in this file suggests that SOME GNU software
|
||||
# can handle that machine. It does not imply ALL GNU software can.
|
||||
@@ -29,8 +25,6 @@ timestamp='2001-09-07'
|
||||
# configuration script generated by Autoconf, you may include it under
|
||||
# the same distribution terms that you use for the rest of that program.
|
||||
|
||||
# Please send patches to <config-patches@gnu.org>.
|
||||
#
|
||||
# Configuration subroutine to validate and canonicalize a configuration type.
|
||||
# Supply the specified configuration type as an argument.
|
||||
# If it is invalid, we print an error message on stderr and exit with code 1.
|
||||
@@ -51,73 +45,30 @@ timestamp='2001-09-07'
|
||||
# CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
|
||||
# It is wrong to echo any other type of specification.
|
||||
|
||||
me=`echo "$0" | sed -e 's,.*/,,'`
|
||||
if [ x$1 = x ]
|
||||
then
|
||||
echo Configuration name missing. 1>&2
|
||||
echo "Usage: $0 CPU-MFR-OPSYS" 1>&2
|
||||
echo "or $0 ALIAS" 1>&2
|
||||
echo where ALIAS is a recognized configuration type. 1>&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
usage="\
|
||||
Usage: $0 [OPTION] CPU-MFR-OPSYS
|
||||
$0 [OPTION] ALIAS
|
||||
|
||||
Canonicalize a configuration name.
|
||||
|
||||
Operation modes:
|
||||
-h, --help print this help, then exit
|
||||
-t, --time-stamp print date of last modification, then exit
|
||||
-v, --version print version number, then exit
|
||||
|
||||
Report bugs and patches to <config-patches@gnu.org>."
|
||||
|
||||
version="\
|
||||
GNU config.sub ($timestamp)
|
||||
|
||||
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
|
||||
Free Software Foundation, Inc.
|
||||
|
||||
This is free software; see the source for copying conditions. There is NO
|
||||
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
|
||||
|
||||
help="
|
||||
Try \`$me --help' for more information."
|
||||
|
||||
# Parse command line
|
||||
while test $# -gt 0 ; do
|
||||
case $1 in
|
||||
--time-stamp | --time* | -t )
|
||||
echo "$timestamp" ; exit 0 ;;
|
||||
--version | -v )
|
||||
echo "$version" ; exit 0 ;;
|
||||
--help | --h* | -h )
|
||||
echo "$usage"; exit 0 ;;
|
||||
-- ) # Stop option processing
|
||||
shift; break ;;
|
||||
- ) # Use stdin as input.
|
||||
break ;;
|
||||
-* )
|
||||
echo "$me: invalid option $1$help"
|
||||
exit 1 ;;
|
||||
|
||||
*local*)
|
||||
# First pass through any local machine types.
|
||||
echo $1
|
||||
exit 0;;
|
||||
|
||||
* )
|
||||
break ;;
|
||||
esac
|
||||
done
|
||||
|
||||
case $# in
|
||||
0) echo "$me: missing argument$help" >&2
|
||||
exit 1;;
|
||||
1) ;;
|
||||
*) echo "$me: too many arguments$help" >&2
|
||||
exit 1;;
|
||||
# First pass through any local machine types.
|
||||
case $1 in
|
||||
*local*)
|
||||
echo $1
|
||||
exit 0
|
||||
;;
|
||||
*)
|
||||
;;
|
||||
esac
|
||||
|
||||
# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any).
|
||||
# Here we must recognize all the valid KERNEL-OS combinations.
|
||||
maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'`
|
||||
case $maybe_os in
|
||||
nto-qnx* | linux-gnu* | storm-chaos* | os2-emx* | windows32-*)
|
||||
linux-gnu*)
|
||||
os=-$maybe_os
|
||||
basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`
|
||||
;;
|
||||
@@ -143,7 +94,7 @@ case $os in
|
||||
-convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\
|
||||
-c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \
|
||||
-harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \
|
||||
-apple | -axis)
|
||||
-apple)
|
||||
os=
|
||||
basic_machine=$1
|
||||
;;
|
||||
@@ -154,17 +105,9 @@ case $os in
|
||||
-scout)
|
||||
;;
|
||||
-wrs)
|
||||
os=-vxworks
|
||||
os=vxworks
|
||||
basic_machine=$1
|
||||
;;
|
||||
-chorusos*)
|
||||
os=-chorusos
|
||||
basic_machine=$1
|
||||
;;
|
||||
-chorusrdb)
|
||||
os=-chorusrdb
|
||||
basic_machine=$1
|
||||
;;
|
||||
-hiux*)
|
||||
os=-hiuxwe2
|
||||
;;
|
||||
@@ -213,60 +156,33 @@ case $os in
|
||||
-psos*)
|
||||
os=-psos
|
||||
;;
|
||||
-mint | -mint[0-9]*)
|
||||
basic_machine=m68k-atari
|
||||
os=-mint
|
||||
;;
|
||||
esac
|
||||
|
||||
# Decode aliases for certain CPU-COMPANY combinations.
|
||||
case $basic_machine in
|
||||
# Recognize the basic CPU types without company name.
|
||||
# Some are omitted here because they have special meanings below.
|
||||
1750a | 580 \
|
||||
| a29k \
|
||||
| alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \
|
||||
| arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr \
|
||||
| c4x | clipper \
|
||||
| d10v | d30v | dsp16xx \
|
||||
| fr30 \
|
||||
| h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
|
||||
| i370 | i860 | i960 | ia64 \
|
||||
| m32r | m68000 | m68k | m88k | mcore \
|
||||
| mips16 | mips64 | mips64el | mips64orion | mips64orionel \
|
||||
| mips64vr4100 | mips64vr4100el | mips64vr4300 \
|
||||
| mips64vr4300el | mips64vr5000 | mips64vr5000el \
|
||||
| mipsbe | mipseb | mipsel | mipsle | mipstx39 | mipstx39el \
|
||||
| mipsisa32 \
|
||||
| mn10200 | mn10300 \
|
||||
| ns16k | ns32k \
|
||||
| openrisc \
|
||||
| pdp10 | pdp11 | pj | pjl \
|
||||
| powerpc | powerpc64 | powerpc64le | powerpcle | ppcbe \
|
||||
| pyramid \
|
||||
| s390 | s390x \
|
||||
| sh | sh[34] | sh[34]eb | shbe | shle \
|
||||
| sparc | sparc64 | sparclet | sparclite | sparcv9 | sparcv9b \
|
||||
| stormy16 | strongarm \
|
||||
| tahoe | thumb | tic80 | tron \
|
||||
| v850 \
|
||||
| we32k \
|
||||
| x86 | xscale \
|
||||
| z8k)
|
||||
tahoe | i860 | m32r | m68k | m68000 | m88k | ns32k | arc | arm \
|
||||
| arme[lb] | pyramid | mn10200 | mn10300 | tron | a29k \
|
||||
| 580 | i960 | h8300 \
|
||||
| hppa | hppa1.0 | hppa1.1 | hppa2.0 | hppa2.0w | hppa2.0n \
|
||||
| alpha | alphaev[4-7] | alphaev56 | alphapca5[67] \
|
||||
| we32k | ns16k | clipper | i370 | sh | powerpc | powerpcle \
|
||||
| 1750a | dsp16xx | pdp11 | mips16 | mips64 | mipsel | mips64el \
|
||||
| mips64orion | mips64orionel | mipstx39 | mipstx39el \
|
||||
| mips64vr4300 | mips64vr4300el | mips64vr4100 | mips64vr4100el \
|
||||
| mips64vr5000 | miprs64vr5000el \
|
||||
| sparc | sparclet | sparclite | sparc64 | sparcv9 | v850 | c4x \
|
||||
| thumb | d10v)
|
||||
basic_machine=$basic_machine-unknown
|
||||
;;
|
||||
m6811 | m68hc11 | m6812 | m68hc12)
|
||||
# Motorola 68HC11/12.
|
||||
basic_machine=$basic_machine-unknown
|
||||
os=-none
|
||||
;;
|
||||
m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k)
|
||||
m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | z8k | v70 | h8500 | w65)
|
||||
;;
|
||||
|
||||
# We use `pc' rather than `unknown'
|
||||
# because (1) that's what they normally are, and
|
||||
# (2) the word "unknown" tends to confuse beginning users.
|
||||
i*86 | x86_64)
|
||||
i[34567]86)
|
||||
basic_machine=$basic_machine-pc
|
||||
;;
|
||||
# Object if more than one company name word.
|
||||
@@ -275,43 +191,23 @@ case $basic_machine in
|
||||
exit 1
|
||||
;;
|
||||
# Recognize the basic CPU types with company name.
|
||||
580-* \
|
||||
| a29k-* \
|
||||
| alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \
|
||||
| alphapca5[67]-* | arc-* \
|
||||
| arm-* | armbe-* | armle-* | armv*-* \
|
||||
| bs2000-* \
|
||||
| c[123]* | c30-* | [cjt]90-* | c54x-* \
|
||||
| clipper-* | cray2-* | cydra-* \
|
||||
| d10v-* | d30v-* \
|
||||
| elxsi-* \
|
||||
| f30[01]-* | f700-* | fr30-* | fx80-* \
|
||||
| h8300-* | h8500-* \
|
||||
| hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \
|
||||
| i*86-* | i860-* | i960-* | ia64-* \
|
||||
| m32r-* \
|
||||
| m68000-* | m680[01234]0-* | m68360-* | m683?2-* | m68k-* \
|
||||
| m88110-* | m88k-* | mcore-* \
|
||||
| mips-* | mips16-* | mips64-* | mips64el-* | mips64orion-* \
|
||||
| mips64orionel-* | mips64vr4100-* | mips64vr4100el-* \
|
||||
| mips64vr4300-* | mips64vr4300el-* | mipsbe-* | mipseb-* \
|
||||
| mipsle-* | mipsel-* | mipstx39-* | mipstx39el-* \
|
||||
| none-* | np1-* | ns16k-* | ns32k-* \
|
||||
| orion-* \
|
||||
| pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \
|
||||
| powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* | ppcbe-* \
|
||||
| pyramid-* \
|
||||
| romp-* | rs6000-* \
|
||||
| s390-* | s390x-* \
|
||||
| sh-* | sh[34]-* | sh[34]eb-* | shbe-* | shle-* \
|
||||
| sparc-* | sparc64-* | sparc86x-* | sparclite-* \
|
||||
| sparcv9-* | sparcv9b-* | stormy16-* | strongarm-* | sv1-* \
|
||||
| t3e-* | tahoe-* | thumb-* | tic30-* | tic54x-* | tic80-* | tron-* \
|
||||
| v850-* | vax-* \
|
||||
| we32k-* \
|
||||
| x86-* | x86_64-* | xmp-* | xps100-* | xscale-* \
|
||||
| ymp-* \
|
||||
| z8k-*)
|
||||
vax-* | tahoe-* | i[34567]86-* | i860-* | m32r-* | m68k-* | m68000-* \
|
||||
| m88k-* | sparc-* | ns32k-* | fx80-* | arc-* | arm-* | c[123]* \
|
||||
| mips-* | pyramid-* | tron-* | a29k-* | romp-* | rs6000-* \
|
||||
| power-* | none-* | 580-* | cray2-* | h8300-* | h8500-* | i960-* \
|
||||
| xmp-* | ymp-* \
|
||||
| hppa-* | hppa1.0-* | hppa1.1-* | hppa2.0-* | hppa2.0w-* | hppa2.0n-* \
|
||||
| alpha-* | alphaev[4-7]-* | alphaev56-* | alphapca5[67]-* \
|
||||
| we32k-* | cydra-* | ns16k-* | pn-* | np1-* | xps100-* \
|
||||
| clipper-* | orion-* \
|
||||
| sparclite-* | pdp11-* | sh-* | powerpc-* | powerpcle-* \
|
||||
| sparc64-* | sparcv9-* | sparc86x-* | mips16-* | mips64-* | mipsel-* \
|
||||
| mips64el-* | mips64orion-* | mips64orionel-* \
|
||||
| mips64vr4100-* | mips64vr4100el-* | mips64vr4300-* | mips64vr4300el-* \
|
||||
| mipstx39-* | mipstx39el-* \
|
||||
| f301-* | armv*-* | t3e-* \
|
||||
| m88110-* | m680[01234]0-* | m683?2-* | m68360-* | z8k-* | d10v-* \
|
||||
| thumb-* | v850-* | d30v-* | tic30-* | c30-* )
|
||||
;;
|
||||
# Recognize the various machine names and aliases which stand
|
||||
# for a CPU type and a company and sometimes even an OS.
|
||||
@@ -348,14 +244,14 @@ case $basic_machine in
|
||||
os=-sysv
|
||||
;;
|
||||
amiga | amiga-*)
|
||||
basic_machine=m68k-unknown
|
||||
basic_machine=m68k-cbm
|
||||
;;
|
||||
amigaos | amigados)
|
||||
basic_machine=m68k-unknown
|
||||
basic_machine=m68k-cbm
|
||||
os=-amigaos
|
||||
;;
|
||||
amigaunix | amix)
|
||||
basic_machine=m68k-unknown
|
||||
basic_machine=m68k-cbm
|
||||
os=-sysv4
|
||||
;;
|
||||
apollo68)
|
||||
@@ -402,16 +298,13 @@ case $basic_machine in
|
||||
basic_machine=cray2-cray
|
||||
os=-unicos
|
||||
;;
|
||||
[cjt]90)
|
||||
basic_machine=${basic_machine}-cray
|
||||
[ctj]90-cray)
|
||||
basic_machine=c90-cray
|
||||
os=-unicos
|
||||
;;
|
||||
crds | unos)
|
||||
basic_machine=m68k-crds
|
||||
;;
|
||||
cris | cris-* | etrax*)
|
||||
basic_machine=cris-axis
|
||||
;;
|
||||
da30 | da30-*)
|
||||
basic_machine=m68k-da30
|
||||
;;
|
||||
@@ -459,10 +352,6 @@ case $basic_machine in
|
||||
basic_machine=tron-gmicro
|
||||
os=-sysv
|
||||
;;
|
||||
go32)
|
||||
basic_machine=i386-pc
|
||||
os=-go32
|
||||
;;
|
||||
h3050r* | hiux*)
|
||||
basic_machine=hppa1.1-hitachi
|
||||
os=-hiuxwe2
|
||||
@@ -536,21 +425,22 @@ case $basic_machine in
|
||||
;;
|
||||
i370-ibm* | ibm*)
|
||||
basic_machine=i370-ibm
|
||||
os=-mvs
|
||||
;;
|
||||
# I'm not sure what "Sysv32" means. Should this be sysv3.2?
|
||||
i*86v32)
|
||||
i[34567]86v32)
|
||||
basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
|
||||
os=-sysv32
|
||||
;;
|
||||
i*86v4*)
|
||||
i[34567]86v4*)
|
||||
basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
|
||||
os=-sysv4
|
||||
;;
|
||||
i*86v)
|
||||
i[34567]86v)
|
||||
basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
|
||||
os=-sysv
|
||||
;;
|
||||
i*86sol2)
|
||||
i[34567]86sol2)
|
||||
basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
|
||||
os=-solaris2
|
||||
;;
|
||||
@@ -562,6 +452,14 @@ case $basic_machine in
|
||||
basic_machine=i386-unknown
|
||||
os=-vsta
|
||||
;;
|
||||
i386-go32 | go32)
|
||||
basic_machine=i386-unknown
|
||||
os=-go32
|
||||
;;
|
||||
i386-mingw32 | mingw32)
|
||||
basic_machine=i386-unknown
|
||||
os=-mingw32
|
||||
;;
|
||||
iris | iris4d)
|
||||
basic_machine=mips-sgi
|
||||
case $os in
|
||||
@@ -587,14 +485,10 @@ case $basic_machine in
|
||||
basic_machine=ns32k-utek
|
||||
os=-sysv
|
||||
;;
|
||||
mingw32)
|
||||
basic_machine=i386-pc
|
||||
os=-mingw32
|
||||
;;
|
||||
miniframe)
|
||||
basic_machine=m68000-convergent
|
||||
;;
|
||||
*mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*)
|
||||
*mint | *MiNT)
|
||||
basic_machine=m68k-atari
|
||||
os=-mint
|
||||
;;
|
||||
@@ -612,22 +506,14 @@ case $basic_machine in
|
||||
mips3*)
|
||||
basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown
|
||||
;;
|
||||
mmix*)
|
||||
basic_machine=mmix-knuth
|
||||
os=-mmixware
|
||||
;;
|
||||
monitor)
|
||||
basic_machine=m68k-rom68k
|
||||
os=-coff
|
||||
;;
|
||||
msdos)
|
||||
basic_machine=i386-pc
|
||||
basic_machine=i386-unknown
|
||||
os=-msdos
|
||||
;;
|
||||
mvs)
|
||||
basic_machine=i370-ibm
|
||||
os=-mvs
|
||||
;;
|
||||
ncr3000)
|
||||
basic_machine=i486-ncr
|
||||
os=-sysv4
|
||||
@@ -637,7 +523,7 @@ case $basic_machine in
|
||||
os=-netbsd
|
||||
;;
|
||||
netwinder)
|
||||
basic_machine=armv4l-rebel
|
||||
basic_machine=armv4l-corel
|
||||
os=-linux
|
||||
;;
|
||||
news | news700 | news800 | news900)
|
||||
@@ -685,16 +571,9 @@ case $basic_machine in
|
||||
basic_machine=i960-intel
|
||||
os=-mon960
|
||||
;;
|
||||
nonstopux)
|
||||
basic_machine=mips-compaq
|
||||
os=-nonstopux
|
||||
;;
|
||||
np1)
|
||||
basic_machine=np1-gould
|
||||
;;
|
||||
nsr-tandem)
|
||||
basic_machine=nsr-tandem
|
||||
;;
|
||||
op50n-* | op60c-*)
|
||||
basic_machine=hppa1.1-oki
|
||||
os=-proelf
|
||||
@@ -724,28 +603,28 @@ case $basic_machine in
|
||||
pc532 | pc532-*)
|
||||
basic_machine=ns32k-pc532
|
||||
;;
|
||||
pentium | p5 | k5 | k6 | nexgen)
|
||||
pentium | p5 | k5 | k6 | nexen)
|
||||
basic_machine=i586-pc
|
||||
;;
|
||||
pentiumpro | p6 | 6x86 | athlon)
|
||||
pentiumpro | p6 | 6x86)
|
||||
basic_machine=i686-pc
|
||||
;;
|
||||
pentiumii | pentium2)
|
||||
basic_machine=i686-pc
|
||||
basic_machine=i786-pc
|
||||
;;
|
||||
pentium-* | p5-* | k5-* | k6-* | nexgen-*)
|
||||
pentium-* | p5-* | k5-* | k6-* | nexen-*)
|
||||
basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'`
|
||||
;;
|
||||
pentiumpro-* | p6-* | 6x86-* | athlon-*)
|
||||
pentiumpro-* | p6-* | 6x86-*)
|
||||
basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
|
||||
;;
|
||||
pentiumii-* | pentium2-*)
|
||||
basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
|
||||
basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'`
|
||||
;;
|
||||
pn)
|
||||
basic_machine=pn-gould
|
||||
;;
|
||||
power) basic_machine=power-ibm
|
||||
power) basic_machine=rs6000-ibm
|
||||
;;
|
||||
ppc) basic_machine=powerpc-unknown
|
||||
;;
|
||||
@@ -757,23 +636,9 @@ case $basic_machine in
|
||||
ppcle-* | powerpclittle-*)
|
||||
basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'`
|
||||
;;
|
||||
ppc64) basic_machine=powerpc64-unknown
|
||||
;;
|
||||
ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'`
|
||||
;;
|
||||
ppc64le | powerpc64little | ppc64-le | powerpc64-little)
|
||||
basic_machine=powerpc64le-unknown
|
||||
;;
|
||||
ppc64le-* | powerpc64little-*)
|
||||
basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'`
|
||||
;;
|
||||
ps2)
|
||||
basic_machine=i386-ibm
|
||||
;;
|
||||
pw32)
|
||||
basic_machine=i586-unknown
|
||||
os=-pw32
|
||||
;;
|
||||
rom68k)
|
||||
basic_machine=m68k-rom68k
|
||||
os=-coff
|
||||
@@ -853,10 +718,6 @@ case $basic_machine in
|
||||
sun386 | sun386i | roadrunner)
|
||||
basic_machine=i386-sun
|
||||
;;
|
||||
sv1)
|
||||
basic_machine=sv1-cray
|
||||
os=-unicos
|
||||
;;
|
||||
symmetry)
|
||||
basic_machine=i386-sequent
|
||||
os=-dynix
|
||||
@@ -865,10 +726,6 @@ case $basic_machine in
|
||||
basic_machine=t3e-cray
|
||||
os=-unicos
|
||||
;;
|
||||
tic54x | c54x*)
|
||||
basic_machine=tic54x-unknown
|
||||
os=-coff
|
||||
;;
|
||||
tx39)
|
||||
basic_machine=mipstx39-unknown
|
||||
;;
|
||||
@@ -921,10 +778,6 @@ case $basic_machine in
|
||||
basic_machine=hppa1.1-winbond
|
||||
os=-proelf
|
||||
;;
|
||||
windows32)
|
||||
basic_machine=i386-pc
|
||||
os=-windows32-msvcrt
|
||||
;;
|
||||
xmp)
|
||||
basic_machine=xmp-cray
|
||||
os=-unicos
|
||||
@@ -968,20 +821,13 @@ case $basic_machine in
|
||||
vax)
|
||||
basic_machine=vax-dec
|
||||
;;
|
||||
pdp10)
|
||||
# there are many clones, so DEC is not a safe bet
|
||||
basic_machine=pdp10-unknown
|
||||
;;
|
||||
pdp11)
|
||||
basic_machine=pdp11-dec
|
||||
;;
|
||||
we32k)
|
||||
basic_machine=we32k-att
|
||||
;;
|
||||
sh3 | sh4 | sh3eb | sh4eb)
|
||||
basic_machine=sh-unknown
|
||||
;;
|
||||
sparc | sparcv9 | sparcv9b)
|
||||
sparc | sparcv9)
|
||||
basic_machine=sparc-sun
|
||||
;;
|
||||
cydra)
|
||||
@@ -1003,9 +849,6 @@ case $basic_machine in
|
||||
basic_machine=c4x-none
|
||||
os=-coff
|
||||
;;
|
||||
*-unknown)
|
||||
# Make sure to match an already-canonicalized machine name.
|
||||
;;
|
||||
*)
|
||||
echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
|
||||
exit 1
|
||||
@@ -1062,30 +905,14 @@ case $os in
|
||||
| -lynxos* | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \
|
||||
| -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \
|
||||
| -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \
|
||||
| -chorusos* | -chorusrdb* \
|
||||
| -cygwin* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
|
||||
| -mingw32* | -linux-gnu* | -uxpv* | -beos* | -mpeix* | -udk* \
|
||||
| -interix* | -uwin* | -rhapsody* | -darwin* | -opened* \
|
||||
| -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \
|
||||
| -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \
|
||||
| -os2* | -vos*)
|
||||
| -interix* | -uwin* | -rhapsody* | -openstep* | -oskit*)
|
||||
# Remember, each alternative MUST END IN *, to match a version number.
|
||||
;;
|
||||
-qnx*)
|
||||
case $basic_machine in
|
||||
x86-* | i*86-*)
|
||||
;;
|
||||
*)
|
||||
os=-nto$os
|
||||
;;
|
||||
esac
|
||||
;;
|
||||
-nto*)
|
||||
os=-nto-qnx
|
||||
;;
|
||||
-sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \
|
||||
| -windows* | -osx | -abug | -netware* | -os9* | -beos* \
|
||||
| -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*)
|
||||
| -macos* | -mpw* | -magic* | -mon960* | -lnews*)
|
||||
;;
|
||||
-mac*)
|
||||
os=`echo $os | sed -e 's|mac|macos|'`
|
||||
@@ -1099,12 +926,6 @@ case $os in
|
||||
-sunos6*)
|
||||
os=`echo $os | sed -e 's|sunos6|solaris3|'`
|
||||
;;
|
||||
-opened*)
|
||||
os=-openedition
|
||||
;;
|
||||
-wince*)
|
||||
os=-wince
|
||||
;;
|
||||
-osfrose*)
|
||||
os=-osfrose
|
||||
;;
|
||||
@@ -1129,9 +950,6 @@ case $os in
|
||||
-ns2 )
|
||||
os=-nextstep2
|
||||
;;
|
||||
-nsk*)
|
||||
os=-nsk
|
||||
;;
|
||||
# Preserve the version number of sinix5.
|
||||
-sinix5.*)
|
||||
os=`echo $os | sed -e 's|sinix|sysv|'`
|
||||
@@ -1166,7 +984,7 @@ case $os in
|
||||
-xenix)
|
||||
os=-xenix
|
||||
;;
|
||||
-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
|
||||
-*mint | -*MiNT)
|
||||
os=-mint
|
||||
;;
|
||||
-none)
|
||||
@@ -1194,15 +1012,12 @@ case $basic_machine in
|
||||
*-acorn)
|
||||
os=-riscix1.2
|
||||
;;
|
||||
arm*-rebel)
|
||||
arm*-corel)
|
||||
os=-linux
|
||||
;;
|
||||
arm*-semi)
|
||||
os=-aout
|
||||
;;
|
||||
pdp10-*)
|
||||
os=-tops20
|
||||
;;
|
||||
pdp11-*)
|
||||
os=-none
|
||||
;;
|
||||
@@ -1311,7 +1126,7 @@ case $basic_machine in
|
||||
*-masscomp)
|
||||
os=-rtu
|
||||
;;
|
||||
f30[01]-fujitsu | f700-fujitsu)
|
||||
f301-fujitsu)
|
||||
os=-uxpv
|
||||
;;
|
||||
*-rom68k)
|
||||
@@ -1371,7 +1186,7 @@ case $basic_machine in
|
||||
-genix*)
|
||||
vendor=ns
|
||||
;;
|
||||
-mvs* | -opened*)
|
||||
-mvs*)
|
||||
vendor=ibm
|
||||
;;
|
||||
-ptx*)
|
||||
@@ -1389,23 +1204,12 @@ case $basic_machine in
|
||||
-mpw* | -macos*)
|
||||
vendor=apple
|
||||
;;
|
||||
-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
|
||||
-*mint | -*MiNT)
|
||||
vendor=atari
|
||||
;;
|
||||
-vos*)
|
||||
vendor=stratus
|
||||
;;
|
||||
esac
|
||||
basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"`
|
||||
;;
|
||||
esac
|
||||
|
||||
echo $basic_machine$os
|
||||
exit 0
|
||||
|
||||
# Local variables:
|
||||
# eval: (add-hook 'write-file-hooks 'time-stamp)
|
||||
# time-stamp-start: "timestamp='"
|
||||
# time-stamp-format: "%:y-%02m-%02d"
|
||||
# time-stamp-end: "'"
|
||||
# End:
|
||||
|
3721
configure.in
3721
configure.in
File diff suppressed because it is too large
Load Diff
@@ -3,13 +3,11 @@
|
||||
#
|
||||
|
||||
all:
|
||||
cd src; $(MAKE)
|
||||
cd src; make
|
||||
|
||||
clean:
|
||||
cd src; $(MAKE) clean
|
||||
cd samples; $(MAKE) clean
|
||||
cd utils; $(MAKE) clean
|
||||
|
||||
cd src; make clean
|
||||
cd samples; make clean
|
||||
|
||||
samples:
|
||||
cd samples; $(MAKE)
|
||||
cd samples; make
|
||||
|
62
contrib/configure
vendored
62
contrib/configure
vendored
@@ -812,45 +812,17 @@ done
|
||||
ac_given_srcdir=$srcdir
|
||||
|
||||
trap 'rm -fr `echo "
|
||||
Makefile
|
||||
src/Makefile
|
||||
src/ogl/Makefile
|
||||
src/mmedia/Makefile
|
||||
src/stc/Makefile
|
||||
src/xrc/Makefile
|
||||
src/canvas/Makefile
|
||||
src/gizmos/Makefile
|
||||
src/plot/Makefile
|
||||
src/applet/Makefile
|
||||
src/fl/Makefile
|
||||
src/net/Makefile
|
||||
samples/Makefile
|
||||
samples/mmedia/Makefile
|
||||
samples/ogl/Makefile
|
||||
samples/ogl/ogledit/Makefile
|
||||
samples/ogl/studio/Makefile
|
||||
samples/stc/Makefile
|
||||
samples/canvas/Makefile
|
||||
samples/canvas/test/Makefile
|
||||
samples/canvas/simple/Makefile
|
||||
samples/gizmos/Makefile
|
||||
samples/gizmos/multicell/Makefile
|
||||
samples/gizmos/splittree/Makefile
|
||||
samples/gizmos/editlbox/Makefile
|
||||
samples/gizmos/dynsash/Makefile
|
||||
samples/gizmos/dynsash_switch/Makefile
|
||||
samples/xrc/Makefile
|
||||
samples/plot/Makefile
|
||||
samples/applet/Makefile
|
||||
samples/fl/Makefile
|
||||
samples/fl/fl_demo1/Makefile
|
||||
samples/fl/fl_demo2/Makefile
|
||||
samples/fl/fl_sample1/Makefile
|
||||
samples/fl/fl_sample2/Makefile
|
||||
samples/fl/fl_sample3/Makefile
|
||||
utils/Makefile
|
||||
utils/wxrc/Makefile
|
||||
utils/wxrcedit/Makefile
|
||||
utils/convertrc/Makefile
|
||||
" | sed "s/:[^ ]*//g"` conftest*; exit 1' 1 2 15
|
||||
EOF
|
||||
cat >> $CONFIG_STATUS <<EOF
|
||||
@@ -929,45 +901,17 @@ EOF
|
||||
|
||||
cat >> $CONFIG_STATUS <<EOF
|
||||
|
||||
CONFIG_FILES=\${CONFIG_FILES-"src/Makefile
|
||||
CONFIG_FILES=\${CONFIG_FILES-"Makefile
|
||||
src/Makefile
|
||||
src/ogl/Makefile
|
||||
src/mmedia/Makefile
|
||||
src/stc/Makefile
|
||||
src/xrc/Makefile
|
||||
src/canvas/Makefile
|
||||
src/gizmos/Makefile
|
||||
src/plot/Makefile
|
||||
src/applet/Makefile
|
||||
src/fl/Makefile
|
||||
src/net/Makefile
|
||||
samples/Makefile
|
||||
samples/mmedia/Makefile
|
||||
samples/ogl/Makefile
|
||||
samples/ogl/ogledit/Makefile
|
||||
samples/ogl/studio/Makefile
|
||||
samples/stc/Makefile
|
||||
samples/canvas/Makefile
|
||||
samples/canvas/test/Makefile
|
||||
samples/canvas/simple/Makefile
|
||||
samples/gizmos/Makefile
|
||||
samples/gizmos/multicell/Makefile
|
||||
samples/gizmos/splittree/Makefile
|
||||
samples/gizmos/editlbox/Makefile
|
||||
samples/gizmos/dynsash/Makefile
|
||||
samples/gizmos/dynsash_switch/Makefile
|
||||
samples/xrc/Makefile
|
||||
samples/plot/Makefile
|
||||
samples/applet/Makefile
|
||||
samples/fl/Makefile
|
||||
samples/fl/fl_demo1/Makefile
|
||||
samples/fl/fl_demo2/Makefile
|
||||
samples/fl/fl_sample1/Makefile
|
||||
samples/fl/fl_sample2/Makefile
|
||||
samples/fl/fl_sample3/Makefile
|
||||
utils/Makefile
|
||||
utils/wxrc/Makefile
|
||||
utils/wxrcedit/Makefile
|
||||
utils/convertrc/Makefile
|
||||
"}
|
||||
EOF
|
||||
cat >> $CONFIG_STATUS <<\EOF
|
||||
|
@@ -37,43 +37,15 @@ dnl File output
|
||||
|
||||
|
||||
AC_OUTPUT([
|
||||
Makefile
|
||||
src/Makefile
|
||||
src/ogl/Makefile
|
||||
src/mmedia/Makefile
|
||||
src/stc/Makefile
|
||||
src/xrc/Makefile
|
||||
src/canvas/Makefile
|
||||
src/gizmos/Makefile
|
||||
src/plot/Makefile
|
||||
src/applet/Makefile
|
||||
src/fl/Makefile
|
||||
src/net/Makefile
|
||||
samples/Makefile
|
||||
samples/mmedia/Makefile
|
||||
samples/ogl/Makefile
|
||||
samples/ogl/ogledit/Makefile
|
||||
samples/ogl/studio/Makefile
|
||||
samples/stc/Makefile
|
||||
samples/canvas/Makefile
|
||||
samples/canvas/test/Makefile
|
||||
samples/canvas/simple/Makefile
|
||||
samples/gizmos/Makefile
|
||||
samples/gizmos/multicell/Makefile
|
||||
samples/gizmos/splittree/Makefile
|
||||
samples/gizmos/editlbox/Makefile
|
||||
samples/gizmos/dynsash/Makefile
|
||||
samples/gizmos/dynsash_switch/Makefile
|
||||
samples/xrc/Makefile
|
||||
samples/plot/Makefile
|
||||
samples/applet/Makefile
|
||||
samples/fl/Makefile
|
||||
samples/fl/fl_demo1/Makefile
|
||||
samples/fl/fl_demo2/Makefile
|
||||
samples/fl/fl_sample1/Makefile
|
||||
samples/fl/fl_sample2/Makefile
|
||||
samples/fl/fl_sample3/Makefile
|
||||
utils/Makefile
|
||||
utils/wxrc/Makefile
|
||||
utils/wxrcedit/Makefile
|
||||
utils/convertrc/Makefile
|
||||
])
|
||||
|
Binary file not shown.
Before Width: | Height: | Size: 440 B |
@@ -214,30 +214,15 @@ been set. In all other cases, you must return FALSE.
|
||||
\membersection{wxSoundFileStream::RepositionStream}\label{wxsoundfilestreamrepositionstream}
|
||||
\func{bool}{RepositionStream}{\param{wxUint32 }{position}}
|
||||
|
||||
This is called by wxSoundFileStream::SetPosition to seek the input stream
|
||||
to the right position. This must be overidden by the file codec class.
|
||||
The position is relative to the beginning of the samples.
|
||||
If it is impossible (as for a piped input stream), you must return FALSE.
|
||||
|
||||
\membersection{wxSoundFileStream::FinishPreparation}\label{wxsoundfilestreamfinishpreparation}
|
||||
\func{void}{FinishPreparation}{\param{wxUint32 }{len}}
|
||||
|
||||
This is an internal function but it must called by the file codec class when
|
||||
the "playing" preparation is finished and you know the size of the stream.
|
||||
If it is an {\it infinite} stream, you should set this to wxSOUND\_INFINITE\_TIME.
|
||||
|
||||
\membersection{wxSoundFileStream::GetData}\label{wxsoundfilestreamgetdata}
|
||||
\func{wxUint32}{GetData}{\param{void* }{buffer}, \param{wxUint32 }{len}}
|
||||
|
||||
This is called by wxSoundFileStream when it needs to get new sound data to
|
||||
send to the device driver (or to a conversion codec). This must be eventually
|
||||
overidden by the file codec class. The default behaviour is simply to read from
|
||||
the input stream.
|
||||
|
||||
\membersection{wxSoundFileStream::PutData}\label{wxsoundfilestreamputdata}
|
||||
\func{wxUint32}{PutData}{\param{const void* }{buffer}, \param{wxUint32 }{len}}
|
||||
|
||||
This is called by wxSoundFileStream when it needs to put new sound data received
|
||||
from the device driver (or from a conversion codec). This must be eventually
|
||||
overidden by the file codec class. The default behaviour is simply to write to
|
||||
the input stream.
|
||||
|
@@ -6,8 +6,8 @@
|
||||
|
||||
\section{\class{wxSoundRouterStream}}\label{wxsoundrouterstream}
|
||||
|
||||
This is the router "codec" class. It should do codec routing when the device
|
||||
driver does not deal with a format.
|
||||
|
||||
Codec router class
|
||||
|
||||
\wxheading{Derived from}
|
||||
|
||||
@@ -17,21 +17,43 @@ driver does not deal with a format.
|
||||
|
||||
\latexignore{\rtfignore{\wxheading{Members}}}
|
||||
|
||||
\membersection{wxSoundRouterStream::wxSoundRouterStream}\label{wxsoundrouterstreamwxsoundrouterstream}
|
||||
\func{}{wxSoundRouterStream}{\param{wxSoundStream\& }{sndio}}
|
||||
|
||||
\helpref{wxSoundCodec}{wxsoundcodec}
|
||||
\membersection{wxSoundRouterStream::wxSoundRouterStream}\label{wxsoundrouterstreamwxsoundrouterstream}
|
||||
|
||||
\func{}{wxSoundRouterStream}{\param{wxSoundStream\& }{sndio}}
|
||||
|
||||
|
||||
\membersection{wxSoundRouterStream::\destruct{wxSoundRouterStream}}\label{wxsoundrouterstreamdtor}
|
||||
|
||||
\func{}{\destruct{wxSoundRouterStream}}{\void}
|
||||
|
||||
Destructor.
|
||||
|
||||
\membersection{wxSoundRouterStream::Read}\label{wxsoundrouterstreamread}
|
||||
|
||||
\func{wxSoundStream\&}{Read}{\param{void* }{buffer}, \param{wxUint32 }{len}}
|
||||
|
||||
|
||||
\membersection{wxSoundRouterStream::Write}\label{wxsoundrouterstreamwrite}
|
||||
|
||||
\func{wxSoundStream\&}{Write}{\param{const void* }{buffer}, \param{wxUint32 }{len}}
|
||||
|
||||
|
||||
\membersection{wxSoundRouterStream::SetSoundFormat}\label{wxsoundrouterstreamsetsoundformat}
|
||||
|
||||
\func{bool}{SetSoundFormat}{\param{const wxSoundFormatBase\& }{format}}
|
||||
|
||||
SetSoundFormat will first try to setup the device driver with the specified
|
||||
format. If this fails, it will try to find a codec which will convert the
|
||||
input format to a valid format for the device driver. It uses an internal
|
||||
codec database.
|
||||
|
||||
\membersection{wxSoundRouterStream::StartProduction}\label{wxsoundrouterstreamstartproduction}
|
||||
|
||||
\func{bool}{StartProduction}{\param{int }{evt}}
|
||||
|
||||
|
||||
\membersection{wxSoundRouterStream::StopProduction}\label{wxsoundrouterstreamstopproduction}
|
||||
|
||||
\func{bool}{StopProduction}{\void}
|
||||
|
||||
|
||||
\membersection{wxSoundRouterStream::GetBestSize}\label{wxsoundrouterstreamgetbestsize}
|
||||
|
||||
\constfunc{wxUint32}{GetBestSize}{\void}
|
||||
|
||||
|
@@ -1,4 +1,3 @@
|
||||
; Last change: JAC 13 Oct 100 5:16 pm
|
||||
runTwice = yes
|
||||
titleFontSize = 12
|
||||
authorFontSize = 10
|
||||
@@ -14,7 +13,7 @@ htmlBrowseButtons = bitmap
|
||||
winHelpVersion = 3
|
||||
winHelpContents = yes
|
||||
winHelpTitle = "MMedia Manual"
|
||||
truncateFilenames = no
|
||||
truncateFilenames = yes
|
||||
combineSubSections = yes
|
||||
\overview [2] {\rtfonly{See also }\settransparency{on}\sethotspotcolour{off}\sethotspotunderline{on}\winhelponly{\image{}{books.bmp}\settransparency{off}}
|
||||
\htmlonly{\image{}{books.gif}}\helpref{#1}{#2}
|
||||
|
Binary file not shown.
Before Width: | Height: | Size: 440 B |
@@ -1,4 +1,4 @@
|
||||
; Last change: JAC 13 Oct 100 5:11 pm
|
||||
; Last change: JS 8 Sep 98 2:54 pm
|
||||
runTwice = yes
|
||||
titleFontSize = 12
|
||||
authorFontSize = 10
|
||||
|
@@ -1,335 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: animate.h
|
||||
// Purpose: Animation classes
|
||||
// Author: Julian Smart and Guillermo Rodriguez Garcia
|
||||
// Modified by:
|
||||
// Created: 13/8/99
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) Julian Smart and Guillermo Rodriguez Garcia
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_ANIMATEH__
|
||||
#define _WX_ANIMATEH__
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "animate.h"
|
||||
#endif
|
||||
|
||||
#include <wx/defs.h>
|
||||
#include <wx/string.h>
|
||||
#include <wx/gdicmn.h>
|
||||
#include <wx/list.h>
|
||||
#include <wx/timer.h>
|
||||
|
||||
//#define ANIMDLLEXPORT WXDLLEXPORT
|
||||
#define ANIMDLLEXPORT
|
||||
|
||||
class ANIMDLLEXPORT wxAnimationBase;
|
||||
class ANIMDLLEXPORT wxAnimationPlayer;
|
||||
class WXDLLEXPORT wxImage;
|
||||
|
||||
enum wxAnimationDisposal
|
||||
{
|
||||
wxANIM_UNSPECIFIED = -1,
|
||||
wxANIM_DONOTREMOVE = 0,
|
||||
wxANIM_TOBACKGROUND = 1,
|
||||
wxANIM_TOPREVIOUS = 2
|
||||
} ;
|
||||
|
||||
class ANIMDLLEXPORT wxAnimationTimer: public wxTimer
|
||||
{
|
||||
public:
|
||||
wxAnimationTimer() { m_player = (wxAnimationPlayer*) NULL; }
|
||||
|
||||
virtual void Notify();
|
||||
void SetPlayer(wxAnimationPlayer* player) { m_player = player; }
|
||||
|
||||
protected:
|
||||
wxAnimationPlayer* m_player;
|
||||
};
|
||||
|
||||
/* wxAnimationPlayer
|
||||
* Create an object of this class, and either pass an wxXXXAnimation object in the constructor,
|
||||
* or call SetAnimation. Then call Play().
|
||||
* The wxAnimation object is only destroyed in the destructor if destroyAnimation is TRUE
|
||||
* in the constructor.
|
||||
*/
|
||||
|
||||
class ANIMDLLEXPORT wxAnimationPlayer : public wxObject
|
||||
{
|
||||
DECLARE_CLASS(wxAnimationPlayer)
|
||||
|
||||
public:
|
||||
wxAnimationPlayer(wxAnimationBase *animation = (wxAnimationBase *) NULL, bool destroyAnimation = FALSE);
|
||||
~wxAnimationPlayer();
|
||||
//// Accessors
|
||||
|
||||
void SetAnimation(wxAnimationBase* animation, bool destroyAnimation = FALSE);
|
||||
wxAnimationBase* GetAnimation() const { return m_animation; }
|
||||
|
||||
void SetDestroyAnimation(bool destroyAnimation) { m_destroyAnimation = destroyAnimation; };
|
||||
bool GetDestroyAnimation() const { return m_destroyAnimation; }
|
||||
|
||||
void SetCurrentFrame(int currentFrame) { m_currentFrame = currentFrame; };
|
||||
int GetCurrentFrame() const { return m_currentFrame; }
|
||||
|
||||
void SetWindow(wxWindow* window) { m_window = window; };
|
||||
wxWindow* GetWindow() const { return m_window; }
|
||||
|
||||
void SetPosition(const wxPoint& pos) { m_position = pos; };
|
||||
wxPoint GetPosition() const { return m_position; }
|
||||
|
||||
void SetLooped(bool looped) { m_looped = looped; };
|
||||
bool GetLooped() const { return m_looped; }
|
||||
|
||||
bool HasAnimation() const { return (m_animation != (wxAnimationBase*) NULL); }
|
||||
|
||||
bool IsPlaying() const { return m_isPlaying; }
|
||||
|
||||
// Specify whether the GIF's background colour is to be shown,
|
||||
// or whether the window background should show through (the default)
|
||||
void UseBackgroundColour(bool useBackground) { m_useBackgroundColour = useBackground; }
|
||||
bool UsingBackgroundColour() const { return m_useBackgroundColour; }
|
||||
|
||||
// Set and use a user-specified background colour (valid for transparent
|
||||
// animations only)
|
||||
void SetCustomBackgroundColour(const wxColour& col, bool useCustomBackgroundColour = TRUE)
|
||||
{ m_customBackgroundColour = col; m_useCustomBackgroundColour = useCustomBackgroundColour; }
|
||||
|
||||
bool UsingCustomBackgroundColour() const { return m_useCustomBackgroundColour; }
|
||||
const wxColour& GetCustomBackgroundColour() const { return m_customBackgroundColour; }
|
||||
|
||||
// Another refinement - suppose we're drawing the animation in a separate
|
||||
// control or window. We may wish to use the background of the parent
|
||||
// window as the background of our animation. This allows us to specify
|
||||
// whether to grab from the parent or from this window.
|
||||
void UseParentBackground(bool useParent) { m_useParentBackground = useParent; }
|
||||
bool UsingParentBackground() const { return m_useParentBackground; }
|
||||
|
||||
//// Operations
|
||||
|
||||
// Play
|
||||
virtual bool Play(wxWindow& window, const wxPoint& pos = wxPoint(0, 0), bool looped = TRUE);
|
||||
|
||||
// Build animation (list of wxImages). If not called before Play
|
||||
// is called, Play will call this automatically.
|
||||
virtual bool Build();
|
||||
|
||||
// Stop the animation
|
||||
virtual void Stop();
|
||||
|
||||
// Draw the current view of the animation into this DC.
|
||||
// Call this from your OnPaint, for example.
|
||||
virtual void Draw(wxDC& dc);
|
||||
|
||||
//// Accessing the current animation
|
||||
|
||||
virtual int GetFrameCount() const;
|
||||
virtual wxImage* GetFrame(int i) const; // Creates a new wxImage
|
||||
virtual wxAnimationDisposal GetDisposalMethod(int i) const;
|
||||
virtual wxRect GetFrameRect(int i) const; // Position and size of frame
|
||||
virtual int GetDelay(int i) const; // Delay for this frame
|
||||
|
||||
virtual wxSize GetLogicalScreenSize() const;
|
||||
virtual bool GetBackgroundColour(wxColour& col) const ;
|
||||
virtual bool GetTransparentColour(wxColour& col) const ;
|
||||
|
||||
//// Implementation
|
||||
|
||||
// Play the frame
|
||||
virtual bool PlayFrame(int frame, wxWindow& window, wxPoint& pos);
|
||||
virtual bool PlayFrame();
|
||||
virtual void DrawFrame(int frame, wxDC& dc, const wxPoint& pos);
|
||||
virtual void DrawBackground(wxDC& dc, const wxPoint& pos, const wxColour& colour);
|
||||
|
||||
// Clear the wxImage cache
|
||||
virtual void ClearCache();
|
||||
|
||||
// Save the pertinent area of the window so we can restore
|
||||
// it if drawing transparently
|
||||
void SaveBackground(const wxRect& rect);
|
||||
|
||||
wxBitmap& GetBackingStore() { return m_backingStore; }
|
||||
|
||||
//// Data members
|
||||
protected:
|
||||
wxAnimationBase* m_animation;
|
||||
bool m_destroyAnimation; // Destroy m_animation on deletion of this object
|
||||
wxList m_frames; // List of cached wxBitmap frames.
|
||||
int m_currentFrame; // Current frame
|
||||
wxWindow* m_window; // Window to draw into
|
||||
wxPoint m_position; // Position to draw at
|
||||
bool m_looped; // Looped, or not
|
||||
wxAnimationTimer m_timer; // The timer
|
||||
bool m_isPlaying; // Is the animation playing?
|
||||
wxBitmap m_savedBackground; // Saved background of window portion
|
||||
wxBitmap m_backingStore; // The player draws into this
|
||||
bool m_useBackgroundColour; // Use colour or background
|
||||
wxColour m_customBackgroundColour; // Override animation background
|
||||
bool m_useCustomBackgroundColour;
|
||||
bool m_useParentBackground; // Grab background from parent?
|
||||
};
|
||||
|
||||
/* wxAnimationBase
|
||||
* Base class for animations.
|
||||
* A wxXXXAnimation only stores the animation, providing accessors to wxAnimationPlayer.
|
||||
* Currently an animation is read-only, but we could extend the API for adding frames
|
||||
* programmatically, and perhaps have a wxMemoryAnimation class that stores its frames
|
||||
* in memory, and is able to save all files with suitable filenames. You could then use
|
||||
* e.g. Ulead GIF Animator to load the image files into a GIF animation.
|
||||
*/
|
||||
|
||||
class ANIMDLLEXPORT wxAnimationBase : public wxObject
|
||||
{
|
||||
DECLARE_ABSTRACT_CLASS(wxAnimationBase)
|
||||
|
||||
public:
|
||||
wxAnimationBase() {};
|
||||
~wxAnimationBase() {};
|
||||
|
||||
//// Accessors. Should be overridden by each derived class.
|
||||
|
||||
virtual int GetFrameCount() const = 0;
|
||||
virtual wxImage* GetFrame(int i) const = 0; // Creates a new wxImage
|
||||
virtual wxAnimationDisposal GetDisposalMethod(int i) const = 0;
|
||||
virtual wxRect GetFrameRect(int i) const = 0; // Position and size of frame
|
||||
virtual int GetDelay(int i) const = 0; // Delay for this frame
|
||||
|
||||
virtual wxSize GetLogicalScreenSize() const = 0;
|
||||
virtual bool GetBackgroundColour(wxColour& col) const = 0;
|
||||
virtual bool GetTransparentColour(wxColour& col) const = 0;
|
||||
|
||||
// Is the animation OK?
|
||||
virtual bool IsValid() const = 0;
|
||||
|
||||
//// Operations
|
||||
|
||||
virtual bool LoadFile(const wxString& filename) { return FALSE; }
|
||||
};
|
||||
|
||||
/* wxGIFAnimation
|
||||
* This will be moved to a separate file in due course.
|
||||
*/
|
||||
|
||||
class ANIMDLLEXPORT wxGIFDecoder;
|
||||
|
||||
class ANIMDLLEXPORT wxGIFAnimation : public wxAnimationBase
|
||||
{
|
||||
DECLARE_CLASS(wxGIFAnimation)
|
||||
|
||||
public:
|
||||
wxGIFAnimation() ;
|
||||
~wxGIFAnimation() ;
|
||||
|
||||
//// Accessors
|
||||
|
||||
virtual int GetFrameCount() const;
|
||||
virtual wxImage* GetFrame(int i) const;
|
||||
virtual wxAnimationDisposal GetDisposalMethod(int i) const;
|
||||
virtual wxRect GetFrameRect(int i) const; // Position and size of frame
|
||||
virtual int GetDelay(int i) const; // Delay for this frame
|
||||
|
||||
virtual wxSize GetLogicalScreenSize() const ;
|
||||
virtual bool GetBackgroundColour(wxColour& col) const ;
|
||||
virtual bool GetTransparentColour(wxColour& col) const ;
|
||||
|
||||
virtual bool IsValid() const;
|
||||
|
||||
//// Operations
|
||||
|
||||
virtual bool LoadFile(const wxString& filename);
|
||||
|
||||
protected:
|
||||
|
||||
wxGIFDecoder* m_decoder;
|
||||
};
|
||||
|
||||
/*
|
||||
* wxAnimationCtrlBase
|
||||
* Abstract base class for format-specific animation controls.
|
||||
* This class implements most of the functionality; all a derived
|
||||
* class has to do is create the appropriate animation class on demand.
|
||||
*/
|
||||
|
||||
// Resize to animation size if this is set
|
||||
#define wxAN_FIT_ANIMATION 0x0010
|
||||
|
||||
class ANIMDLLEXPORT wxAnimationCtrlBase: public wxControl
|
||||
{
|
||||
public:
|
||||
wxAnimationCtrlBase() { }
|
||||
wxAnimationCtrlBase(wxWindow *parent, wxWindowID id,
|
||||
const wxString& filename = wxEmptyString,
|
||||
const wxPoint& pos = wxDefaultPosition,
|
||||
const wxSize& size = wxDefaultSize, long style = wxAN_FIT_ANIMATION|wxNO_BORDER,
|
||||
const wxString& name = wxT("animationControl"))
|
||||
{
|
||||
Create(parent, id, filename, pos, size, style, name);
|
||||
}
|
||||
~wxAnimationCtrlBase();
|
||||
|
||||
bool Create(wxWindow *parent, wxWindowID id,
|
||||
const wxString& filename = wxEmptyString,
|
||||
const wxPoint& pos = wxDefaultPosition,
|
||||
const wxSize& size = wxDefaultSize, long style = wxAN_FIT_ANIMATION|wxNO_BORDER,
|
||||
const wxString& name = wxT("animationControl"));
|
||||
|
||||
//// Operations
|
||||
virtual bool LoadFile(const wxString& filename = wxEmptyString);
|
||||
virtual bool Play(bool looped = TRUE) ;
|
||||
virtual void Stop() { m_animationPlayer.Stop(); }
|
||||
virtual void FitToAnimation();
|
||||
|
||||
//// Accessors
|
||||
virtual bool IsPlaying() const { return m_animationPlayer.IsPlaying(); }
|
||||
virtual wxAnimationPlayer& GetPlayer() { return m_animationPlayer; }
|
||||
virtual wxAnimationBase* GetAnimation() { return m_animation; }
|
||||
|
||||
const wxString& GetFilename() const { return m_filename; }
|
||||
void SetFilename(const wxString& filename) { m_filename = filename; }
|
||||
|
||||
//// Event handlers
|
||||
void OnPaint(wxPaintEvent& event);
|
||||
|
||||
protected:
|
||||
virtual wxSize DoGetBestSize() const;
|
||||
|
||||
// Override this in derived classes
|
||||
virtual wxAnimationBase* DoCreateAnimation(const wxString& filename) = 0;
|
||||
|
||||
wxAnimationPlayer m_animationPlayer;
|
||||
wxAnimationBase* m_animation;
|
||||
wxString m_filename;
|
||||
|
||||
private:
|
||||
DECLARE_ABSTRACT_CLASS(wxAnimationCtrlBase)
|
||||
DECLARE_EVENT_TABLE()
|
||||
};
|
||||
|
||||
/*
|
||||
* wxGIFAnimationCtrl
|
||||
* Provides a GIF animation class when required.
|
||||
*/
|
||||
|
||||
class ANIMDLLEXPORT wxGIFAnimationCtrl: public wxAnimationCtrlBase
|
||||
{
|
||||
public:
|
||||
wxGIFAnimationCtrl() { }
|
||||
wxGIFAnimationCtrl(wxWindow *parent, wxWindowID id,
|
||||
const wxString& filename = wxEmptyString,
|
||||
const wxPoint& pos = wxDefaultPosition,
|
||||
const wxSize& size = wxDefaultSize, long style = wxAN_FIT_ANIMATION|wxNO_BORDER,
|
||||
const wxString& name = wxT("animationControl"))
|
||||
{
|
||||
Create(parent, id, filename, pos, size, style, name);
|
||||
}
|
||||
|
||||
protected:
|
||||
virtual wxAnimationBase* DoCreateAnimation(const wxString& filename) ;
|
||||
private:
|
||||
DECLARE_DYNAMIC_CLASS(wxGIFAnimationCtrl)
|
||||
};
|
||||
|
||||
#endif // _WX_ANIMATEH__
|
||||
|
@@ -1,85 +0,0 @@
|
||||
/****************************************************************************
|
||||
*
|
||||
* wxWindows HTML Applet Package
|
||||
*
|
||||
* Copyright (C) 1991-2001 SciTech Software, Inc.
|
||||
* All rights reserved.
|
||||
*
|
||||
* ========================================================================
|
||||
*
|
||||
* The contents of this file are subject to the wxWindows License
|
||||
* Version 3.0 (the "License"); you may not use this file except in
|
||||
* compliance with the License. You may obtain a copy of the License at
|
||||
* http://www.wxwindows.org/licence3.txt
|
||||
*
|
||||
* Software distributed under the License is distributed on an
|
||||
* "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
||||
* implied. See the License for the specific language governing
|
||||
* rights and limitations under the License.
|
||||
*
|
||||
* ========================================================================
|
||||
*
|
||||
* Language: ANSI C++
|
||||
* Environment: Any
|
||||
*
|
||||
* Description: Header file for the wxApplet class
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
#ifndef __WX_APPLET_H
|
||||
#define __WX_APPLET_H
|
||||
|
||||
#include "wx/panel.h"
|
||||
#include "wx/html/htmlwin.h"
|
||||
|
||||
// Forward declaration
|
||||
class wxHtmlAppletWindow;
|
||||
|
||||
/*--------------------------- Class Definitions ---------------------------*/
|
||||
|
||||
/****************************************************************************
|
||||
REMARKS:
|
||||
Defines the abstract base class for wxApplet objects.
|
||||
****************************************************************************/
|
||||
class wxApplet : public wxPanel {
|
||||
private:
|
||||
DECLARE_ABSTRACT_CLASS(wxApplet);
|
||||
DECLARE_EVENT_TABLE();
|
||||
|
||||
protected:
|
||||
//wxHtmlAppletWindow *m_parent;
|
||||
|
||||
// Special handler for background erase messages
|
||||
void OnEraseBackground(wxEraseEvent&);
|
||||
|
||||
public:
|
||||
// Constructor (called during dynamic creation)
|
||||
wxApplet() { m_parent = NULL; };
|
||||
|
||||
// Psuedo virtual constructor
|
||||
virtual bool Create(
|
||||
wxHtmlAppletWindow *parent,
|
||||
const wxHtmlTag& params,
|
||||
const wxSize& size,
|
||||
long style = wxTAB_TRAVERSAL | wxNO_BORDER);
|
||||
|
||||
// Virtual destructor
|
||||
virtual ~wxApplet();
|
||||
|
||||
// Handle HTML navigation to a new URL
|
||||
virtual void OnLinkClicked(const wxHtmlLinkInfo& link) = 0;
|
||||
|
||||
// Handle HTML navigation forward command in applet
|
||||
virtual void OnHistoryForward() = 0;
|
||||
|
||||
// Handle HTML navigation back command in applet
|
||||
virtual void OnHistoryBack() = 0;
|
||||
|
||||
// Handle messages from the wxAppletManager and other applets
|
||||
virtual void OnMessage(wxEvent& msg) = 0;
|
||||
};
|
||||
|
||||
|
||||
|
||||
#endif // __WX_APPLET_H
|
||||
|
@@ -1,95 +0,0 @@
|
||||
/****************************************************************************
|
||||
*
|
||||
* wxWindows HTML Applet Package
|
||||
*
|
||||
* Copyright (C) 1991-2001 SciTech Software, Inc.
|
||||
* All rights reserved.
|
||||
*
|
||||
* ========================================================================
|
||||
*
|
||||
* The contents of this file are subject to the wxWindows License
|
||||
* Version 3.0 (the "License"); you may not use this file except in
|
||||
* compliance with the License. You may obtain a copy of the License at
|
||||
* http://www.wxwindows.org/licence3.txt
|
||||
*
|
||||
* Software distributed under the License is distributed on an
|
||||
* "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
||||
* implied. See the License for the specific language governing
|
||||
* rights and limitations under the License.
|
||||
*
|
||||
* ========================================================================
|
||||
*
|
||||
* Language: ANSI C++
|
||||
* Environment: Any
|
||||
*
|
||||
* Description: Header file for wxEchoVariable Class, Dynamically constructed
|
||||
* objects representing variables in SSI #echo directive
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
#ifndef __WX_ECHOVAR_H
|
||||
#define __WX_ECHOVAR_H
|
||||
|
||||
/*--------------------------- Class Definitions ---------------------------*/
|
||||
|
||||
/****************************************************************************
|
||||
REMARKS:
|
||||
wxEchoVariable class Definition
|
||||
****************************************************************************/
|
||||
class wxEchoVariable : public wxObject {
|
||||
private:
|
||||
DECLARE_ABSTRACT_CLASS(wxEchoVariable);
|
||||
|
||||
public:
|
||||
wxEchoVariable() : wxObject() {}
|
||||
~wxEchoVariable() {}
|
||||
|
||||
/****************************************************************************
|
||||
RETURNS:
|
||||
The boolean value of the variable
|
||||
|
||||
PARAMETERS:
|
||||
parms - Optional parameter string passed from parm= field in HTML
|
||||
|
||||
REMARKS:
|
||||
To create new variables for the #echo HTML preprocessing directives
|
||||
you need to derive classes from wxEchoVariable and override the
|
||||
pure virtual GetValue function. However this should not be done directly
|
||||
but by using the BEGIN_ECHO_VARIABLE and END_ECHO_VARIABLE macros
|
||||
|
||||
SEE ALSO:
|
||||
wxEchoPrep, BEGIN_ECHO_VARIABLE, END_ECHO_VARIABLE
|
||||
****************************************************************************/
|
||||
virtual wxString GetValue(const char *parms = NULL) const = 0;
|
||||
|
||||
|
||||
public:
|
||||
// static function to retrieve any variable avaliable
|
||||
static wxString FindValue(const wxString &cls, const char *parms = NULL);
|
||||
};
|
||||
|
||||
/*--------------------------------- MACROS --------------------------------*/
|
||||
|
||||
#define ECHO_PARM (_BEV_parm)
|
||||
#define BEGIN_ECHO_VARIABLE(name) \
|
||||
class wxEchoVariable##name : public wxEchoVariable { \
|
||||
private: \
|
||||
DECLARE_DYNAMIC_CLASS(wxEchoVariable##name##); \
|
||||
public: \
|
||||
wxEchoVariable##name##() : wxEchoVariable() {} \
|
||||
virtual wxString GetValue(const char *parms = NULL) const; \
|
||||
}; \
|
||||
IMPLEMENT_DYNAMIC_CLASS(wxEchoVariable##name##, wxEchoVariable); \
|
||||
wxString wxEchoVariable##name :: GetValue(const char *parms) const { \
|
||||
wxString _BEV_parm = wxString(parms);
|
||||
|
||||
#define END_ECHO_VARIABLE(returnval) \
|
||||
return returnval; \
|
||||
}
|
||||
|
||||
#define STRING_ECHO_VARIABLE(name, string) \
|
||||
BEGIN_ECHO_VARIABLE(##name##); \
|
||||
END_ECHO_VARIABLE(wxString(##string##))
|
||||
|
||||
#endif // __WX_ECHOVAR_H
|
||||
|
@@ -1,94 +0,0 @@
|
||||
/****************************************************************************
|
||||
*
|
||||
* wxWindows HTML Applet Package
|
||||
*
|
||||
* Copyright (C) 1991-2001 SciTech Software, Inc.
|
||||
* All rights reserved.
|
||||
*
|
||||
* ========================================================================
|
||||
*
|
||||
* The contents of this file are subject to the wxWindows License
|
||||
* Version 3.0 (the "License"); you may not use this file except in
|
||||
* compliance with the License. You may obtain a copy of the License at
|
||||
* http://www.wxwindows.org/licence3.txt
|
||||
*
|
||||
* Software distributed under the License is distributed on an
|
||||
* "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
||||
* implied. See the License for the specific language governing
|
||||
* rights and limitations under the License.
|
||||
*
|
||||
* ========================================================================
|
||||
*
|
||||
* Language: ANSI C++
|
||||
* Environment: Any
|
||||
*
|
||||
* Description: Header file for wxIfElseVariable Class, Dynamically constructed
|
||||
* objects representing variables in SSI #if, #else and #endif directives
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
#ifndef __WX_IFELSEVAR_H
|
||||
#define __WX_IFELSEVAR_H
|
||||
|
||||
/*--------------------------- Class Definitions ---------------------------*/
|
||||
|
||||
/****************************************************************************
|
||||
REMARKS:
|
||||
This class is used to create variables for the HTML preprocessor #if, #else,
|
||||
and #endif directives.
|
||||
|
||||
SEE ALSO:
|
||||
wxIfElsePrep
|
||||
****************************************************************************/
|
||||
class wxIfElseVariable : public wxObject {
|
||||
private:
|
||||
DECLARE_ABSTRACT_CLASS(wxIfElseVariable);
|
||||
|
||||
public:
|
||||
wxIfElseVariable() : wxObject() {}
|
||||
~wxIfElseVariable() {}
|
||||
|
||||
/****************************************************************************
|
||||
RETURNS:
|
||||
The boolean value of the variable
|
||||
|
||||
REMARKS:
|
||||
To create new variables for the #if, #else and #endif HTML preprocessing
|
||||
blocks you need to derive classes from wxIfElseVariable and override the
|
||||
pure virtual GetValue function. However this should not be done directly
|
||||
but by using the BEGIN_IFELSE_VARIABLE and END_IFELSE_VARIABLE macros
|
||||
|
||||
SEE ALSO:
|
||||
wxIfElsePrep, BEGIN_IFELSE_VARIABLE, END_IFELSE_VARIABLE
|
||||
****************************************************************************/
|
||||
virtual bool GetValue() const = 0;
|
||||
|
||||
|
||||
public:
|
||||
// static function to retrieve any variable avaliable
|
||||
static bool FindValue(const wxString &cls);
|
||||
};
|
||||
|
||||
/*--------------------------------- MACROS --------------------------------*/
|
||||
|
||||
#define BEGIN_IFELSE_VARIABLE(name) \
|
||||
class wxIfElseVariable##name : public wxIfElseVariable { \
|
||||
private: \
|
||||
DECLARE_DYNAMIC_CLASS(wxIfElseVariable##name##); \
|
||||
public: \
|
||||
wxIfElseVariable##name##() : wxIfElseVariable() {} \
|
||||
virtual bool GetValue() const; \
|
||||
}; \
|
||||
IMPLEMENT_DYNAMIC_CLASS(wxIfElseVariable##name##, wxIfElseVariable); \
|
||||
bool wxIfElseVariable##name :: GetValue() const {
|
||||
|
||||
#define END_IFELSE_VARIABLE(returnval) \
|
||||
return returnval; \
|
||||
}
|
||||
|
||||
#define IFELSE_VARIABLE(name, state) \
|
||||
BEGIN_IFELSE_VARIABLE(##name##); \
|
||||
END_IFELSE_VARIABLE(bool (state))
|
||||
|
||||
#endif // __WX_IFELSEVAR_H
|
||||
|
@@ -1,109 +0,0 @@
|
||||
/****************************************************************************
|
||||
*
|
||||
* wxWindows HTML Applet Package
|
||||
*
|
||||
* Copyright (C) 1991-2001 SciTech Software, Inc.
|
||||
* All rights reserved.
|
||||
*
|
||||
* ========================================================================
|
||||
*
|
||||
* The contents of this file are subject to the wxWindows License
|
||||
* Version 3.0 (the "License"); you may not use this file except in
|
||||
* compliance with the License. You may obtain a copy of the License at
|
||||
* http://www.wxwindows.org/licence3.txt
|
||||
*
|
||||
* Software distributed under the License is distributed on an
|
||||
* "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
||||
* implied. See the License for the specific language governing
|
||||
* rights and limitations under the License.
|
||||
*
|
||||
* ========================================================================
|
||||
*
|
||||
* Language: ANSI C++
|
||||
* Environment: Any
|
||||
*
|
||||
* Description: Header file for the wxLoadPage Event class
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
#ifndef __WX_LOAD_PAGE_H
|
||||
#define __WX_LOAD_PAGE_H
|
||||
|
||||
#include "wx/html/htmlwin.h"
|
||||
|
||||
// Forward declaration
|
||||
class wxHtmlAppletWindow;
|
||||
|
||||
// If we are compiling this code into a library that links against
|
||||
// the DLL, we need to remove all the __declspec(dllimports) that
|
||||
// would declare our classes below incorrectly.
|
||||
|
||||
#ifndef WXMAKINGDLL
|
||||
#undef WXDLLEXPORT
|
||||
#define WXDLLEXPORT
|
||||
#endif
|
||||
// Declare our local load page event type
|
||||
BEGIN_DECLARE_EVENT_TYPES()
|
||||
DECLARE_EVENT_TYPE(wxEVT_LOAD_PAGE, wxEVT_USER_FIRST+1)
|
||||
DECLARE_EVENT_TYPE(wxEVT_PAGE_LOADED, wxEVT_USER_FIRST+2)
|
||||
END_DECLARE_EVENT_TYPES()
|
||||
|
||||
/*--------------------------- Class Definitions ---------------------------*/
|
||||
|
||||
/****************************************************************************
|
||||
REMARKS:
|
||||
Defines the class for load page events.
|
||||
****************************************************************************/
|
||||
class wxLoadPageEvent : public wxEvent {
|
||||
DECLARE_DYNAMIC_CLASS(wxLoadPageEvent);
|
||||
|
||||
protected:
|
||||
wxString m_hRef;
|
||||
wxHtmlAppletWindow *m_htmlWindow;
|
||||
|
||||
public:
|
||||
// Constructor
|
||||
wxLoadPageEvent(const wxString &hRef = "",wxHtmlAppletWindow *htmlWindow = NULL);
|
||||
|
||||
// Destructor
|
||||
~wxLoadPageEvent() {}
|
||||
|
||||
// Return the hmtl window for the load page operation
|
||||
wxHtmlAppletWindow *GetHtmlWindow() { return m_htmlWindow; };
|
||||
|
||||
// Get the hRef string for the load page operation
|
||||
const wxString & GetHRef() { return m_hRef; };
|
||||
|
||||
// Copy constructor for the object
|
||||
void CopyObject(wxObject& obj) const;
|
||||
};
|
||||
|
||||
|
||||
// Define the macro to create our event type
|
||||
typedef void (wxEvtHandler::*wxLoadPageEventFunction)(wxLoadPageEvent&);
|
||||
#define EVT_LOAD_PAGE(fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_LOAD_PAGE, -1, -1, (wxObjectEventFunction)(wxEventFunction)(wxLoadPageEventFunction) & fn, (wxObject *) NULL ),
|
||||
|
||||
/****************************************************************************
|
||||
REMARKS:
|
||||
Defines the class for pageloaded events.
|
||||
****************************************************************************/
|
||||
class wxPageLoadedEvent : public wxEvent {
|
||||
DECLARE_DYNAMIC_CLASS(wxPageLoadedEvent);
|
||||
|
||||
public:
|
||||
// Constructor
|
||||
wxPageLoadedEvent();
|
||||
|
||||
// Destructor
|
||||
~wxPageLoadedEvent() {}
|
||||
|
||||
// Copy constructor for the object
|
||||
void CopyObject(wxObject& obj) const;
|
||||
};
|
||||
|
||||
// Define the macro to create our event type
|
||||
typedef void (wxEvtHandler::*wxPageLoadedEventFunction)(wxPageLoadedEvent&);
|
||||
#define EVT_PAGE_LOADED(fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_PAGE_LOADED, -1, -1, (wxObjectEventFunction)(wxEventFunction)(wxPageLoadedEventFunction) & fn, (wxObject *) NULL ),
|
||||
|
||||
|
||||
#endif // __WX_LOAD_PAGE_H
|
@@ -1,57 +0,0 @@
|
||||
/****************************************************************************
|
||||
*
|
||||
* wxWindows HTML Applet Package
|
||||
*
|
||||
* Copyright (C) 1991-2001 SciTech Software, Inc.
|
||||
* All rights reserved.
|
||||
*
|
||||
* ========================================================================
|
||||
*
|
||||
* The contents of this file are subject to the wxWindows License
|
||||
* Version 3.0 (the "License"); you may not use this file except in
|
||||
* compliance with the License. You may obtain a copy of the License at
|
||||
* http://www.wxwindows.org/licence3.txt
|
||||
*
|
||||
* Software distributed under the License is distributed on an
|
||||
* "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
||||
* implied. See the License for the specific language governing
|
||||
* rights and limitations under the License.
|
||||
*
|
||||
* ========================================================================
|
||||
*
|
||||
* Language: ANSI C++
|
||||
* Environment: Any
|
||||
*
|
||||
* Description: Header file for the wxQlet class
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
#ifndef __WX_PLUGIN_H
|
||||
#define __WX_PLUGIN_H
|
||||
|
||||
// Forward declaration
|
||||
class wxHtmlAppletWindow;
|
||||
|
||||
/*--------------------------- Class Definitions ---------------------------*/
|
||||
|
||||
/****************************************************************************
|
||||
REMARKS:
|
||||
Defines the abstract base class for wxQlet objects.
|
||||
****************************************************************************/
|
||||
class wxPlugIn : public wxObject {
|
||||
private:
|
||||
DECLARE_ABSTRACT_CLASS(wxPlugIn);
|
||||
|
||||
wxHtmlAppletWindow *m_parent;
|
||||
public:
|
||||
// Constructor (called during dynamic creation)
|
||||
wxPlugIn() { m_parent = NULL; };
|
||||
|
||||
// Psuedo virtual constructor
|
||||
virtual bool Create(wxHtmlAppletWindow *parent);
|
||||
|
||||
// Virtual destructor
|
||||
virtual ~wxPlugIn();
|
||||
};
|
||||
#endif // __WX_PLUGIN_H
|
||||
|
@@ -1,59 +0,0 @@
|
||||
/****************************************************************************
|
||||
*
|
||||
* wxWindows HTML Applet Package
|
||||
*
|
||||
* Copyright (C) 1991-2001 SciTech Software, Inc.
|
||||
* All rights reserved.
|
||||
*
|
||||
* ========================================================================
|
||||
*
|
||||
* The contents of this file are subject to the wxWindows License
|
||||
* Version 3.0 (the "License"); you may not use this file except in
|
||||
* compliance with the License. You may obtain a copy of the License at
|
||||
* http://www.wxwindows.org/licence3.txt
|
||||
*
|
||||
* Software distributed under the License is distributed on an
|
||||
* "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
||||
* implied. See the License for the specific language governing
|
||||
* rights and limitations under the License.
|
||||
*
|
||||
* ========================================================================
|
||||
*
|
||||
* Language: ANSI C++
|
||||
* Environment: Any
|
||||
*
|
||||
* Description: Header file for the Preprocessor of the #echo directive
|
||||
* in wxHTML.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
#ifndef __WX_PREPECHO_H
|
||||
#define __WX_PREPECHO_H
|
||||
|
||||
#include "wx/html/htmlproc.h"
|
||||
|
||||
/*--------------------------- Class Definitions ---------------------------*/
|
||||
|
||||
/****************************************************************************
|
||||
REMARKS:
|
||||
Echo Preprocessor class Definition
|
||||
****************************************************************************/
|
||||
class wxEchoPrep : public wxHtmlProcessor {
|
||||
private:
|
||||
//DECLARE_DYNAMIC_CLASS(wxEchoPrep);
|
||||
|
||||
public:
|
||||
wxEchoPrep() : wxHtmlProcessor() {}
|
||||
~wxEchoPrep() {}
|
||||
|
||||
// Process input text and return processed result
|
||||
wxString Process(const wxString& text) const;
|
||||
|
||||
// Return priority value of this processor. The higher, the sooner
|
||||
// is the processor applied to the text.
|
||||
int GetPriority() const { return wxHTML_PRIORITY_SYSTEM-2; }
|
||||
};
|
||||
|
||||
|
||||
#endif // __WX_PREPECHO_H
|
||||
|
@@ -1,59 +0,0 @@
|
||||
/****************************************************************************
|
||||
*
|
||||
* wxWindows HTML Applet Package
|
||||
*
|
||||
* Copyright (C) 1991-2001 SciTech Software, Inc.
|
||||
* All rights reserved.
|
||||
*
|
||||
* ========================================================================
|
||||
*
|
||||
* The contents of this file are subject to the wxWindows License
|
||||
* Version 3.0 (the "License"); you may not use this file except in
|
||||
* compliance with the License. You may obtain a copy of the License at
|
||||
* http://www.wxwindows.org/licence3.txt
|
||||
*
|
||||
* Software distributed under the License is distributed on an
|
||||
* "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
||||
* implied. See the License for the specific language governing
|
||||
* rights and limitations under the License.
|
||||
*
|
||||
* ========================================================================
|
||||
*
|
||||
* Language: ANSI C++
|
||||
* Environment: Any
|
||||
*
|
||||
* Description: Header file for the Preprocessor of the #if SSI directive
|
||||
* in wxHTML.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
#ifndef __WX_PREPIFELSE_H
|
||||
#define __WX_PREPIFELSE_H
|
||||
|
||||
#include "wx/html/htmlproc.h"
|
||||
|
||||
/*--------------------------- Class Definitions ---------------------------*/
|
||||
|
||||
/****************************************************************************
|
||||
REMARKS:
|
||||
If Else Preprocessor class Definition
|
||||
****************************************************************************/
|
||||
class wxIfElsePrep : public wxHtmlProcessor {
|
||||
private:
|
||||
//DECLARE_DYNAMIC_CLASS(wxIfElsePrep);
|
||||
|
||||
public:
|
||||
wxIfElsePrep() : wxHtmlProcessor() {}
|
||||
~wxIfElsePrep() {}
|
||||
|
||||
// Process input text and return processed result
|
||||
wxString Process(const wxString& text) const;
|
||||
|
||||
// Return priority value of this processor. The higher, the sooner
|
||||
// is the processor applied to the text.
|
||||
int GetPriority() const { return wxHTML_PRIORITY_SYSTEM-2; }
|
||||
};
|
||||
|
||||
|
||||
#endif // __WX_PREPECHO_H
|
||||
|
@@ -1,61 +0,0 @@
|
||||
/****************************************************************************
|
||||
*
|
||||
* wxWindows HTML Applet Package
|
||||
*
|
||||
* Copyright (C) 1991-2001 SciTech Software, Inc.
|
||||
* All rights reserved.
|
||||
*
|
||||
* ========================================================================
|
||||
*
|
||||
* The contents of this file are subject to the wxWindows License
|
||||
* Version 3.0 (the "License"); you may not use this file except in
|
||||
* compliance with the License. You may obtain a copy of the License at
|
||||
* http://www.wxwindows.org/licence3.txt
|
||||
*
|
||||
* Software distributed under the License is distributed on an
|
||||
* "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
||||
* implied. See the License for the specific language governing
|
||||
* rights and limitations under the License.
|
||||
*
|
||||
* ========================================================================
|
||||
*
|
||||
* Language: ANSI C++
|
||||
* Environment: Any
|
||||
*
|
||||
* Description: Header file for the Preprocessor of the #include directive
|
||||
* in wxHTML.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
#ifndef __WX_PREPINCLUDE_H
|
||||
#define __WX_PREPINCLUDE_H
|
||||
|
||||
#include "wx/html/htmlproc.h"
|
||||
|
||||
/*--------------------------- Class Definitions ---------------------------*/
|
||||
|
||||
/****************************************************************************
|
||||
REMARKS:
|
||||
wxIncludePrep class Definition
|
||||
****************************************************************************/
|
||||
class wxIncludePrep : public wxHtmlProcessor {
|
||||
private:
|
||||
//DECLARE_DYNAMIC_CLASS(wxIncludePrep);
|
||||
wxFileSystem *m_FS;
|
||||
public:
|
||||
wxIncludePrep() : wxHtmlProcessor() {}
|
||||
~wxIncludePrep() {}
|
||||
|
||||
// Process input text and return processed result
|
||||
wxString Process(const wxString& text) const;
|
||||
|
||||
// Return priority value of this processor. The higher, the sooner
|
||||
// is the processor applied to the text.
|
||||
int GetPriority() const { return wxHTML_PRIORITY_SYSTEM; }
|
||||
|
||||
void ChangeDirectory(wxFileSystem *);
|
||||
};
|
||||
|
||||
|
||||
#endif // __WX_PREPINCLUDE_H
|
||||
|
@@ -1,226 +0,0 @@
|
||||
/****************************************************************************
|
||||
*
|
||||
* wxWindows HTML Applet Package
|
||||
*
|
||||
* Copyright (C) 1991-2001 SciTech Software, Inc.
|
||||
* All rights reserved.
|
||||
*
|
||||
* ========================================================================
|
||||
*
|
||||
* The contents of this file are subject to the wxWindows License
|
||||
* Version 3.0 (the "License"); you may not use this file except in
|
||||
* compliance with the License. You may obtain a copy of the License at
|
||||
* http://www.wxwindows.org/licence3.txt
|
||||
*
|
||||
* Software distributed under the License is distributed on an
|
||||
* "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
||||
* implied. See the License for the specific language governing
|
||||
* rights and limitations under the License.
|
||||
*
|
||||
* ========================================================================
|
||||
*
|
||||
* Language: ANSI C++
|
||||
* Environment: Any
|
||||
*
|
||||
* Description: Header file for the wxHtmlAppletWindow class
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
#ifndef __WX_APPLET_WINDOW_H
|
||||
#define __WX_APPLET_WINDOW_H
|
||||
|
||||
#include "wx/html/htmlwin.h"
|
||||
#include "wx/process.h"
|
||||
|
||||
// Forward declare
|
||||
class wxApplet;
|
||||
class wxQlet;
|
||||
class wxLoadPageEvent;
|
||||
class wxPageLoadedEvent;
|
||||
class wxIncludePrep;
|
||||
class wxToolBarBase;
|
||||
|
||||
// Declare a linked list of wxApplet pointers
|
||||
WX_DECLARE_LIST(wxApplet, wxAppletList);
|
||||
|
||||
/*--------------------------- Class Definitions ---------------------------*/
|
||||
|
||||
/****************************************************************************
|
||||
REMARKS:
|
||||
Defines the class for virtual-link data types
|
||||
****************************************************************************/
|
||||
class VirtualData : public wxObject {
|
||||
private:
|
||||
wxString m_name;
|
||||
wxString m_group;
|
||||
wxString m_href;
|
||||
|
||||
public:
|
||||
// Ctors
|
||||
VirtualData(
|
||||
wxString& name,
|
||||
wxString& group,
|
||||
wxString& href );
|
||||
|
||||
VirtualData();
|
||||
|
||||
// Gets
|
||||
wxString GetName(){ return m_name;};
|
||||
wxString GetGroup(){ return m_group;};
|
||||
wxString GetHref(){ return m_href;};
|
||||
|
||||
// Sets
|
||||
void SetName (wxString& s){ m_name = s; };
|
||||
void SetGroup(wxString& s){ m_group = s; };
|
||||
void SetHref (wxString& s){ m_href = s; };
|
||||
};
|
||||
|
||||
/****************************************************************************
|
||||
REMARKS:
|
||||
Defines the class for wxAppletWindow. This class is derived from the
|
||||
wxHtmlWindow class and extends it with functionality to handle embedded
|
||||
wxApplet's on the HTML pages.
|
||||
****************************************************************************/
|
||||
class wxHtmlAppletWindow : public wxHtmlWindow {
|
||||
private:
|
||||
DECLARE_CLASS(wxHtmlAppletWindow);
|
||||
DECLARE_EVENT_TABLE();
|
||||
|
||||
bool m_mutexLock;
|
||||
wxIncludePrep *incPreprocessor; // deleted by list it is added too in constructor
|
||||
|
||||
protected:
|
||||
wxAppletList m_AppletList;
|
||||
static wxHashTable m_Cookies;
|
||||
bool m_NavBarEnabled;
|
||||
wxToolBarBase *m_NavBar;
|
||||
int m_NavBackId;
|
||||
int m_NavForwardId;
|
||||
wxPalette m_globalPalette;
|
||||
|
||||
// Override this so we can do proper palette management!!
|
||||
virtual void OnDraw(wxDC& dc);
|
||||
|
||||
public:
|
||||
// Constructor
|
||||
wxHtmlAppletWindow(
|
||||
wxWindow *parent,
|
||||
wxWindowID id = -1,
|
||||
wxToolBarBase *navBar = NULL,
|
||||
int navBackId = -1,
|
||||
int navForwardId = -1,
|
||||
const wxPoint& pos = wxDefaultPosition,
|
||||
const wxSize& size = wxDefaultSize,
|
||||
long style = wxHW_SCROLLBAR_AUTO,
|
||||
const wxString& name = "htmlAppletWindow",
|
||||
const wxPalette& globalPalette = wxNullPalette);
|
||||
|
||||
// Destructor
|
||||
~wxHtmlAppletWindow();
|
||||
|
||||
// Create an instance of an applet based on it's class name
|
||||
wxApplet *CreateApplet(
|
||||
const wxString& classId,
|
||||
const wxString& iName,
|
||||
const wxHtmlTag ¶ms,
|
||||
const wxSize& size);
|
||||
|
||||
// Create an instance of an Qlet based on it's class name
|
||||
bool CreatePlugIn(const wxString& classId );
|
||||
|
||||
// Find an instance of an applet based on it's class name
|
||||
wxApplet *FindApplet(const wxString& className);
|
||||
|
||||
// Remove an applet from the window. Called during applet destruction
|
||||
bool RemoveApplet(const wxApplet *applet);
|
||||
|
||||
// Load a new URL page
|
||||
virtual bool LoadPage(const wxString& location);
|
||||
|
||||
// Called when users clicked on hypertext link.
|
||||
virtual void OnLinkClicked(const wxHtmlLinkInfo& link);
|
||||
|
||||
// Handles forward navigation within the HTML stack
|
||||
bool HistoryForward();
|
||||
|
||||
// Handles backwards navigation within the HTML stack
|
||||
bool HistoryBack();
|
||||
|
||||
// Disables Nav bars
|
||||
void DisableNavBar();
|
||||
|
||||
// Enables Nav bars
|
||||
void EnableNavBar();
|
||||
|
||||
void SetNavBar(wxToolBarBase *navBar);
|
||||
|
||||
// Broadcast a message to all applets on the page
|
||||
void SendMessage(wxEvent& msg);
|
||||
|
||||
// Register a cookie of data in the applet manager
|
||||
static bool RegisterCookie(const wxString& name,wxObject *cookie);
|
||||
|
||||
// UnRegister a cookie of data in the applet manager
|
||||
static bool UnRegisterCookie(const wxString& name);
|
||||
|
||||
// Find a cookie of data given it's public name
|
||||
static wxObject *FindCookie(const wxString& name);
|
||||
|
||||
// Event handlers to load a new page
|
||||
void OnLoadPage(wxLoadPageEvent &event);
|
||||
|
||||
// Event handlers to load a new page
|
||||
void OnPageLoaded(wxPageLoadedEvent &event);
|
||||
|
||||
// LoadPage mutex locks
|
||||
void Lock(){ m_mutexLock = true;};
|
||||
void UnLock(){ m_mutexLock = false;};
|
||||
|
||||
// Returns TRUE if the mutex is locked, FALSE otherwise.
|
||||
bool IsLocked(){ return m_mutexLock;};
|
||||
|
||||
// Tries to lock the mutex. If it can't, returns immediately with false.
|
||||
bool TryLock();
|
||||
|
||||
};
|
||||
|
||||
/****************************************************************************
|
||||
REMARKS:
|
||||
Defines the class for AppetProcess
|
||||
***************************************************************************/
|
||||
class AppletProcess : public wxProcess {
|
||||
public:
|
||||
AppletProcess(
|
||||
wxWindow *parent)
|
||||
: wxProcess(parent)
|
||||
{
|
||||
}
|
||||
|
||||
// instead of overriding this virtual function we might as well process the
|
||||
// event from it in the frame class - this might be more convenient in some
|
||||
// cases
|
||||
virtual void OnTerminate(int pid, int status);
|
||||
|
||||
};
|
||||
|
||||
/****************************************************************************
|
||||
REMARKS:
|
||||
Defines the class for wxHtmlAppletCell
|
||||
***************************************************************************/
|
||||
class wxHtmlAppletCell : public wxHtmlCell
|
||||
{
|
||||
public:
|
||||
wxHtmlAppletCell(wxWindow *wnd, int w = 0);
|
||||
~wxHtmlAppletCell() { m_Wnd->Destroy(); }
|
||||
virtual void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2);
|
||||
virtual void DrawInvisible(wxDC& dc, int x, int y);
|
||||
virtual void Layout(int w);
|
||||
|
||||
protected:
|
||||
wxWindow* m_Wnd;
|
||||
// width float is used in adjustWidth (it is in percents)
|
||||
};
|
||||
|
||||
|
||||
#endif // __WX_APPLET_WINDOW_H
|
||||
|
@@ -1,76 +0,0 @@
|
||||
#ifndef __WXBOUNDINGBOX_H__
|
||||
#define __WXBOUNDINGBOX_H__
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "bbox.cpp"
|
||||
#endif
|
||||
|
||||
#ifndef WX_PRECOMP
|
||||
#include "wx/wx.h"
|
||||
#endif
|
||||
|
||||
#include "wx/matrix.h"
|
||||
#include "wx/geometry.h"
|
||||
|
||||
enum OVERLAP {_IN,_ON,_OUT};
|
||||
|
||||
//Purpose The wxBoundingBox class stores one wxBoundingBox.
|
||||
//The wxBoundingBox is defined by two coordiates,
|
||||
//a upperleft coordinate and a lowerright coordinate.
|
||||
class wxBoundingBox
|
||||
{
|
||||
public:
|
||||
wxBoundingBox();
|
||||
wxBoundingBox(wxBoundingBox&);
|
||||
wxBoundingBox(const wxPoint2DDouble&);
|
||||
wxBoundingBox(double xmin, double ymin, double xmax, double ymax);
|
||||
|
||||
bool And(wxBoundingBox*, double Marge = 0);
|
||||
|
||||
void EnLarge(const double Marge);
|
||||
void Shrink(const double Marge);
|
||||
|
||||
void Expand(const wxPoint2DDouble& , const wxPoint2DDouble&);
|
||||
void Expand(const wxPoint2DDouble&);
|
||||
void Expand(double x,double y);
|
||||
void Expand(const wxBoundingBox& bbox);
|
||||
|
||||
OVERLAP Intersect( wxBoundingBox &, double Marge = 0);
|
||||
bool LineIntersect(const wxPoint2DDouble& begin, const wxPoint2DDouble& end );
|
||||
bool PointInBox( const wxPoint2DDouble&, double Marge = 0);
|
||||
bool PointInBox( double, double, double Marge = 0);
|
||||
|
||||
void Reset();
|
||||
|
||||
void Translate( wxPoint2DDouble& );
|
||||
void MapBbox( const wxTransformMatrix& matrix);
|
||||
|
||||
double GetWidth() {return m_maxx-m_minx;};
|
||||
double GetHeight(){return m_maxy-m_miny;};
|
||||
bool GetValid() const;
|
||||
void SetValid(bool);
|
||||
|
||||
void SetBoundingBox(const wxPoint2DDouble& a_point);
|
||||
|
||||
void SetMin(double, double);
|
||||
void SetMax(double, double);
|
||||
inline wxPoint2DDouble GetMin();
|
||||
inline wxPoint2DDouble GetMax();
|
||||
inline double GetMinX(){return m_minx;};
|
||||
inline double GetMinY(){return m_miny;};
|
||||
inline double GetMaxX(){return m_maxx;};
|
||||
inline double GetMaxY(){return m_maxy;};
|
||||
|
||||
wxBoundingBox& operator+( wxBoundingBox& );
|
||||
wxBoundingBox& operator=( const wxBoundingBox& );
|
||||
|
||||
protected:
|
||||
//bounding box in world
|
||||
double m_minx;
|
||||
double m_miny;
|
||||
double m_maxx;
|
||||
double m_maxy;
|
||||
bool m_validbbox;
|
||||
};
|
||||
|
||||
#endif
|
@@ -1,859 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: canvas.h
|
||||
// Author: Robert Roebling
|
||||
// Created: XX/XX/XX
|
||||
// Copyright: 2000 (c) Robert Roebling
|
||||
// Licence: wxWindows Licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef __WXCANVAS_H__
|
||||
#define __WXCANVAS_H__
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "canvas.cpp"
|
||||
#endif
|
||||
|
||||
#ifndef WX_PRECOMP
|
||||
#include "wx/wx.h"
|
||||
#endif
|
||||
|
||||
#include "wx/image.h"
|
||||
#include "wx/txtstrm.h"
|
||||
#include "wx/geometry.h"
|
||||
#include "wx/matrix.h"
|
||||
#include "bbox.h"
|
||||
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// decls
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
class wxCanvas;
|
||||
class wxCanvasAdmin;
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// wxCanvasObject
|
||||
//----------------------------------------------------------------------------
|
||||
enum wxDRAG_MODE
|
||||
{
|
||||
wxDRAG_RECTANGLE,
|
||||
wxDRAG_ONTOP,
|
||||
wxDRAG_REDRAW
|
||||
};
|
||||
|
||||
//:defenition
|
||||
// wxCanvasObject is the base class for Canvas Objects.
|
||||
// All Objects for drawing one the canvas are derived from this class.
|
||||
// It supports dragging and moving methods that can be used in derived
|
||||
// classes for defining several ways of dragging.
|
||||
// Also it is possible to plug in events handlers to do this for all derived classes at once.
|
||||
//
|
||||
// wxCanvasObjects have themselves as their event handlers by default,
|
||||
// but their event handlers could be set to another object entirely. This
|
||||
// separation can reduce the amount of derivation required, and allow
|
||||
// alteration of a wxCanvasObject functionality
|
||||
class wxCanvasObject: public wxEvtHandler
|
||||
{
|
||||
public:
|
||||
|
||||
wxCanvasObject();
|
||||
|
||||
//If the position (x,y) is within the object this return a pointer to the object
|
||||
//Normally this function needs to be defined for each derived wxCanvasObject.
|
||||
//The default is a simple bounding box test.
|
||||
virtual wxCanvasObject* IsHitWorld( double x, double y, double margin = 0 );
|
||||
|
||||
//render this object to the canvas (either on its buffer or directly on the canvas)
|
||||
//this depends on the wxDC that is set for the active canvas.
|
||||
virtual void Render(wxTransformMatrix* cworld, int clip_x, int clip_y, int clip_width, int clip_height );
|
||||
|
||||
//x position in world coordinates of the object
|
||||
virtual double GetPosX()=0;
|
||||
//y position in world coordinates of the object
|
||||
virtual double GetPosY()=0;
|
||||
|
||||
//set position in world coordinates for the object
|
||||
virtual void SetPosXY( double x, double y)=0;
|
||||
|
||||
//absolute moving the object to position x,y in world coordinates
|
||||
//also does an update of the old and new area
|
||||
virtual void MoveAbsolute( double x, double y );
|
||||
|
||||
//relative moving the object to position x,y in world coordinates
|
||||
//also does an update of the old and new area
|
||||
virtual void MoveRelative( double x, double y );
|
||||
|
||||
//relative translate the object to position x,y in world coordinates
|
||||
//does NOT update the old and new area
|
||||
//this function must be defined for each derived object,
|
||||
//it is used internally for dragging and moving objects.
|
||||
virtual void TransLate( double x, double y )=0;
|
||||
|
||||
//choose one of the three diffrenet drag methods |
|
||||
//DRAG_RECTANGLE = as a rectangle when drag is in progress |
|
||||
//DRAG_ONTOP = only redraw the object when dragging |
|
||||
//DRAG_REDRAW = redraw the damaged areas when dragging
|
||||
void SetDragMode(wxDRAG_MODE mode) { m_dragmode=mode; };
|
||||
|
||||
//return the dragmode
|
||||
wxDRAG_MODE GetDragMode() { return m_dragmode; };
|
||||
|
||||
//called when starting a drag
|
||||
virtual void DragStart();
|
||||
//called when dragging is in progress
|
||||
virtual void DragRelative( double x, double y);
|
||||
//called when dragging is ended
|
||||
virtual void DragEnd();
|
||||
|
||||
//return the object if it is part of the given object or
|
||||
//if the given object is part of a group within this object.
|
||||
//For group objects this means recursively search for it.
|
||||
virtual wxCanvasObject* Contains( wxCanvasObject* obj );
|
||||
|
||||
//calculate the boundingbox in world coordinates
|
||||
virtual void CalcBoundingBox()=0;
|
||||
|
||||
//write the object as SVG (scalable vector grafhics
|
||||
virtual void WriteSVG( wxTextOutputStream &stream );
|
||||
|
||||
//get the administrator for the object,
|
||||
//this will give access to the canvas's where it is displayed upon.
|
||||
//It is used to render the object to the active canvas.
|
||||
//Conversion from world to Device coordinates and visa versa is
|
||||
//done using the Active canvas at that moment.
|
||||
wxCanvasAdmin *GetAdmin() { return m_admin; }
|
||||
|
||||
//set the administrator
|
||||
virtual void SetAdmin( wxCanvasAdmin *admin ) { m_admin = admin; }
|
||||
|
||||
//is this a control type of canvas object
|
||||
bool IsControl() { return m_isControl; }
|
||||
//is this a vector type of canvas object
|
||||
bool IsVector() { return m_isVector; }
|
||||
//is this an Image type of canvas object
|
||||
bool IsImage() { return m_isImage; }
|
||||
|
||||
//get minimum X of the boundingbox in world coordinates
|
||||
inline double GetXMin() { return m_bbox.GetMinX(); }
|
||||
//get minimum Y of the boundingbox in world coordinates
|
||||
inline double GetYMin() { return m_bbox.GetMinY(); }
|
||||
//get maximum X of the boundingbox in world coordinates
|
||||
inline double GetXMax() { return m_bbox.GetMaxX(); }
|
||||
//get maximum Y of the boundingbox in world coordinates
|
||||
inline double GetYMax() { return m_bbox.GetMaxY(); }
|
||||
|
||||
//get boundingbox
|
||||
inline wxBoundingBox GetBbox() { return m_bbox; }
|
||||
|
||||
//redirect all mouse events for the canvas to this object
|
||||
void CaptureMouse();
|
||||
//release the mouse capture for this object
|
||||
void ReleaseMouse();
|
||||
//is the mouse captured for this object
|
||||
bool IsCapturedMouse();
|
||||
|
||||
//set if this object will visible (be rendered or not)
|
||||
inline void SetVisible(bool visible) { m_visible=visible; }
|
||||
//get visibility
|
||||
inline bool GetVisible() {return m_visible; }
|
||||
|
||||
//can the object be dragged
|
||||
inline void SetDraggable(bool drag) { m_dragable=drag; }
|
||||
//get if the object can be dragged
|
||||
inline bool GetDraggable() {return m_dragable; }
|
||||
|
||||
//get absolute area in the device coordinates where the object
|
||||
//its boundingbox in world coordinates is first translated using the matrix.
|
||||
wxRect GetAbsoluteArea(const wxTransformMatrix& cworld);
|
||||
|
||||
//get currently used eventhandler (always the first in the list)
|
||||
wxEvtHandler *GetEventHandler() const { return m_eventHandler; }
|
||||
|
||||
//process an event for the object, starting with the first eventhandler
|
||||
// in the list.
|
||||
bool ProcessCanvasObjectEvent(wxEvent& event);
|
||||
|
||||
// push/pop event handler: allows to chain a custom event handler to
|
||||
// already existing ones
|
||||
void PushEventHandler( wxEvtHandler *handler );
|
||||
|
||||
//remove first eventhandler in the list (one will be always stay in)
|
||||
wxEvtHandler *PopEventHandler( bool deleteHandler = FALSE );
|
||||
//append an eventhandler to the list, this event handler will be called
|
||||
//if the other skipped the event to process.
|
||||
void AppendEventHandler(wxEvtHandler *handler);
|
||||
//remove last event handler in the list (one will always stay in)
|
||||
wxEvtHandler *RemoveLastEventHandler(bool deleteHandler);
|
||||
|
||||
protected:
|
||||
|
||||
//administator for rendering and accessing the canvas's
|
||||
wxCanvasAdmin* m_admin;
|
||||
|
||||
//active event handler, default the object itself
|
||||
wxEvtHandler* m_eventHandler;
|
||||
|
||||
bool m_isControl:1;
|
||||
bool m_isVector:1;
|
||||
bool m_isImage:1;
|
||||
bool m_visible:1;
|
||||
bool m_dragable:1;
|
||||
wxDRAG_MODE m_dragmode:3;
|
||||
|
||||
//boundingbox in world coordinates
|
||||
wxBoundingBox m_bbox;
|
||||
|
||||
//used for dragging
|
||||
wxBitmap m_atnewpos;
|
||||
};
|
||||
|
||||
//:defenition
|
||||
// wxCanvasObjectGroup is a container for wxCanvas derived Objects.
|
||||
// It renders itself by calling the render methods of the wxCanvasObjects it contains.
|
||||
// It can have nested groups also, in the same way as the other wxCanvasObjects it already contains.
|
||||
// The group has a matrix to position/rotate/scale the group.
|
||||
class wxCanvasObjectGroup: public wxCanvasObject
|
||||
{
|
||||
public:
|
||||
wxCanvasObjectGroup(double x, double y);
|
||||
virtual ~wxCanvasObjectGroup();
|
||||
|
||||
void SetAdmin(wxCanvasAdmin* admin);
|
||||
|
||||
//prepend a wxCanvasObject to this group
|
||||
virtual void Prepend( wxCanvasObject* obj );
|
||||
//append a wxCanvasObject to this group
|
||||
virtual void Append( wxCanvasObject* obj );
|
||||
//insert a wxCanvasObject to this group
|
||||
virtual void Insert( size_t before, wxCanvasObject* obj );
|
||||
//remove the given object from the group
|
||||
virtual void Remove( wxCanvasObject* obj );
|
||||
|
||||
//those this group contain the given object.
|
||||
//in case of nested groups also search in there to the lowwest level.
|
||||
virtual wxCanvasObject* Contains( wxCanvasObject* obj );
|
||||
|
||||
//returns index of the given wxCanvasObject in this group
|
||||
virtual int IndexOf( wxCanvasObject* obj );
|
||||
|
||||
double GetPosX() { return lworld.GetValue(2,0); }
|
||||
double GetPosY() { return lworld.GetValue(2,1); }
|
||||
void SetPosXY( double x, double y) {lworld.SetValue(2,0,x);lworld.SetValue(2,1,y);CalcBoundingBox();};
|
||||
|
||||
void TransLate( double x, double y );
|
||||
|
||||
void CalcBoundingBox();
|
||||
//remove all wxCanvasObjects from the group (flag for deletion of the objectsalso)
|
||||
void DeleteContents( bool );
|
||||
virtual void Render(wxTransformMatrix* cworld,int x, int y, int width, int height );
|
||||
virtual void WriteSVG( wxTextOutputStream &stream );
|
||||
|
||||
//recursive call the IsHitWorld on all contained objects, the first
|
||||
//one that is hit will be returned
|
||||
wxCanvasObject* IsHitWorld( double x, double y, double margin = 0 );
|
||||
|
||||
//recursive calls for contained objects to set eventhandlers,
|
||||
//and also sets its own eventhandler
|
||||
void PushEventHandler( wxEvtHandler *handler );
|
||||
//recursive calls for contained objects to set eventhandlers,
|
||||
//and also sets its own eventhandler
|
||||
wxEvtHandler *PopEventHandler( bool deleteHandler = FALSE );
|
||||
//recursive calls for contained objects to set eventhandlers,
|
||||
//and also sets its own eventhandler
|
||||
void AppendEventHandler(wxEvtHandler *handler);
|
||||
//recursive calls for contained objects to set eventhandlers,
|
||||
//and also sets its own eventhandler
|
||||
wxEvtHandler *RemoveLastEventHandler(bool deleteHandler);
|
||||
|
||||
protected:
|
||||
|
||||
//to position the object
|
||||
wxTransformMatrix lworld;
|
||||
|
||||
wxList m_objects;
|
||||
|
||||
friend class wxCanvas;
|
||||
};
|
||||
|
||||
//:defenition
|
||||
// wxCanvasObjectRef is a reference to any wxCanvasObject derived class.
|
||||
// It does not duplicate the referenced object.
|
||||
// It has a matrix to reposition/rotate/scale the object it references.
|
||||
// The position/matrix of the referenced Object is accumulated with the one here.
|
||||
class wxCanvasObjectRef: public wxCanvasObject
|
||||
{
|
||||
public:
|
||||
wxCanvasObjectRef(double x, double y,wxCanvasObject* obj);
|
||||
|
||||
//set rotation for the reference
|
||||
void SetRotation(double rotation);
|
||||
|
||||
//set scale in x and y ( > zero)
|
||||
void SetScale( double scalex, double scaley );
|
||||
|
||||
void SetAdmin(wxCanvasAdmin* admin);
|
||||
|
||||
double GetPosX() { return lworld.GetValue(2,0); }
|
||||
double GetPosY() { return lworld.GetValue(2,1); }
|
||||
void SetPosXY( double x, double y) {lworld.SetValue(2,0,x);lworld.SetValue(2,1,y);CalcBoundingBox();};
|
||||
|
||||
void TransLate( double x, double y );
|
||||
void CalcBoundingBox();
|
||||
virtual void Render(wxTransformMatrix* cworld,int x, int y, int width, int height );
|
||||
virtual void WriteSVG( wxTextOutputStream &stream );
|
||||
|
||||
//return this object if one of the objects it references is hit
|
||||
wxCanvasObject* IsHitWorld( double x, double y, double margin = 0 );
|
||||
virtual wxCanvasObject* Contains( wxCanvasObject* obj );
|
||||
|
||||
//recursive calls for contained objects to set eventhandlers,
|
||||
//and also sets its own eventhandler
|
||||
void PushEventHandler( wxEvtHandler *handler );
|
||||
//recursive calls for contained objects to set eventhandlers,
|
||||
//and also sets its own eventhandler
|
||||
wxEvtHandler *PopEventHandler( bool deleteHandler = FALSE );
|
||||
//recursive calls for contained objects to set eventhandlers,
|
||||
//and also sets its own eventhandler
|
||||
void AppendEventHandler(wxEvtHandler *handler);
|
||||
//recursive calls for contained objects to set eventhandlers,
|
||||
//and also sets its own eventhandler
|
||||
wxEvtHandler *RemoveLastEventHandler(bool deleteHandler);
|
||||
|
||||
protected:
|
||||
|
||||
//to position the object
|
||||
wxTransformMatrix lworld;
|
||||
|
||||
//reference to another wxCanvasObject
|
||||
wxCanvasObject* m_obj;
|
||||
};
|
||||
|
||||
//:defenition
|
||||
// wxCanvasRect
|
||||
class wxCanvasRect: public wxCanvasObject
|
||||
{
|
||||
public:
|
||||
wxCanvasRect( double x, double y, double w, double h , double radius=0 );
|
||||
void SetBrush( const wxBrush& brush) { m_brush = brush; };
|
||||
void SetPen( const wxPen& pen) { m_pen = pen; CalcBoundingBox(); };
|
||||
|
||||
double GetPosX() { return m_x; }
|
||||
double GetPosY() { return m_y; }
|
||||
void SetPosXY( double x, double y) {m_x=x; m_y=y; CalcBoundingBox();};
|
||||
|
||||
void TransLate( double x, double y );
|
||||
void CalcBoundingBox();
|
||||
|
||||
virtual void Render(wxTransformMatrix* cworld, int clip_x, int clip_y, int clip_width, int clip_height );
|
||||
virtual void WriteSVG( wxTextOutputStream &stream );
|
||||
|
||||
private:
|
||||
wxPen m_pen;
|
||||
wxBrush m_brush;
|
||||
|
||||
double m_x;
|
||||
double m_y;
|
||||
double m_width;
|
||||
double m_height;
|
||||
double m_radius;
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// wxCanvasCircle
|
||||
//----------------------------------------------------------------------------
|
||||
class wxCanvasCircle: public wxCanvasObject
|
||||
{
|
||||
public:
|
||||
wxCanvasCircle( double x, double y, double radius );
|
||||
void SetBrush( const wxBrush& brush) { m_brush = brush; };
|
||||
void SetPen( const wxPen& pen) { m_pen = pen; CalcBoundingBox(); };
|
||||
|
||||
double GetPosX() { return m_x; }
|
||||
double GetPosY() { return m_y; }
|
||||
void SetPosXY( double x, double y) {m_x=x; m_y=y;CalcBoundingBox(); };
|
||||
|
||||
void TransLate( double x, double y );
|
||||
|
||||
void CalcBoundingBox();
|
||||
|
||||
virtual void Render(wxTransformMatrix* cworld, int clip_x, int clip_y, int clip_width, int clip_height );
|
||||
virtual void WriteSVG( wxTextOutputStream &stream );
|
||||
|
||||
wxCanvasObject* IsHitWorld( double x, double y, double margin = 0 );
|
||||
|
||||
private:
|
||||
wxPen m_pen;
|
||||
wxBrush m_brush;
|
||||
|
||||
double m_x;
|
||||
double m_y;
|
||||
double m_radius;
|
||||
};
|
||||
|
||||
//:defenition
|
||||
// wxCanvasEllipse
|
||||
class wxCanvasEllipse: public wxCanvasObject
|
||||
{
|
||||
public:
|
||||
wxCanvasEllipse( double x, double y, double width, double height );
|
||||
void SetBrush( const wxBrush& brush) { m_brush = brush; };
|
||||
void SetPen( const wxPen& pen) { m_pen = pen; CalcBoundingBox(); };
|
||||
|
||||
double GetPosX() { return m_x; }
|
||||
double GetPosY() { return m_y; }
|
||||
void SetPosXY( double x, double y) {m_x=x; m_y=y; CalcBoundingBox();};
|
||||
|
||||
void TransLate( double x, double y );
|
||||
|
||||
void CalcBoundingBox();
|
||||
|
||||
virtual void Render(wxTransformMatrix* cworld, int clip_x, int clip_y, int clip_width, int clip_height );
|
||||
virtual void WriteSVG( wxTextOutputStream &stream );
|
||||
|
||||
wxCanvasObject* IsHitWorld( double x, double y, double margin = 0 );
|
||||
|
||||
private:
|
||||
wxPen m_pen;
|
||||
wxBrush m_brush;
|
||||
|
||||
double m_x;
|
||||
double m_y;
|
||||
double m_width;
|
||||
double m_height;
|
||||
};
|
||||
|
||||
//:defenition
|
||||
// wxCanvasEllipticArc
|
||||
class wxCanvasEllipticArc: public wxCanvasObject
|
||||
{
|
||||
public:
|
||||
wxCanvasEllipticArc( double x, double y, double width, double height, double start, double end );
|
||||
void SetBrush( const wxBrush& brush) { m_brush = brush; };
|
||||
void SetPen( const wxPen& pen) { m_pen = pen; CalcBoundingBox(); };
|
||||
|
||||
double GetPosX() { return m_x; }
|
||||
double GetPosY() { return m_y; }
|
||||
void SetPosXY( double x, double y) {m_x=x; m_y=y; CalcBoundingBox();};
|
||||
|
||||
void TransLate( double x, double y );
|
||||
void CalcBoundingBox();
|
||||
|
||||
virtual void Render(wxTransformMatrix* cworld, int clip_x, int clip_y, int clip_width, int clip_height );
|
||||
virtual void WriteSVG( wxTextOutputStream &stream );
|
||||
|
||||
wxCanvasObject* IsHitWorld( double x, double y, double margin = 0 );
|
||||
|
||||
private:
|
||||
wxPen m_pen;
|
||||
wxBrush m_brush;
|
||||
|
||||
double m_x;
|
||||
double m_y;
|
||||
double m_width;
|
||||
double m_height;
|
||||
double m_start;
|
||||
double m_end;
|
||||
};
|
||||
|
||||
//:defenition
|
||||
// wxCanvasLine
|
||||
class wxCanvasLine: public wxCanvasObject
|
||||
{
|
||||
public:
|
||||
wxCanvasLine( double x1, double y1, double x2, double y2 );
|
||||
void SetPen( const wxPen& pen) { m_pen = pen; CalcBoundingBox(); };
|
||||
|
||||
|
||||
double GetPosX() { return m_x1; }
|
||||
double GetPosY() { return m_y1; }
|
||||
void SetPosXY( double x, double y) {m_x1=x; m_y1=y; CalcBoundingBox();};
|
||||
|
||||
void TransLate( double x, double y );
|
||||
|
||||
void CalcBoundingBox();
|
||||
|
||||
virtual void Render(wxTransformMatrix* cworld, int clip_x, int clip_y, int clip_width, int clip_height );
|
||||
virtual void WriteSVG( wxTextOutputStream &stream );
|
||||
|
||||
wxCanvasObject* IsHitWorld( double x, double y, double margin = 0 );
|
||||
|
||||
private:
|
||||
wxPen m_pen;
|
||||
|
||||
double m_x1;
|
||||
double m_y1;
|
||||
double m_x2;
|
||||
double m_y2;
|
||||
};
|
||||
|
||||
//:defenition
|
||||
// wxCanvasImage
|
||||
class wxCanvasImage: public wxCanvasObject
|
||||
{
|
||||
public:
|
||||
wxCanvasImage( const wxImage &image, double x, double y, double w, double h );
|
||||
|
||||
double GetPosX() { return m_x; }
|
||||
double GetPosY() { return m_y; }
|
||||
void SetPosXY( double x, double y);
|
||||
|
||||
void TransLate( double x, double y );
|
||||
|
||||
void CalcBoundingBox();
|
||||
|
||||
virtual void Render(wxTransformMatrix* cworld, int clip_x, int clip_y, int clip_width, int clip_height );
|
||||
virtual void WriteSVG( wxTextOutputStream &stream );
|
||||
|
||||
private:
|
||||
double m_x;
|
||||
double m_y;
|
||||
double m_width;
|
||||
double m_height;
|
||||
|
||||
wxImage m_image;
|
||||
int m_orgw,m_orgh;
|
||||
|
||||
// cache
|
||||
wxBitmap m_cBitmap;
|
||||
wxImage m_cImage;
|
||||
int m_cW;
|
||||
int m_cH;
|
||||
double m_cR;
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// wxCanvasControl
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
class wxCanvasControl: public wxCanvasObject
|
||||
{
|
||||
public:
|
||||
wxCanvasControl( wxWindow *control );
|
||||
~wxCanvasControl();
|
||||
|
||||
double GetPosX();
|
||||
double GetPosY();
|
||||
void SetPosXY( double x, double y);
|
||||
|
||||
void TransLate( double x, double y );
|
||||
void MoveRelative( double x, double y );
|
||||
|
||||
void CalcBoundingBox();
|
||||
|
||||
private:
|
||||
wxWindow *m_control;
|
||||
};
|
||||
|
||||
//:defenition
|
||||
// wxCanvasText
|
||||
class wxCanvasText: public wxCanvasObject
|
||||
{
|
||||
public:
|
||||
wxCanvasText( const wxString &text, double x, double y, const wxString &foneFile, int size );
|
||||
~wxCanvasText();
|
||||
|
||||
double GetPosX() { return m_x; }
|
||||
double GetPosY() { return m_y; }
|
||||
void SetPosXY( double x, double y) {m_x=x; m_y=y;CalcBoundingBox(); };
|
||||
|
||||
void TransLate( double x, double y );
|
||||
|
||||
void CalcBoundingBox();
|
||||
|
||||
virtual void Render(wxTransformMatrix* cworld, int clip_x, int clip_y, int clip_width, int clip_height );
|
||||
virtual void WriteSVG( wxTextOutputStream &stream );
|
||||
|
||||
void SetRGB( unsigned char red, unsigned char green, unsigned char blue );
|
||||
void SetFlag( int flag );
|
||||
int GetFlag() { return m_flag; }
|
||||
|
||||
private:
|
||||
wxString m_text;
|
||||
double m_x;
|
||||
double m_y;
|
||||
unsigned char *m_alpha;
|
||||
void *m_faceData;
|
||||
int m_flag;
|
||||
int m_red;
|
||||
int m_green;
|
||||
int m_blue;
|
||||
wxString m_fontFileName;
|
||||
int m_size;
|
||||
};
|
||||
|
||||
//:defenition
|
||||
// wxCanvas is used to display a wxCanvasGroupObject, which contains wxCanvasObject derived
|
||||
// drawable objects. The group to draw is called the root.
|
||||
// All objects are defined in world coordinates, relative to its parent (e.g. nested groups)
|
||||
// There are methods to convert from world to device coordinates and visa versa.
|
||||
// Rendering a draw is normally started on the root, it to a buffer, afterwords
|
||||
// an update of the damaged parts will blitted from the buffer to the screen.
|
||||
// This is done in Idle time, but can also be forced.
|
||||
// World coordinates can be with the Y axis going up are down.
|
||||
// The area of the drawing in world coordinates that is visible on the canvas
|
||||
// can be set. Parts of this area can be zoomed into resulting in scroll bars
|
||||
// to be displayed.
|
||||
class wxCanvas: public wxScrolledWindow
|
||||
{
|
||||
public:
|
||||
// constructors and destructors
|
||||
wxCanvas( wxCanvasAdmin* admin ,wxWindow *parent, wxWindowID id = -1,
|
||||
const wxPoint& pos = wxDefaultPosition,
|
||||
const wxSize& size = wxDefaultSize,
|
||||
long style = wxScrolledWindowStyle );
|
||||
virtual ~wxCanvas();
|
||||
|
||||
//background colour for the canvas
|
||||
virtual void SetColour( const wxColour& background );
|
||||
|
||||
//update the area given in device coordinates
|
||||
virtual void Update( int x, int y, int width, int height, bool blit = TRUE );
|
||||
|
||||
//blit all updated areas now to the screen, else it will happen in idle time.
|
||||
//Use this to support dragging for instance, becuase in such cases idle time
|
||||
//will take to long.
|
||||
virtual void UpdateNow();
|
||||
|
||||
//prevent canvas activety
|
||||
virtual void Freeze();
|
||||
//allow canvas activety
|
||||
virtual void Thaw();
|
||||
|
||||
//get the buffer that is used for rendering in general
|
||||
inline wxBitmap *GetBuffer() { return &m_buffer; }
|
||||
//get the DC that is used for rendering
|
||||
inline wxDC *GetDC() { return m_renderDC; }
|
||||
//set the DC that is used for rendering
|
||||
inline void SetDC(wxDC* dc) { m_renderDC=dc; }
|
||||
|
||||
inline int GetBufferWidth() { return m_buffer.GetWidth(); }
|
||||
inline int GetBufferHeight() { return m_buffer.GetHeight(); }
|
||||
|
||||
//updating is needed for the canvas if the buffer did change
|
||||
bool NeedUpdate() { return m_needUpdate; }
|
||||
bool IsFrozen() { return m_frozen; }
|
||||
|
||||
//blit damaged areas in the buffer to the screen
|
||||
void BlitBuffer( wxDC &dc );
|
||||
|
||||
//redirect events to this canvas object
|
||||
void SetCaptureMouse( wxCanvasObject *obj );
|
||||
//are events redirected, if so return the object else NULL
|
||||
inline wxCanvasObject* GetCaptured() { return m_captureMouse;}
|
||||
|
||||
//set the root group where the objects for this canvas are stored
|
||||
void SetRoot(wxCanvasObjectGroup* aroot){m_root=aroot;}
|
||||
|
||||
//get root group that is displayed on the canvas
|
||||
wxCanvasObjectGroup* GetRoot(){return m_root;}
|
||||
|
||||
//scroll the window in device coordinates
|
||||
virtual void ScrollWindow( int dx, int dy,
|
||||
const wxRect* rect = (wxRect *) NULL );
|
||||
|
||||
//get y axis orientation
|
||||
virtual bool GetYaxis() { return FALSE; }
|
||||
|
||||
//get the visible part in world coordinates
|
||||
virtual double GetMinX() const;
|
||||
virtual double GetMinY() const;
|
||||
virtual double GetMaxX() const;
|
||||
virtual double GetMaxY() const;
|
||||
|
||||
//convert from window to virtual coordinates
|
||||
virtual double DeviceToLogicalX(int x) const;
|
||||
virtual double DeviceToLogicalY(int y) const;
|
||||
virtual double DeviceToLogicalXRel(int x) const;
|
||||
virtual double DeviceToLogicalYRel(int y) const;
|
||||
virtual int LogicalToDeviceX(double x) const;
|
||||
virtual int LogicalToDeviceY(double y) const;
|
||||
virtual int LogicalToDeviceXRel(double x) const;
|
||||
virtual int LogicalToDeviceYRel(double y) const;
|
||||
|
||||
protected:
|
||||
wxBitmap m_buffer;
|
||||
|
||||
//always available and m_buffer selected
|
||||
wxDC* m_renderDC;
|
||||
|
||||
bool m_needUpdate;
|
||||
wxList m_updateRects;
|
||||
wxCanvasObjectGroup* m_root;
|
||||
|
||||
wxColour m_background;
|
||||
bool m_frozen;
|
||||
wxCanvasObject *m_lastMouse;
|
||||
wxCanvasObject *m_captureMouse;
|
||||
|
||||
int m_oldDeviceX,m_oldDeviceY;
|
||||
|
||||
wxCanvasAdmin* m_admin;
|
||||
|
||||
private:
|
||||
int m_bufferX,m_bufferY;
|
||||
|
||||
protected:
|
||||
void OnMouse( wxMouseEvent &event );
|
||||
void OnPaint( wxPaintEvent &event );
|
||||
void OnSize( wxSizeEvent &event );
|
||||
void OnIdle( wxIdleEvent &event );
|
||||
void OnSetFocus( wxFocusEvent &event );
|
||||
void OnKillFocus( wxFocusEvent &event );
|
||||
void OnEraseBackground( wxEraseEvent &event );
|
||||
|
||||
private:
|
||||
DECLARE_CLASS(wxCanvas)
|
||||
DECLARE_EVENT_TABLE()
|
||||
};
|
||||
|
||||
|
||||
|
||||
class wxVectorCanvas: public wxCanvas
|
||||
{
|
||||
public:
|
||||
// constructors and destructors
|
||||
wxVectorCanvas( wxCanvasAdmin* admin ,wxWindow *parent, wxWindowID id = -1,
|
||||
const wxPoint& pos = wxDefaultPosition,
|
||||
const wxSize& size = wxDefaultSize,
|
||||
long style = wxScrolledWindowStyle );
|
||||
|
||||
//scroll the window in device coordinates
|
||||
virtual void ScrollWindow( int dx, int dy,
|
||||
const wxRect* rect = (wxRect *) NULL );
|
||||
|
||||
//set if the Yaxis goes up or down
|
||||
void SetYaxis(bool up) { m_yaxis=up; }
|
||||
|
||||
//get currently used Yaxis setting
|
||||
virtual bool GetYaxis() { return m_yaxis; }
|
||||
|
||||
//to set the total area in world coordinates that can be scrolled.
|
||||
// when totaly zoomed out (SetMappingScroll same size as given here),
|
||||
// this will be the area displayed.
|
||||
// To display all of a drawing, set this here to the boundingbox of the root group
|
||||
// of the canvas.
|
||||
void SetScroll(double vx1,double vy1,double vx2,double vy2);
|
||||
|
||||
//given the virtual size to be displayed, the mappingmatrix will be calculated
|
||||
//in such a manner that it fits (same ratio in width and height) to the window size.
|
||||
//The window size is used to intitialize the mapping.
|
||||
//The virtual size is just an indication, it will be ajusted to fit in the client window ratio.
|
||||
//When border is set an extra margin is added so that the drawing will fit nicely.
|
||||
// To display all of a drawing, set this here to the boundingbox of the root group
|
||||
// of the canvas.
|
||||
void SetMappingScroll(double vx1,double vy1,double vx2,double vy2,bool border);
|
||||
|
||||
//matrix for calculating the virtual coordinate given a screen coordinate
|
||||
wxTransformMatrix GetInverseMappingMatrix();
|
||||
|
||||
//matrix for calculating the screen coordinate given a virtual coordinate
|
||||
wxTransformMatrix GetMappingMatrix();
|
||||
|
||||
//get minimum X of the visible part in world coordinates
|
||||
virtual double GetMinX() const;
|
||||
virtual double GetMinY() const;
|
||||
virtual double GetMaxX() const;
|
||||
virtual double GetMaxY() const;
|
||||
|
||||
//convert from window to virtual coordinates and back
|
||||
virtual double DeviceToLogicalX(int x) const;
|
||||
virtual double DeviceToLogicalY(int y) const;
|
||||
virtual double DeviceToLogicalXRel(int x) const;
|
||||
virtual double DeviceToLogicalYRel(int y) const;
|
||||
virtual int LogicalToDeviceX(double x) const;
|
||||
virtual int LogicalToDeviceY(double y) const;
|
||||
virtual int LogicalToDeviceXRel(double x) const;
|
||||
virtual int LogicalToDeviceYRel(double y) const;
|
||||
|
||||
protected:
|
||||
// up or down
|
||||
bool m_yaxis;
|
||||
|
||||
// holds the matrix for mapping from virtual to screen coordinates
|
||||
wxTransformMatrix m_mapping_matrix;
|
||||
|
||||
// holds the inverse of the mapping matrix
|
||||
wxTransformMatrix m_inverse_mapping;
|
||||
|
||||
//virtual coordinates of total drawing
|
||||
double m_virtm_minX, m_virtm_minY, m_virtm_maxX, m_virtm_maxY;
|
||||
|
||||
// virtual coordinates box
|
||||
double m_virt_minX, m_virt_minY, m_virt_maxX, m_virt_maxY;
|
||||
|
||||
// bounding box
|
||||
double m_minX, m_minY, m_maxX, m_maxY;
|
||||
|
||||
//are scroll bars active?
|
||||
bool m_scrolled;
|
||||
|
||||
private:
|
||||
void OnScroll(wxScrollWinEvent& event);
|
||||
void OnChar( wxKeyEvent &event );
|
||||
void OnSize( wxSizeEvent &event );
|
||||
|
||||
private:
|
||||
DECLARE_CLASS(wxVectorCanvas)
|
||||
DECLARE_EVENT_TABLE()
|
||||
};
|
||||
|
||||
|
||||
|
||||
//:defenition
|
||||
//Contains a list of wxCanvas Objects that will be maintained through this class.
|
||||
//Each wxCanvasObject can be displayed on several wxCanvas Objects at the same time.
|
||||
//The active wxCanvas is used to render and convert coordinates from world to device.
|
||||
//So it is important to set the active wxCanvas based on the wxCanvas that has the focus
|
||||
//or is scrolled etc. This is normally done within wxCanvas when appropriate.
|
||||
class wxCanvasAdmin
|
||||
{
|
||||
public:
|
||||
// constructors and destructors
|
||||
wxCanvasAdmin();
|
||||
virtual ~wxCanvasAdmin();
|
||||
|
||||
//convert from window to virtual coordinates
|
||||
double DeviceToLogicalX(int x) const;
|
||||
//convert from window to virtual coordinates
|
||||
double DeviceToLogicalY(int y) const;
|
||||
//convert from window to virtual coordinates relatif
|
||||
double DeviceToLogicalXRel(int x) const;
|
||||
//convert from window to virtual coordinates relatif
|
||||
double DeviceToLogicalYRel(int y) const;
|
||||
//convert from virtual to window coordinates
|
||||
int LogicalToDeviceX(double x) const;
|
||||
//convert from virtual to window coordinates
|
||||
int LogicalToDeviceY(double y) const;
|
||||
//convert from virtual to window coordinates relatif
|
||||
int LogicalToDeviceXRel(double x) const;
|
||||
//convert from virtual to window coordinates relatif
|
||||
int LogicalToDeviceYRel(double y) const;
|
||||
|
||||
//update in the buffer off all canvases, the area given in world coordinates
|
||||
virtual void Update(wxCanvasObject* obj, double x, double y, double width, double height);
|
||||
|
||||
//blit all updated areas now to the screen, else it will happen in idle time.
|
||||
//Use this to support dragging for instance, becuase in such cases idle time
|
||||
//will take to long.
|
||||
virtual void UpdateNow();
|
||||
|
||||
//append another canvas
|
||||
virtual void Append( wxCanvas* canvas );
|
||||
|
||||
//remove a canvas
|
||||
virtual void Remove( wxCanvas* canvas );
|
||||
|
||||
//set the given canvas as active (for rendering, coordinate conversion etc.)
|
||||
void SetActive(wxCanvas* activate);
|
||||
|
||||
//get active canvas
|
||||
inline wxCanvas* GetActive() {return m_active;};
|
||||
|
||||
private:
|
||||
wxList m_canvaslist;
|
||||
wxCanvas* m_active;
|
||||
};
|
||||
|
||||
#endif
|
||||
// WXCANVAS
|
||||
|
@@ -1,58 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: liner.h
|
||||
// Author: Klaas Holwerda
|
||||
// Created: 1/10/2000
|
||||
// Copyright: 2000 (c) Klaas Holwerda
|
||||
// Licence: wxWindows Licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
#ifndef __WXLINER_H
|
||||
#define __WXLINER_H
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "liner.cpp"
|
||||
#endif
|
||||
|
||||
|
||||
#include "wx/geometry.h"
|
||||
|
||||
enum OUTPRODUCT {R_IS_LEFT,R_IS_ON,R_IS_RIGHT};
|
||||
|
||||
// Status of a point to a wxLine
|
||||
enum R_PointStatus {R_LEFT_SIDE, R_RIGHT_SIDE, R_ON_AREA, R_IN_AREA};
|
||||
|
||||
class wxLine
|
||||
{
|
||||
public:
|
||||
// constructors and destructor
|
||||
wxLine( double x1, double y1, double x2, double y2 );
|
||||
wxLine( const wxPoint2DDouble& a, const wxPoint2DDouble& b);
|
||||
~wxLine();
|
||||
|
||||
wxPoint2DDouble GetBeginPoint(); // Get the beginpoint from a wxLine
|
||||
wxPoint2DDouble GetEndPoint(); // Get the endpoint from a wxLine
|
||||
bool CheckIntersect( wxLine&, double Marge); // Check if two wxLines intersects
|
||||
int Intersect( wxLine&, wxPoint2DDouble& bp ,wxPoint2DDouble& ep ,double Marge) ; // Intersects two wxLines
|
||||
bool Intersect( wxLine& lijn, wxPoint2DDouble& crossing); //intersect two (infinit) lines
|
||||
R_PointStatus PointOnLine( const wxPoint2DDouble& a_Point, double& Distance, double Marge ); //For an infinite wxLine
|
||||
R_PointStatus PointInLine( const wxPoint2DDouble& a_Point, double& Distance, double Marge ); //For a non-infinite wxLine
|
||||
OUTPRODUCT OutProduct( const wxLine& two, double accur); // outproduct of two wxLines
|
||||
double Calculate_Y( double X); // Caclulate Y if X is known
|
||||
void Virtual_Point( wxPoint2DDouble& a_point, double distance) const;
|
||||
wxLine& operator=( const wxLine&); // assignment operator
|
||||
void CalculateLineParameters(); // Calculate the parameters if nessecary
|
||||
void OffsetContour( const wxLine& nextline, double factor,wxPoint2DDouble& offsetpoint) const;
|
||||
|
||||
private:
|
||||
|
||||
int ActionOnTable1(R_PointStatus,R_PointStatus); // Function needed for Intersect
|
||||
int ActionOnTable2(R_PointStatus,R_PointStatus); // Function needed for Intersect
|
||||
|
||||
double m_AA;
|
||||
double m_BB;
|
||||
double m_CC;
|
||||
wxPoint2DDouble m_a;
|
||||
wxPoint2DDouble m_b;
|
||||
bool m_valid_parameters;
|
||||
};
|
||||
|
||||
#endif
|
@@ -1,220 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: polygon.h
|
||||
// Author: Klaas Holwerda
|
||||
// Created: XX/XX/XX
|
||||
// Copyright: 2000 (c) Klaas Holwerda
|
||||
// Licence: wxWindows Licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef __WXPOLYGON_H__
|
||||
#define __WXPOLYGON_H__
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "polygon.cpp"
|
||||
#endif
|
||||
|
||||
#ifndef WX_PRECOMP
|
||||
#include "wx/wx.h"
|
||||
#endif
|
||||
|
||||
#include "wx/matrix.h"
|
||||
#include "wx/geometry.h"
|
||||
#include "bbox.h"
|
||||
#include "canvas.h"
|
||||
|
||||
enum INOUTPOLY {OUTSIDE_POLY,INSIDE_POLY,ON_POLY};
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// wxCanvasPolygon
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
class wxCanvasPolygon: public wxCanvasObject
|
||||
{
|
||||
public:
|
||||
wxCanvasPolygon( int n, wxPoint2DDouble points[], bool spline = FALSE );
|
||||
~wxCanvasPolygon();
|
||||
void SetBrush( const wxBrush& brush) { m_brush = brush; }
|
||||
void SetPen( const wxPen& pen) { m_pen = pen; CalcBoundingBox(); }
|
||||
|
||||
//set colour 1
|
||||
//being the background color if filling with a monochrome bitmap
|
||||
//or in case of gradient filling the starting colour for the fill
|
||||
void SetColour1( const wxColour& fg) { m_textfg=fg;}
|
||||
//set colour 1
|
||||
//being the foreground color if filling with a monochrome bitmap
|
||||
//or in case of gradient filling the ending colour for the fill
|
||||
void SetColour2( const wxColour& bg) { m_textbg=bg;}
|
||||
//transparent filling when bitmapbrush is monochrome
|
||||
void SetTransParent(bool transp) { m_transp=transp;}
|
||||
//gradient filling using lines chnging in colour from colour1 to colour2
|
||||
void SetGradient(bool gradient, const wxPen& gpen, double distance)
|
||||
{ m_gradient=gradient;
|
||||
m_gpen=gpen;
|
||||
m_gdistance=distance;
|
||||
}
|
||||
|
||||
double GetPosX() { return m_points[0].m_x; }
|
||||
double GetPosY() { return m_points[0].m_y; }
|
||||
void SetPosXY( double x, double y);
|
||||
|
||||
void TransLate( double x, double y );
|
||||
void CalcBoundingBox();
|
||||
|
||||
virtual void Render(wxTransformMatrix* cworld, int clip_x, int clip_y, int clip_width, int clip_height );
|
||||
virtual void WriteSVG( wxTextOutputStream &stream );
|
||||
|
||||
wxCanvasObject* IsHitWorld( double x, double y, double margin = 0 );
|
||||
|
||||
INOUTPOLY PointInPolygon(const wxPoint2DDouble& P, double marge);
|
||||
|
||||
private:
|
||||
|
||||
bool MoveUp(double horline, int& index, int direction);
|
||||
void DetectCriticalPoints();
|
||||
void FillPolygon(wxTransformMatrix* cworld, int clip_x, int clip_y, int clip_width, int clip_height );
|
||||
wxList m_CRlist;
|
||||
wxList m_AETlist;
|
||||
|
||||
|
||||
wxBrush m_brush;
|
||||
wxPen m_pen;
|
||||
wxColour m_textbg;
|
||||
wxColour m_textfg;
|
||||
|
||||
//if brush is of type bitmap with a mask fill with mask transparent
|
||||
bool m_transp;
|
||||
bool m_gradient;
|
||||
wxPen m_gpen;
|
||||
double m_gdistance;
|
||||
|
||||
bool m_spline;
|
||||
|
||||
int m_n;
|
||||
wxPoint2DDouble* m_points;
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// wxCanvasPolyline
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
class wxCanvasPolyline: public wxCanvasObject
|
||||
{
|
||||
public:
|
||||
wxCanvasPolyline(int n, wxPoint2DDouble points[]);
|
||||
~wxCanvasPolyline();
|
||||
void SetPen( const wxPen& pen) { m_pen = pen; CalcBoundingBox(); }
|
||||
|
||||
double GetPosX() { return m_points[0].m_x; }
|
||||
double GetPosY() { return m_points[0].m_y; }
|
||||
void SetPosXY( double x, double y);
|
||||
|
||||
void TransLate( double x, double y );
|
||||
void CalcBoundingBox();
|
||||
|
||||
virtual void Render(wxTransformMatrix* cworld, int clip_x, int clip_y, int clip_width, int clip_height );
|
||||
virtual void WriteSVG( wxTextOutputStream &stream );
|
||||
|
||||
wxCanvasObject* IsHitWorld( double x, double y, double margin = 0 );
|
||||
|
||||
bool PointOnPolyline(const wxPoint2DDouble& P, double marge);
|
||||
|
||||
private:
|
||||
|
||||
wxPen m_pen;
|
||||
|
||||
int m_n;
|
||||
wxPoint2DDouble* m_points;
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// wxCanvasPolygon
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
class wxCanvasPolygonL: public wxCanvasObject
|
||||
{
|
||||
public:
|
||||
wxCanvasPolygonL(wxList* points, bool spline = FALSE);
|
||||
~wxCanvasPolygonL();
|
||||
void SetBrush( const wxBrush& brush) { m_brush = brush; }
|
||||
void SetPen( const wxPen& pen) { m_pen = pen; CalcBoundingBox(); }
|
||||
void SetColour1( const wxColour& fg) { m_textfg=fg;}
|
||||
void SetColour2( const wxColour& bg) { m_textbg=bg;}
|
||||
void SetTransParent(bool transp) { m_transp=transp;}
|
||||
|
||||
double GetPosX();
|
||||
double GetPosY();
|
||||
void SetPosXY( double x, double y);
|
||||
void TransLate( double x, double y );
|
||||
void CalcBoundingBox();
|
||||
|
||||
virtual void Render(wxTransformMatrix* cworld, int clip_x, int clip_y, int clip_width, int clip_height );
|
||||
virtual void WriteSVG( wxTextOutputStream &stream );
|
||||
|
||||
wxCanvasObject* IsHitWorld( double x, double y, double margin = 0 );
|
||||
|
||||
INOUTPOLY PointInPolygon(const wxPoint2DDouble& P, double marge);
|
||||
|
||||
private:
|
||||
|
||||
wxBrush m_brush;
|
||||
wxPen m_pen;
|
||||
bool m_spline;
|
||||
wxColour m_textbg;
|
||||
wxColour m_textfg;
|
||||
//if brush is of type bitmap with a mask fill with mask transparent
|
||||
bool m_transp;
|
||||
|
||||
wxList* m_lpoints;
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// wxCanvasPolyline
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
class wxCanvasPolylineL: public wxCanvasObject
|
||||
{
|
||||
public:
|
||||
wxCanvasPolylineL(wxList* points, bool spline );
|
||||
~wxCanvasPolylineL();
|
||||
void SetPen( const wxPen& pen) { m_pen = pen; CalcBoundingBox(); }
|
||||
|
||||
double GetPosX();
|
||||
double GetPosY();
|
||||
void SetPosXY( double x, double y);
|
||||
|
||||
void TransLate( double x, double y );
|
||||
void CalcBoundingBox();
|
||||
|
||||
virtual void Render(wxTransformMatrix* cworld, int clip_x, int clip_y, int clip_width, int clip_height );
|
||||
virtual void WriteSVG( wxTextOutputStream &stream );
|
||||
|
||||
wxCanvasObject* IsHitWorld( double x, double y, double margin = 0 );
|
||||
|
||||
bool PointOnPolyline(const wxPoint2DDouble& P, double marge);
|
||||
|
||||
private:
|
||||
wxPen m_pen;
|
||||
bool m_spline;
|
||||
|
||||
wxList* m_lpoints;
|
||||
};
|
||||
|
||||
//active edge table
|
||||
class wxAET
|
||||
{
|
||||
public:
|
||||
inline void CalculateLineParameters( const wxPoint2DDouble& p1 , const wxPoint2DDouble& p2 );
|
||||
inline void CalculateXs( double y );
|
||||
|
||||
//line paramters
|
||||
bool m_horizontal;
|
||||
double m_BdivA;
|
||||
double m_CdivA;
|
||||
int m_index;
|
||||
int m_direction;
|
||||
//intersection point with scanline;
|
||||
double m_xs;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
File diff suppressed because it is too large
Load Diff
@@ -1,204 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: No names yet.
|
||||
// Purpose: Contrib. demo
|
||||
// Author: Aleksandras Gluchovas
|
||||
// Modified by:
|
||||
// Created: ??/10/98
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) Aleksandras Gluchovas
|
||||
// Licence: wxWindows license
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef __DYNTBAR_G__
|
||||
#define __DYNTBAR_G__
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "dyntbar.h"
|
||||
#endif
|
||||
|
||||
#include "wx/tbarbase.h"
|
||||
#include "wx/dynarray.h"
|
||||
|
||||
// layout item
|
||||
|
||||
class wxToolLayoutItem : public wxObject
|
||||
{
|
||||
public:
|
||||
wxRect mRect;
|
||||
bool mIsSeparator;
|
||||
};
|
||||
|
||||
class wxDynToolInfo;
|
||||
|
||||
typedef wxToolLayoutItem* wxToolLayoutItemPtrT;
|
||||
typedef wxDynToolInfo* wxDynToolInfoPtrT;
|
||||
|
||||
|
||||
WX_DEFINE_ARRAY( wxToolLayoutItemPtrT, wxLayoutItemArrayT );
|
||||
WX_DEFINE_ARRAY( wxDynToolInfoPtrT, wxDynToolInfoArrayT );
|
||||
|
||||
// base class for layouting algorithm implementations
|
||||
|
||||
class LayoutManagerBase
|
||||
{
|
||||
public:
|
||||
virtual void Layout( const wxSize& parentDim,
|
||||
wxSize& resultingDim,
|
||||
wxLayoutItemArrayT& items,
|
||||
int horizGap,
|
||||
int vertGap ) = 0;
|
||||
|
||||
virtual ~LayoutManagerBase() {}
|
||||
};
|
||||
|
||||
// layouts items in left-to-right order from
|
||||
// top towards bottom
|
||||
|
||||
class BagLayout : public LayoutManagerBase
|
||||
{
|
||||
public:
|
||||
virtual void Layout( const wxSize& parentDim,
|
||||
wxSize& resultingDim,
|
||||
wxLayoutItemArrayT& items,
|
||||
int horizGap,
|
||||
int vertGap );
|
||||
};
|
||||
|
||||
class wxDynToolInfo : public wxToolLayoutItem
|
||||
{
|
||||
DECLARE_DYNAMIC_CLASS(wxDynToolInfo)
|
||||
|
||||
public:
|
||||
wxWindow* mpToolWnd;
|
||||
int mIndex;
|
||||
wxSize mRealSize;
|
||||
};
|
||||
|
||||
// layouting orientations for tools
|
||||
|
||||
#define LO_HORIZONTAL 0
|
||||
#define LO_VERTICAL 1
|
||||
#define LO_FIT_TO_WINDOW 2
|
||||
|
||||
// class manages containment and layouting of tool-windows
|
||||
|
||||
class wxDynamicToolBar : public wxToolBarBase
|
||||
{
|
||||
DECLARE_DYNAMIC_CLASS(wxDynamicToolBar)
|
||||
protected:
|
||||
|
||||
friend class wxDynamicToolBarSerializer;
|
||||
|
||||
wxDynToolInfoArrayT mTools;
|
||||
LayoutManagerBase* mpLayoutMan;
|
||||
|
||||
protected:
|
||||
virtual void SizeToolWindows();
|
||||
|
||||
public: /* public properties */
|
||||
|
||||
int mSepartorSize; // default: 8
|
||||
int mVertGap; // default: 0
|
||||
int mHorizGap; // default: 0
|
||||
|
||||
public:
|
||||
wxDynamicToolBar();
|
||||
|
||||
wxDynamicToolBar(wxWindow *parent, const wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
|
||||
const long style = wxNO_BORDER, const int orientation = wxVERTICAL,
|
||||
const int RowsOrColumns = 1, const wxString& name = wxToolBarNameStr);
|
||||
|
||||
~wxDynamicToolBar(void);
|
||||
|
||||
bool Create(wxWindow *parent, const wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
|
||||
const long style = wxNO_BORDER, const int orientation = wxVERTICAL, const int RowsOrColumns = 1, const wxString& name = wxToolBarNameStr);
|
||||
|
||||
// overridables
|
||||
|
||||
virtual void AddTool( int toolIndex,
|
||||
wxWindow* pToolWindow,
|
||||
const wxSize& size = wxDefaultSize );
|
||||
|
||||
virtual void AddTool( int toolIndex,
|
||||
const wxString& imageFileName,
|
||||
wxBitmapType imageFileType = wxBITMAP_TYPE_BMP,
|
||||
const wxString& labelText = "", bool alignTextRight = FALSE,
|
||||
bool isFlat = TRUE );
|
||||
virtual void AddTool( int toolIndex, wxBitmap labelBmp,
|
||||
const wxString& labelText = "", bool alignTextRight = FALSE,
|
||||
bool isFlat = TRUE );
|
||||
|
||||
// method from wxToolBarBase (for compatibility), only
|
||||
// first two arguments are valid
|
||||
|
||||
virtual wxToolBarToolBase *AddTool(const int toolIndex, const wxBitmap& bitmap, const wxBitmap& pushedBitmap = wxNullBitmap,
|
||||
const bool toggle = FALSE, const long xPos = -1, const long yPos = -1, wxObject *clientData = NULL,
|
||||
const wxString& helpString1 = "", const wxString& helpString2 = "");
|
||||
|
||||
virtual void AddSeparator( wxWindow* pSepartorWnd = NULL );
|
||||
|
||||
wxDynToolInfo* GetToolInfo( int toolIndex );
|
||||
|
||||
void RemveTool( int toolIndex );
|
||||
|
||||
// the default implementation draws shaded line
|
||||
virtual void DrawSeparator( wxDynToolInfo& info, wxDC& dc );
|
||||
|
||||
// see definitions of orientation types
|
||||
virtual bool Layout();
|
||||
|
||||
virtual void GetPreferredDim( const wxSize& givenDim, wxSize& prefDim );
|
||||
|
||||
virtual LayoutManagerBase* CreateDefaulLayout() { return new BagLayout(); }
|
||||
|
||||
virtual void SetLayout( LayoutManagerBase* pLayout );
|
||||
|
||||
virtual void EnableTool(const int toolIndex, const bool enable = TRUE);
|
||||
|
||||
// event handlers
|
||||
|
||||
void OnSize( wxSizeEvent& event );
|
||||
void OnPaint( wxPaintEvent& event );
|
||||
void OnEraseBackground( wxEraseEvent& event );
|
||||
|
||||
// overriden from wxToolBarBase
|
||||
|
||||
virtual bool Realize(void);
|
||||
|
||||
// stuff from the 2.1.15
|
||||
|
||||
virtual wxToolBarToolBase *FindToolForPosition(wxCoord x,
|
||||
wxCoord y) const;
|
||||
|
||||
|
||||
virtual bool DoInsertTool(size_t pos, wxToolBarToolBase *tool);
|
||||
|
||||
// the tool is still in m_tools list when this function is called, it will
|
||||
// only be deleted from it if it succeeds
|
||||
virtual bool DoDeleteTool(size_t pos, wxToolBarToolBase *tool);
|
||||
|
||||
// called when the tools enabled flag changes
|
||||
virtual void DoEnableTool(wxToolBarToolBase *tool, bool enable);
|
||||
|
||||
// called when the tool is toggled
|
||||
virtual void DoToggleTool(wxToolBarToolBase *tool, bool toggle);
|
||||
|
||||
// called when the tools "can be toggled" flag changes
|
||||
virtual void DoSetToggle(wxToolBarToolBase *tool, bool toggle);
|
||||
|
||||
// the functions to create toolbar tools
|
||||
virtual wxToolBarToolBase *CreateTool(int id,
|
||||
const wxBitmap& bitmap1,
|
||||
const wxBitmap& bitmap2,
|
||||
bool toggle,
|
||||
wxObject *clientData,
|
||||
const wxString& shortHelpString,
|
||||
const wxString& longHelpString);
|
||||
virtual wxToolBarToolBase *CreateTool(wxControl *control);
|
||||
|
||||
|
||||
DECLARE_EVENT_TABLE()
|
||||
};
|
||||
|
||||
#endif /* __DYNTBAR_G__ */
|
||||
|
@@ -1,169 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: dynamicsash.h
|
||||
// Purpose: A window which can be dynamically split to an arbitrary depth
|
||||
// and later reunified through the user interface
|
||||
// Author: Matt Kimball
|
||||
// Modified by:
|
||||
// Created: 7/15/2001
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2001 Matt Kimball
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_DYNAMICSASH_H_
|
||||
#define _WX_DYNAMICSASH_H_
|
||||
|
||||
#ifdef GIZMOISDLL
|
||||
#define GIZMODLLEXPORT WXDLLEXPORT
|
||||
#else
|
||||
#define GIZMODLLEXPORT
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
|
||||
wxDynamicSashWindow
|
||||
|
||||
wxDynamicSashWindow widgets manages the way other widgets are viewed.
|
||||
When a wxDynamicSashWindow is first shown, it will contain one child
|
||||
view, a viewport for that child, and a pair of scrollbars to allow the
|
||||
user to navigate the child view area. Next to each scrollbar is a small
|
||||
tab. By clicking on either tab and dragging to the appropriate spot, a
|
||||
user can split the view area into two smaller views separated by a
|
||||
draggable sash. Later, when the user wishes to reunify the two subviews,
|
||||
the user simply drags the sash to the side of the window.
|
||||
wxDynamicSashWindow will automatically reparent the appropriate child
|
||||
view back up the window hierarchy, and the wxDynamicSashWindow will have
|
||||
only one child view once again.
|
||||
|
||||
As an application developer, you will simply create a wxDynamicSashWindow
|
||||
using either the Create() function or the more complex constructor
|
||||
provided below, and then create a view window whose parent is the
|
||||
wxDynamicSashWindow. The child should respond to
|
||||
wxDynamicSashSplitEvents -- perhaps with an OnSplit() event handler -- by
|
||||
constructing a new view window whose parent is also the
|
||||
wxDynamicSashWindow. That's it! Now your users can dynamically split
|
||||
and reunify the view you provided.
|
||||
|
||||
If you wish to handle the scrollbar events for your view, rather than
|
||||
allowing wxDynamicSashWindow to do it for you, things are a bit more
|
||||
complex. (You might want to handle scrollbar events yourself, if,
|
||||
for instance, you wish to scroll a subwindow of the view you add to
|
||||
your wxDynamicSashWindow object, rather than scrolling the whole view.)
|
||||
In this case, you will need to construct your wxDynamicSashWindow without
|
||||
the wxDS_MANAGE_SCROLLBARS style and you will need to use the
|
||||
GetHScrollBar() and GetVScrollBar() methods to retrieve the scrollbar
|
||||
controls and call SetEventHanler() on them to redirect the scrolling
|
||||
events whenever your window is reparented by wxDyanmicSashWindow.
|
||||
You will need to set the scrollbars' event handler at three times:
|
||||
|
||||
* When your view is created
|
||||
* When your view receives a wxDynamicSashSplitEvent
|
||||
* When your view receives a wxDynamicSashUnifyEvent
|
||||
|
||||
See the dynsash_switch sample application for an example which does this.
|
||||
|
||||
*/
|
||||
|
||||
|
||||
#include <wx/event.h>
|
||||
#include <wx/window.h>
|
||||
class wxScrollBar;
|
||||
|
||||
|
||||
#define wxEVT_DYNAMIC_SASH_BASE (((int)('d' - 'a') << 11) | ((int)('s' - 'a') << 6) | ((int)('h' - 'a') << 1))
|
||||
#define wxEVT_DYNAMIC_SASH_SPLIT (wxEVT_DYNAMIC_SASH_BASE + 1)
|
||||
#define wxEVT_DYNAMIC_SASH_UNIFY (wxEVT_DYNAMIC_SASH_BASE + 2)
|
||||
|
||||
#define EVT_DYNAMIC_SASH_SPLIT(id, func) EVT_CUSTOM(wxEVT_DYNAMIC_SASH_SPLIT, (id), (func))
|
||||
#define EVT_DYNAMIC_SASH_UNIFY(id, func) EVT_CUSTOM(wxEVT_DYNAMIC_SASH_UNIFY, (id), (func))
|
||||
|
||||
|
||||
/*
|
||||
wxDS_MANAGE_SCROLLBARS is a default style of wxDynamicSashWindow which
|
||||
will cause it to respond to scrollbar events for your application by
|
||||
automatically scrolling the child view.
|
||||
*/
|
||||
#define wxDS_MANAGE_SCROLLBARS 0x0010
|
||||
|
||||
|
||||
/*
|
||||
wxDS_DRAG_CORNER style indicates that the views can also be resized by
|
||||
dragging the corner piece between the scrollbars, and which is reflected up
|
||||
to the frame if necessary.
|
||||
*/
|
||||
#define wxDS_DRAG_CORNER 0x0020
|
||||
|
||||
|
||||
/*
|
||||
wxDynamicSashSplitEvents are sent to your view by wxDynamicSashWindow
|
||||
whenever your view is being split by the user. It is your
|
||||
responsibility to handle this event by creating a new view window as
|
||||
a child of the wxDynamicSashWindow. wxDynamicSashWindow will
|
||||
automatically reparent it to the proper place in its window hierarchy.
|
||||
*/
|
||||
class GIZMODLLEXPORT wxDynamicSashSplitEvent : public wxCommandEvent {
|
||||
public:
|
||||
wxDynamicSashSplitEvent();
|
||||
wxDynamicSashSplitEvent(const wxDynamicSashSplitEvent& event): wxCommandEvent(event) { }
|
||||
wxDynamicSashSplitEvent(wxObject *target);
|
||||
|
||||
virtual wxEvent* Clone() const { return new wxDynamicSashSplitEvent(*this); }
|
||||
|
||||
private:
|
||||
DECLARE_DYNAMIC_CLASS(wxDynamicSashSplitEvent)
|
||||
};
|
||||
|
||||
/*
|
||||
wxDynamicSashUnifyEvents are sent to your view by wxDynamicSashWindow
|
||||
whenever the sash which splits your view and its sibling is being
|
||||
reunified such that your view is expanding to replace its sibling.
|
||||
You needn't do anything with this event if you are allowing
|
||||
wxDynamicSashWindow to manage your view's scrollbars, but it is useful
|
||||
if you are managing the scrollbars yourself so that you can keep
|
||||
the scrollbars' event handlers connected to your view's event handler
|
||||
class.
|
||||
*/
|
||||
class GIZMODLLEXPORT wxDynamicSashUnifyEvent : public wxCommandEvent {
|
||||
public:
|
||||
wxDynamicSashUnifyEvent();
|
||||
wxDynamicSashUnifyEvent(const wxDynamicSashUnifyEvent& event): wxCommandEvent(event) {}
|
||||
wxDynamicSashUnifyEvent(wxObject *target);
|
||||
|
||||
virtual wxEvent* Clone() const { return new wxDynamicSashUnifyEvent(*this); }
|
||||
|
||||
private:
|
||||
DECLARE_DYNAMIC_CLASS(wxDynamicSashUnifyEvent);
|
||||
};
|
||||
|
||||
/*
|
||||
wxDynamicSashWindow. See above.
|
||||
*/
|
||||
class GIZMODLLEXPORT wxDynamicSashWindow : public wxWindow {
|
||||
public:
|
||||
wxDynamicSashWindow();
|
||||
wxDynamicSashWindow(wxWindow *parent, wxWindowID id,
|
||||
const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
|
||||
long style = wxCLIP_CHILDREN | wxDS_MANAGE_SCROLLBARS | wxDS_DRAG_CORNER,
|
||||
const wxString& name = "dynamicSashWindow");
|
||||
virtual ~wxDynamicSashWindow();
|
||||
|
||||
virtual bool Create(wxWindow *parent, wxWindowID id,
|
||||
const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
|
||||
long style = wxCLIP_CHILDREN | wxDS_MANAGE_SCROLLBARS | wxDS_DRAG_CORNER,
|
||||
const wxString& name = "dynamicSashWindow");
|
||||
virtual wxScrollBar *GetHScrollBar(const wxWindow *child) const;
|
||||
virtual wxScrollBar *GetVScrollBar(const wxWindow *child) const;
|
||||
|
||||
/* This is overloaded from wxWindowBase. It's not here for you to
|
||||
call directly. */
|
||||
virtual void AddChild(wxWindowBase *child);
|
||||
|
||||
private:
|
||||
class wxDynamicSashWindowImpl *m_impl;
|
||||
|
||||
DECLARE_DYNAMIC_CLASS(wxDynamicSashWindow)
|
||||
};
|
||||
|
||||
|
||||
#endif
|
@@ -1,65 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: editlbox.h
|
||||
// Purpose: ListBox with editable items
|
||||
// Author: Vaclav Slavik
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) Vaclav Slavik
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
#ifndef __WX_EDITLBOX_H__
|
||||
#define __WX_EDITLBOX_H__
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "editlbox.h"
|
||||
#endif
|
||||
|
||||
#include "wx/panel.h"
|
||||
|
||||
#ifdef GIZMOISDLL
|
||||
#define GIZMODLLEXPORT WXDLLEXPORT
|
||||
#else
|
||||
#define GIZMODLLEXPORT
|
||||
#endif
|
||||
|
||||
|
||||
class WXDLLEXPORT wxBitmapButton;
|
||||
class WXDLLEXPORT wxListCtrl;
|
||||
class WXDLLEXPORT wxListEvent;
|
||||
|
||||
// This class provides a composite control that lets the
|
||||
// user easily enter list of strings
|
||||
|
||||
class GIZMODLLEXPORT wxEditableListBox : public wxPanel
|
||||
{
|
||||
DECLARE_CLASS(wxEditableListBox);
|
||||
|
||||
public:
|
||||
wxEditableListBox(wxWindow *parent, wxWindowID id,
|
||||
const wxString& label,
|
||||
const wxPoint& pos = wxDefaultPosition,
|
||||
const wxSize& size = wxDefaultSize,
|
||||
const wxString& name = wxT("editableListBox"));
|
||||
|
||||
void SetStrings(const wxArrayString& strings);
|
||||
void GetStrings(wxArrayString& strings);
|
||||
|
||||
protected:
|
||||
wxBitmapButton *m_bDel, *m_bNew, *m_bUp, *m_bDown, *m_bEdit;
|
||||
wxListCtrl *m_listCtrl;
|
||||
int m_selection;
|
||||
bool m_edittingNew;
|
||||
|
||||
void OnItemSelected(wxListEvent& event);
|
||||
void OnEndLabelEdit(wxListEvent& event);
|
||||
void OnNewItem(wxCommandEvent& event);
|
||||
void OnDelItem(wxCommandEvent& event);
|
||||
void OnEditItem(wxCommandEvent& event);
|
||||
void OnUpItem(wxCommandEvent& event);
|
||||
void OnDownItem(wxCommandEvent& event);
|
||||
|
||||
DECLARE_EVENT_TABLE()
|
||||
};
|
||||
|
||||
#endif
|
@@ -1,89 +0,0 @@
|
||||
#ifndef _WX_LEDNUMBERCTRL_H_
|
||||
#define _WX_LEDNUMBERCTRL_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "wxLEDNumberCtrl.h"
|
||||
#endif
|
||||
|
||||
#ifdef GIZMOISDLL
|
||||
#define GIZMODLLEXPORT WXDLLEXPORT
|
||||
#else
|
||||
#define GIZMODLLEXPORT
|
||||
#endif
|
||||
|
||||
|
||||
#include <wx/window.h>
|
||||
#include <wx/control.h>
|
||||
|
||||
class wxEraseEvent;
|
||||
class wxPaintEvent;
|
||||
class wxSizeEvent;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// enum and styles
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
enum wxLEDValueAlign
|
||||
{
|
||||
wxLED_ALIGN_LEFT = 0x01,
|
||||
wxLED_ALIGN_RIGHT = 0x02,
|
||||
wxLED_ALIGN_CENTER = 0x04,
|
||||
|
||||
wxLED_ALIGN_MASK = 0x04
|
||||
};
|
||||
|
||||
#define wxLED_DRAW_FADED 0x08
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxLEDNumberCtrl
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class GIZMODLLEXPORT wxLEDNumberCtrl : public wxControl
|
||||
{
|
||||
public:
|
||||
// Constructors.
|
||||
wxLEDNumberCtrl();
|
||||
wxLEDNumberCtrl(wxWindow *parent, wxWindowID id = -1,
|
||||
const wxPoint& pos = wxDefaultPosition,
|
||||
const wxSize& size = wxDefaultSize,
|
||||
long style = wxLED_ALIGN_LEFT | wxLED_DRAW_FADED);
|
||||
|
||||
// Create functions.
|
||||
bool Create(wxWindow *parent, wxWindowID id = -1,
|
||||
const wxPoint& pos = wxDefaultPosition,
|
||||
const wxSize& size = wxDefaultSize,
|
||||
long style = 0);
|
||||
|
||||
wxLEDValueAlign GetAlignment() const { return m_Alignment; }
|
||||
bool GetDrawFaded() const { return m_DrawFaded; }
|
||||
const wxString &GetValue() const { return m_Value; }
|
||||
|
||||
void SetAlignment(wxLEDValueAlign Alignment, bool Redraw = TRUE);
|
||||
void SetDrawFaded(bool DrawFaded, bool Redraw = TRUE);
|
||||
void SetValue(const wxString &Value, bool Redraw = TRUE);
|
||||
|
||||
private:
|
||||
// Members.
|
||||
wxString m_Value;
|
||||
wxLEDValueAlign m_Alignment;
|
||||
|
||||
int m_LineMargin;
|
||||
int m_DigitMargin;
|
||||
int m_LineLength;
|
||||
int m_LineWidth;
|
||||
bool m_DrawFaded;
|
||||
int m_LeftStartPos;
|
||||
|
||||
// Functions.
|
||||
void DrawDigit(wxDC &Dc, int Digit, int Column);
|
||||
void RecalcInternals(const wxSize &CurrentSize);
|
||||
|
||||
// Events.
|
||||
DECLARE_EVENT_TABLE()
|
||||
|
||||
void OnEraseBackground(wxEraseEvent &Event);
|
||||
void OnPaint(wxPaintEvent &Event);
|
||||
void OnSize(wxSizeEvent &Event);
|
||||
};
|
||||
|
||||
#endif
|
@@ -1,175 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: multicell.h
|
||||
// Purpose: provide two new classes for layout, wxMultiCellSizer and wxMultiCellCanvas
|
||||
// Author: Jonathan Bayer
|
||||
// Modified by:
|
||||
// Created:
|
||||
// RCS-ID: $Id:
|
||||
// Copyright: (c) Jonathan Bayer
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// This was inspired by the gbsizer class written by Alex Andruschak
|
||||
|
||||
|
||||
#ifndef __WX_MULTICELL_H__
|
||||
#define __WX_MULTICELL_H__
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "multicell.h"
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef GIZMOISDLL
|
||||
#define GIZMODLLEXPORT WXDLLEXPORT
|
||||
#else
|
||||
#define GIZMODLLEXPORT
|
||||
#endif
|
||||
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// headers
|
||||
// ----------------------------------------------------------------------------
|
||||
// The classes are derived from wxSizer
|
||||
#include "wx/sizer.h"
|
||||
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// constants
|
||||
// ----------------------------------------------------------------------------
|
||||
enum wxResizable
|
||||
{
|
||||
wxNOT_RESIZABLE = 0x00,
|
||||
wxHORIZENTAL_RESIZABLE = 0x01,
|
||||
wxVERTICAL_RESIZABLE = 0x10,
|
||||
wxRESIZABLE = 0x11
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
// classes
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
// wxMultiCellItemHandle
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class GIZMODLLEXPORT wxMultiCellItemHandle: public wxObject
|
||||
{
|
||||
DECLARE_CLASS(wxMultiCellItemHandle);
|
||||
protected:
|
||||
int m_column;
|
||||
int m_row;
|
||||
int m_width;
|
||||
int m_height;
|
||||
wxResizable m_style;
|
||||
wxSize m_fixedSize;
|
||||
int m_alignment;
|
||||
wxSize m_weight;
|
||||
|
||||
public:
|
||||
wxMultiCellItemHandle( int row, int column, int height = 1, int width = 1, wxSize size = wxDefaultSize, wxResizable style = wxNOT_RESIZABLE, wxSize weight = wxSize(1,1), int align = wxALIGN_NOT);
|
||||
wxMultiCellItemHandle( int row, int column, wxSize size, wxResizable style = wxNOT_RESIZABLE, wxSize weight = wxSize(1,1), int align = wxALIGN_NOT);
|
||||
wxMultiCellItemHandle( int row, int column, wxResizable style, wxSize weight = wxSize(1,1), int align = wxALIGN_NOT);
|
||||
wxMultiCellItemHandle( int row, int column, int align);
|
||||
int GetColumn();
|
||||
int GetRow();
|
||||
int GetWidth();
|
||||
int GetHeight();
|
||||
wxResizable GetStyle();
|
||||
wxSize GetLocalSize();
|
||||
int GetAlignment();
|
||||
wxSize GetWeight();
|
||||
|
||||
private:
|
||||
void Initialize( int row, int column, int height = 1, int width = 1, wxSize size = wxDefaultSize, wxResizable style = wxNOT_RESIZABLE, wxSize weight = wxSize(1,1), int align = wxALIGN_NOT);
|
||||
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
// wxMultiCellSizer
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class GIZMODLLEXPORT wxMultiCellSizer : virtual public wxSizer
|
||||
{
|
||||
DECLARE_CLASS(wxMultiCellSizer);
|
||||
|
||||
protected:
|
||||
wxSize m_cell_count;
|
||||
|
||||
public:
|
||||
wxMultiCellSizer(wxSize & size);
|
||||
wxMultiCellSizer(int rows, int cols);
|
||||
~wxMultiCellSizer();
|
||||
|
||||
virtual void RecalcSizes();
|
||||
virtual wxSize CalcMin();
|
||||
bool SetDefaultCellSize(wxSize size);
|
||||
bool SetColumnWidth(int column, int colSize = 5, bool expandable = FALSE);
|
||||
bool SetRowHeight(int row, int rowSize = 5, bool expandable = FALSE);
|
||||
bool EnableGridLines(wxWindow *win);
|
||||
bool SetGridPen(wxPen *pen);
|
||||
void OnPaint(wxDC& dc);
|
||||
|
||||
private:
|
||||
void GetMinimums();
|
||||
int Sum(int *array, int x);
|
||||
|
||||
private:
|
||||
int *m_maxHeight;
|
||||
int *m_maxWidth;
|
||||
int *m_rowStretch;
|
||||
int *m_colStretch;
|
||||
wxSize **m_weights;
|
||||
wxSize **m_minSizes;
|
||||
int m_maxWeights;
|
||||
wxSize m_defaultCellSize;
|
||||
wxWindow *m_win; // usually used for debugging
|
||||
wxPen *m_pen;
|
||||
|
||||
void DrawGridLines(wxDC& dc);
|
||||
void Initialize(wxSize size);
|
||||
};
|
||||
|
||||
|
||||
// wxCell is used internally, so we don't need to declare it here
|
||||
|
||||
class wxCell;
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
// wxMultiCellCanvas
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class GIZMODLLEXPORT wxMultiCellCanvas : public wxFlexGridSizer
|
||||
{
|
||||
public:
|
||||
wxMultiCellCanvas(wxWindow *parent, int numRows = 2, int numCols = 2);
|
||||
void Add(wxWindow *win, unsigned int row, unsigned int col);
|
||||
|
||||
void Resize(int numRows, int numCols);
|
||||
int MaxRows()
|
||||
{
|
||||
return m_maxRows;
|
||||
};
|
||||
int MaxCols()
|
||||
{
|
||||
return m_maxCols;
|
||||
};
|
||||
void CalculateConstraints();
|
||||
void SetMinCellSize(const wxSize size)
|
||||
{
|
||||
m_minCellSize = size;
|
||||
};
|
||||
|
||||
private:
|
||||
wxWindow *m_parent;
|
||||
unsigned int m_maxRows, m_maxCols;
|
||||
|
||||
wxSize m_minCellSize;
|
||||
wxCell **m_cells;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
/*** End of File ***/
|
@@ -1,235 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: splittree.h
|
||||
// Purpose: Classes to achieve a remotely-scrolled tree in a splitter
|
||||
// window that can be scrolled by a scrolled window higher in the
|
||||
// hierarchy
|
||||
// Author: Julian Smart
|
||||
// Modified by:
|
||||
// Created: 8/7/2000
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) Julian Smart
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_SPLITTREE_H_
|
||||
#define _WX_SPLITTREE_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "splittree.h"
|
||||
#endif
|
||||
|
||||
#ifdef GIZMOISDLL
|
||||
#define GIZMODLLEXPORT WXDLLEXPORT
|
||||
#else
|
||||
#define GIZMODLLEXPORT
|
||||
#endif
|
||||
|
||||
// Set this to 1 to use generic tree control (doesn't yet work properly)
|
||||
#define USE_GENERIC_TREECTRL 0
|
||||
|
||||
#include "wx/wx.h"
|
||||
#include "wx/treectrl.h"
|
||||
#include "wx/splitter.h"
|
||||
#include "wx/scrolwin.h"
|
||||
|
||||
#if USE_GENERIC_TREECTRL
|
||||
#include "wx/generic/treectlg.h"
|
||||
#ifndef wxTreeCtrl
|
||||
#define wxTreeCtrl wxGenericTreeCtrl
|
||||
#define sm_classwxTreeCtrl sm_classwxGenericTreeCtrl
|
||||
#endif
|
||||
#endif
|
||||
|
||||
class wxRemotelyScrolledTreeCtrl;
|
||||
class wxThinSplitterWindow;
|
||||
class wxSplitterScrolledWindow;
|
||||
|
||||
/*
|
||||
* wxRemotelyScrolledTreeCtrl
|
||||
*
|
||||
* This tree control disables its vertical scrollbar and catches scroll
|
||||
* events passed by a scrolled window higher in the hierarchy.
|
||||
* It also updates the scrolled window vertical scrollbar as appropriate.
|
||||
*/
|
||||
|
||||
class GIZMODLLEXPORT wxRemotelyScrolledTreeCtrl: public wxTreeCtrl
|
||||
{
|
||||
DECLARE_CLASS(wxRemotelyScrolledTreeCtrl)
|
||||
public:
|
||||
wxRemotelyScrolledTreeCtrl(wxWindow* parent, wxWindowID id, const wxPoint& pt = wxDefaultPosition,
|
||||
const wxSize& sz = wxDefaultSize, long style = wxTR_HAS_BUTTONS);
|
||||
~wxRemotelyScrolledTreeCtrl();
|
||||
|
||||
//// Events
|
||||
void OnSize(wxSizeEvent& event);
|
||||
void OnExpand(wxTreeEvent& event);
|
||||
void OnScroll(wxScrollWinEvent& event);
|
||||
void OnPaint(wxPaintEvent& event);
|
||||
|
||||
//// Overrides
|
||||
// Override this in case we're using the generic tree control.
|
||||
// Calls to this should disable the vertical scrollbar.
|
||||
|
||||
// Number of pixels per user unit (0 or -1 for no scrollbar)
|
||||
// Length of virtual canvas in user units
|
||||
// Length of page in user units
|
||||
virtual void SetScrollbars(int pixelsPerUnitX, int pixelsPerUnitY,
|
||||
int noUnitsX, int noUnitsY,
|
||||
int xPos = 0, int yPos = 0,
|
||||
bool noRefresh = FALSE );
|
||||
|
||||
// In case we're using the generic tree control.
|
||||
// Get the view start
|
||||
virtual void GetViewStart(int *x, int *y) const;
|
||||
|
||||
// In case we're using the generic tree control.
|
||||
virtual void PrepareDC(wxDC& dc);
|
||||
|
||||
// In case we're using the generic tree control.
|
||||
virtual int GetScrollPos(int orient) const;
|
||||
|
||||
//// Helpers
|
||||
void HideVScrollbar();
|
||||
|
||||
// Calculate the tree overall size so we can set the scrollbar
|
||||
// correctly
|
||||
void CalcTreeSize(wxRect& rect);
|
||||
void CalcTreeSize(const wxTreeItemId& id, wxRect& rect);
|
||||
|
||||
// Adjust the containing wxScrolledWindow's scrollbars appropriately
|
||||
void AdjustRemoteScrollbars();
|
||||
|
||||
// Find the scrolled window that contains this control
|
||||
wxScrolledWindow* GetScrolledWindow() const;
|
||||
|
||||
// Scroll to the given line (in scroll units where each unit is
|
||||
// the height of an item)
|
||||
void ScrollToLine(int posHoriz, int posVert);
|
||||
|
||||
//// Accessors
|
||||
|
||||
// The companion window is one which will get notified when certain
|
||||
// events happen such as node expansion
|
||||
void SetCompanionWindow(wxWindow* companion) { m_companionWindow = companion; }
|
||||
wxWindow* GetCompanionWindow() const { return m_companionWindow; }
|
||||
|
||||
|
||||
DECLARE_EVENT_TABLE()
|
||||
protected:
|
||||
wxWindow* m_companionWindow;
|
||||
bool m_drawRowLines;
|
||||
};
|
||||
|
||||
/*
|
||||
* wxTreeCompanionWindow
|
||||
*
|
||||
* A window displaying values associated with tree control items.
|
||||
*/
|
||||
|
||||
class GIZMODLLEXPORT wxTreeCompanionWindow: public wxWindow
|
||||
{
|
||||
public:
|
||||
DECLARE_CLASS(wxTreeCompanionWindow)
|
||||
|
||||
wxTreeCompanionWindow(wxWindow* parent, wxWindowID id = -1,
|
||||
const wxPoint& pos = wxDefaultPosition,
|
||||
const wxSize& sz = wxDefaultSize,
|
||||
long style = 0);
|
||||
|
||||
//// Overrides
|
||||
virtual void DrawItem(wxDC& dc, wxTreeItemId id, const wxRect& rect);
|
||||
|
||||
//// Events
|
||||
void OnPaint(wxPaintEvent& event);
|
||||
void OnScroll(wxScrollWinEvent& event);
|
||||
void OnExpand(wxTreeEvent& event);
|
||||
|
||||
//// Operations
|
||||
|
||||
//// Accessors
|
||||
wxRemotelyScrolledTreeCtrl* GetTreeCtrl() const { return m_treeCtrl; };
|
||||
void SetTreeCtrl(wxRemotelyScrolledTreeCtrl* treeCtrl) { m_treeCtrl = treeCtrl; }
|
||||
|
||||
//// Data members
|
||||
protected:
|
||||
wxRemotelyScrolledTreeCtrl* m_treeCtrl;
|
||||
|
||||
DECLARE_EVENT_TABLE()
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* wxThinSplitterWindow
|
||||
*
|
||||
* Implements a splitter with a less obvious sash
|
||||
* than the usual one.
|
||||
*/
|
||||
|
||||
class GIZMODLLEXPORT wxThinSplitterWindow: public wxSplitterWindow
|
||||
{
|
||||
public:
|
||||
DECLARE_DYNAMIC_CLASS(wxThinSplitterWindow)
|
||||
|
||||
wxThinSplitterWindow(wxWindow* parent, wxWindowID id = -1,
|
||||
const wxPoint& pos = wxDefaultPosition,
|
||||
const wxSize& sz = wxDefaultSize,
|
||||
long style = wxSP_3D | wxCLIP_CHILDREN);
|
||||
|
||||
//// Overrides
|
||||
|
||||
void SizeWindows();
|
||||
// Tests for x, y over sash. Overriding this allows us to increase
|
||||
// the tolerance.
|
||||
bool SashHitTest(int x, int y, int tolerance = 2);
|
||||
void DrawSash(wxDC& dc);
|
||||
|
||||
//// Events
|
||||
|
||||
void OnSize(wxSizeEvent& event);
|
||||
|
||||
//// Operations
|
||||
|
||||
//// Accessors
|
||||
|
||||
//// Data members
|
||||
protected:
|
||||
DECLARE_EVENT_TABLE()
|
||||
};
|
||||
|
||||
/*
|
||||
* wxSplitterScrolledWindow
|
||||
*
|
||||
* This scrolled window is aware of the fact that one of its
|
||||
* children is a splitter window. It passes on its scroll events
|
||||
* (after some processing) to both splitter children for them
|
||||
* scroll appropriately.
|
||||
*/
|
||||
|
||||
class GIZMODLLEXPORT wxSplitterScrolledWindow: public wxScrolledWindow
|
||||
{
|
||||
public:
|
||||
DECLARE_DYNAMIC_CLASS(wxSplitterScrolledWindow)
|
||||
|
||||
wxSplitterScrolledWindow(wxWindow* parent, wxWindowID id = -1,
|
||||
const wxPoint& pos = wxDefaultPosition,
|
||||
const wxSize& sz = wxDefaultSize,
|
||||
long style = 0);
|
||||
|
||||
//// Overrides
|
||||
|
||||
//// Events
|
||||
|
||||
void OnScroll(wxScrollWinEvent& event);
|
||||
void OnSize(wxSizeEvent& event);
|
||||
|
||||
//// Operations
|
||||
|
||||
//// Accessors
|
||||
|
||||
//// Data members
|
||||
public:
|
||||
DECLARE_EVENT_TABLE()
|
||||
};
|
||||
|
||||
#endif
|
||||
// _SPLITTREE_H_
|
@@ -27,7 +27,7 @@ class WXDLLEXPORT wxCDAudio : public wxObject {
|
||||
public:
|
||||
typedef enum { PLAYING, PAUSED, STOPPED } CDstatus;
|
||||
// Table of contents manager
|
||||
class WXDLLEXPORT CDtoc {
|
||||
class CDtoc {
|
||||
protected:
|
||||
wxCDtime *tracks_time, *tracks_pos;
|
||||
wxCDtime total_time;
|
||||
|
@@ -22,7 +22,7 @@
|
||||
// AIFF codec
|
||||
//
|
||||
|
||||
class WXDLLEXPORT wxSoundAiff: public wxSoundFileStream {
|
||||
class wxSoundAiff: public wxSoundFileStream {
|
||||
public:
|
||||
wxSoundAiff(wxInputStream& stream, wxSoundStream& io_sound);
|
||||
wxSoundAiff(wxOutputStream& stream, wxSoundStream& io_sound);
|
||||
|
@@ -112,7 +112,7 @@ class WXDLLEXPORT wxSoundFormatBase {
|
||||
// Base class for sound streams
|
||||
//
|
||||
|
||||
class WXDLLEXPORT wxSoundStream {
|
||||
class wxSoundStream {
|
||||
public:
|
||||
wxSoundStream();
|
||||
virtual ~wxSoundStream();
|
||||
|
@@ -15,7 +15,7 @@
|
||||
#include "wx/defs.h"
|
||||
#include "wx/mmedia/sndbase.h"
|
||||
|
||||
class WXDLLEXPORT wxSoundStreamCodec: public wxSoundStream {
|
||||
class wxSoundStreamCodec: public wxSoundStream {
|
||||
public:
|
||||
wxSoundStreamCodec(wxSoundStream& snd_io);
|
||||
~wxSoundStreamCodec();
|
||||
|
@@ -20,7 +20,7 @@
|
||||
// PCM converter class
|
||||
//
|
||||
|
||||
class WXDLLEXPORT wxSoundStreamPcm: public wxSoundStreamCodec {
|
||||
class wxSoundStreamPcm: public wxSoundStreamCodec {
|
||||
public:
|
||||
typedef void (*ConverterType)(const void *buf_in, void *buf_out,
|
||||
wxUint32 len);
|
||||
|
@@ -5,8 +5,8 @@
|
||||
// Author: Guilhem Lavaux <lavaux@easynet.fr> (C) 2000
|
||||
// CVSID: $Id$
|
||||
// --------------------------------------------------------------------------
|
||||
#ifndef _WX_SNDMSAD_H
|
||||
#define _WX_SNDMSAD_H
|
||||
#ifndef _WX_SNDULAW_H
|
||||
#define _WX_SNDULAW_H
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "sndmsad.h"
|
||||
@@ -17,52 +17,46 @@
|
||||
#include "wx/mmedia/sndcodec.h"
|
||||
#include "wx/mmedia/sndbase.h"
|
||||
|
||||
WX_DEFINE_EXPORTED_ARRAY(wxInt16, wxMSAdpcmCoeffs);
|
||||
WX_DEFINE_EXPORTED_ARRAY(wxUint16, wxMSAdpcmCoeffs);
|
||||
|
||||
//
|
||||
// MSADPCM format
|
||||
//
|
||||
class WXDLLEXPORT wxSoundFormatMSAdpcm: public wxSoundFormatBase {
|
||||
public:
|
||||
wxSoundFormatMSAdpcm();
|
||||
~wxSoundFormatMSAdpcm();
|
||||
|
||||
void SetSampleRate(wxUint32 srate);
|
||||
wxUint32 GetSampleRate() const;
|
||||
|
||||
void SetCoefs(wxInt16 **coefs, wxUint16 ncoefs, wxUint16 coefs_len);
|
||||
void GetCoefs(wxInt16 **&coefs, wxUint16& ncoefs,
|
||||
wxUint16& coefs_len) const;
|
||||
public:
|
||||
wxSoundFormatMSAdpcm();
|
||||
~wxSoundFormatMSAdpcm();
|
||||
|
||||
void SetBlockSize(wxUint16 block_size);
|
||||
wxUint16 GetBlockSize() const;
|
||||
|
||||
void SetChannels(wxUint16 channels);
|
||||
wxUint16 GetChannels() const;
|
||||
|
||||
wxSoundFormatType GetType() const { return wxSOUND_MSADPCM; }
|
||||
wxSoundFormatBase *Clone() const;
|
||||
|
||||
wxUint32 GetTimeFromBytes(wxUint32 bytes) const;
|
||||
wxUint32 GetBytesFromTime(wxUint32 time) const;
|
||||
|
||||
bool operator !=(const wxSoundFormatBase& frmt2) const;
|
||||
void SetSampleRate(wxUint32 srate);
|
||||
wxUint32 GetSampleRate() const;
|
||||
|
||||
protected:
|
||||
wxUint32 m_srate, m_nchannels;
|
||||
wxInt16 **m_coefs;
|
||||
wxUint16 m_ncoefs, m_coefs_len;
|
||||
wxUint16 m_block_size;
|
||||
void SetSamplesBlock(wxUint16 sampblock);
|
||||
wxUint16 GetSamplesBlock() const;
|
||||
|
||||
void SetCoefs(wxMSAdpcmCoefs& coefs);
|
||||
wxMSAdpcmCoefs& GetCoefs() const;
|
||||
|
||||
wxSoundFormatType GetType() const { return wxSOUND_ULAW; }
|
||||
wxSoundFormatBase *Clone() const;
|
||||
|
||||
wxUint32 GetTimeFromBytes(wxUint32 bytes) const;
|
||||
wxUint32 GetBytesFromTime(wxUint32 time) const;
|
||||
|
||||
bool operator !=(const wxSoundFormatBase& frmt2) const;
|
||||
|
||||
protected:
|
||||
wxUint32 m_srate;
|
||||
wxMSAdpcmCoefs *m_coefs;
|
||||
};
|
||||
|
||||
//
|
||||
// MS ADPCM converter class
|
||||
//
|
||||
class WXDLLEXPORT wxSoundRouterStream;
|
||||
class WXDLLEXPORT wxSoundStreamMSAdpcm: public wxSoundStreamCodec {
|
||||
class WXDLLEXPORT wxSoundStreamAdpcm: public wxSoundStreamCodec {
|
||||
public:
|
||||
wxSoundStreamMSAdpcm(wxSoundStream& sndio);
|
||||
~wxSoundStreamMSAdpcm();
|
||||
wxSoundStreamAdpcm(wxSoundStream& sndio);
|
||||
~wxSoundStreamAdpcm();
|
||||
|
||||
wxSoundStream& Read(void *buffer, wxUint32 len);
|
||||
wxSoundStream& Write(const void *buffer, wxUint32 len);
|
||||
@@ -73,32 +67,6 @@ public:
|
||||
|
||||
protected:
|
||||
wxSoundRouterStream *m_router;
|
||||
|
||||
typedef struct {
|
||||
wxInt32 predictor;
|
||||
wxInt16 samp1;
|
||||
wxInt16 samp2;
|
||||
wxInt16 coeff[2];
|
||||
wxInt32 iDelta;
|
||||
} AdpcmState;
|
||||
|
||||
AdpcmState m_state[1];
|
||||
|
||||
bool m_got_header;
|
||||
bool m_stereo;
|
||||
wxInt16 **m_coefs;
|
||||
wxUint16 m_block_size;
|
||||
wxUint16 m_ncoefs;
|
||||
wxUint16 m_next_block;
|
||||
|
||||
protected:
|
||||
wxUint32 DecodeMonoADPCM(const void *in_buffer, void *out_buffer,
|
||||
wxUint32 in_len);
|
||||
wxUint32 DecodeStereoADPCM(const void *in_buffer, void *out_buffer,
|
||||
wxUint32 in_len);
|
||||
void Nibble(wxInt8 nyb,
|
||||
AdpcmState *state,
|
||||
wxInt16 **out_buffer);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
@@ -21,7 +21,7 @@
|
||||
// OSS output class
|
||||
//
|
||||
|
||||
class WXDLLEXPORT wxSoundStreamOSS : public wxSoundStream {
|
||||
class wxSoundStreamOSS : public wxSoundStream {
|
||||
public:
|
||||
wxSoundStreamOSS(const wxString& dev_name = wxT("/dev/dsp"));
|
||||
~wxSoundStreamOSS();
|
||||
|
@@ -42,18 +42,12 @@ protected:
|
||||
wxUint32 GetData(void *buffer, wxUint32 len);
|
||||
wxUint32 PutData(const void *buffer, wxUint32 len);
|
||||
|
||||
bool HandleOutputPCM(wxDataInputStream& data, wxUint32 len,
|
||||
wxUint16 channels, wxUint32 sample_fq,
|
||||
wxUint32 byte_p_sec, wxUint16 byte_p_spl,
|
||||
wxUint16 bits_p_spl);
|
||||
bool HandleOutputMSADPCM(wxDataInputStream& data, wxUint32 len,
|
||||
wxUint16 channels, wxUint32 sample_fq,
|
||||
wxUint32 byte_p_sec, wxUint16 byte_p_spl,
|
||||
wxUint16 bits_p_spl);
|
||||
bool HandleOutputG721(wxDataInputStream& data, wxUint32 len,
|
||||
wxUint16 channels, wxUint32 sample_fq,
|
||||
wxUint32 byte_p_sec, wxUint16 byte_p_spl,
|
||||
wxUint16 bits_p_spl);
|
||||
bool HandleOutputPCM(wxDataInputStream& data, wxUint16 channels,
|
||||
wxUint32 sample_fq, wxUint32 byte_p_sec,
|
||||
wxUint16 byte_p_spl, wxUint16 bits_p_spl);
|
||||
bool HandleOutputG721(wxDataInputStream& data, wxUint16 channels,
|
||||
wxUint32 sample_fq, wxUint32 byte_p_sec,
|
||||
wxUint16 byte_p_spl, wxUint16 bits_p_spl);
|
||||
wxSoundFormatBase *HandleInputPCM(wxDataOutputStream& data);
|
||||
wxSoundFormatBase *HandleInputG72X(wxDataOutputStream& data);
|
||||
|
||||
|
@@ -1,44 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: email.h
|
||||
// Purpose: wxEmail: portable email client class
|
||||
// Author: Julian Smart
|
||||
// Modified by:
|
||||
// Created: 2001-08-21
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) Julian Smart
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "email.h"
|
||||
#endif
|
||||
|
||||
#ifndef _WX_EMAIL_H_
|
||||
#define _WX_EMAIL_H_
|
||||
|
||||
#include "wx/net/msg.h"
|
||||
|
||||
/*
|
||||
* wxEmail
|
||||
* Miscellaneous email functions
|
||||
*/
|
||||
|
||||
class wxEmail
|
||||
{
|
||||
public:
|
||||
//// Ctor/dtor
|
||||
wxEmail() {};
|
||||
|
||||
//// Operations
|
||||
|
||||
// Send a message.
|
||||
// Specify profile, or leave it to wxWindows to find the current user name
|
||||
static bool Send(wxMailMessage& message, const wxString& profileName = wxEmptyString,
|
||||
const wxString& sendMail = wxT("/usr/lib/sendmail -t"));
|
||||
|
||||
protected:
|
||||
};
|
||||
|
||||
|
||||
#endif //_WX_EMAIL_H_
|
||||
|
@@ -1,71 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: msg.h
|
||||
// Purpose: wxMailMessage
|
||||
// Author: Julian Smart
|
||||
// Modified by:
|
||||
// Created: 2001-08-21
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) Julian Smart
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "msg.h"
|
||||
#endif
|
||||
|
||||
#ifndef _WX_MSG_H_
|
||||
#define _WX_MSG_H_
|
||||
|
||||
/*
|
||||
* wxMailMessage
|
||||
* Encapsulates an email message
|
||||
*/
|
||||
|
||||
class wxMailMessage
|
||||
{
|
||||
public:
|
||||
|
||||
// A common usage
|
||||
wxMailMessage(const wxString& subject, const wxString& to,
|
||||
const wxString& body, const wxString& from = wxEmptyString,
|
||||
const wxString& attachment = wxEmptyString,
|
||||
const wxString& attachmentTitle = wxEmptyString)
|
||||
{
|
||||
m_to.Add(to);
|
||||
m_subject = subject;
|
||||
m_body = body;
|
||||
m_from = from;
|
||||
if (!attachment.IsEmpty())
|
||||
{
|
||||
m_attachments.Add(attachment);
|
||||
m_attachmentTitles.Add(attachmentTitle);
|
||||
}
|
||||
}
|
||||
|
||||
wxMailMessage() {};
|
||||
|
||||
//// Accessors
|
||||
|
||||
void AddTo(const wxString& to) { m_to.Add(to); }
|
||||
void AddCc(const wxString& cc) { m_cc.Add(cc); }
|
||||
void AddBcc(const wxString& bcc) { m_bcc.Add(bcc); }
|
||||
void AddAttachment(const wxString& attach, const wxString& title = wxEmptyString)
|
||||
{ m_attachments.Add(attach); m_attachmentTitles.Add(title); }
|
||||
|
||||
void SetSubject(const wxString& subject) { m_subject = subject; }
|
||||
void SetBody(const wxString& body) { m_body = body; }
|
||||
void SetFrom(const wxString& from) { m_from = from; }
|
||||
|
||||
public:
|
||||
wxArrayString m_to; //The To: Recipients
|
||||
wxString m_from; //The From: email address (optional)
|
||||
wxArrayString m_cc; //The CC: Recipients
|
||||
wxArrayString m_bcc; //The BCC Recipients
|
||||
wxString m_subject; //The Subject of the message
|
||||
wxString m_body; //The Body of the message
|
||||
wxArrayString m_attachments; //Files to attach to the email
|
||||
wxArrayString m_attachmentTitles; //Titles to use for the email file attachments
|
||||
};
|
||||
|
||||
#endif // _WX_MSG_H_
|
||||
|
@@ -1,56 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: smapi.h
|
||||
// Purpose: Simple MAPI classes
|
||||
// Author: PJ Naughter <pjna@naughter.com>
|
||||
// Modified by: Julian Smart
|
||||
// Created: 2001-08-21
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) PJ Naughter
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "smapi.h"
|
||||
#endif
|
||||
|
||||
#ifndef _WX_SMAPI_H_
|
||||
#define _WX_SMAPI_H_
|
||||
|
||||
#include "wx/net/msg.h"
|
||||
|
||||
class wxMapiData;
|
||||
|
||||
//The class which encapsulates the MAPI connection
|
||||
class wxMapiSession
|
||||
{
|
||||
public:
|
||||
//Constructors / Destructors
|
||||
wxMapiSession();
|
||||
~wxMapiSession();
|
||||
|
||||
//Logon / Logoff Methods
|
||||
bool Logon(const wxString& sProfileName, const wxString& sPassword = wxEmptyString, wxWindow* pParentWnd = NULL);
|
||||
bool LoggedOn() const;
|
||||
bool Logoff();
|
||||
|
||||
//Send a message
|
||||
bool Send(wxMailMessage& message);
|
||||
|
||||
//General MAPI support
|
||||
bool MapiInstalled() const;
|
||||
|
||||
//Error Handling
|
||||
long GetLastError() const;
|
||||
|
||||
protected:
|
||||
//Methods
|
||||
void Initialise();
|
||||
void Deinitialise();
|
||||
bool Resolve(const wxString& sName, void* lppRecip1);
|
||||
|
||||
wxMapiData* m_data;
|
||||
|
||||
};
|
||||
|
||||
|
||||
#endif //_WX_SMAPI_H_
|
@@ -1,37 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: web.h
|
||||
// Purpose: wxWeb: portable web browser-related class
|
||||
// Author: Julian Smart
|
||||
// Modified by:
|
||||
// Created: 2001-08-21
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) Julian Smart
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "web.h"
|
||||
#endif
|
||||
|
||||
#ifndef _WX_WEB_H_
|
||||
#define _WX_WEB_H_
|
||||
|
||||
/*
|
||||
* wxWeb
|
||||
* Miscellaneous web functions
|
||||
*/
|
||||
|
||||
class wxWeb
|
||||
{
|
||||
public:
|
||||
//// Ctor/dtor
|
||||
wxWeb() {};
|
||||
|
||||
//// Operations
|
||||
|
||||
protected:
|
||||
};
|
||||
|
||||
|
||||
#endif //_WX_WEB_H_
|
||||
|
@@ -124,7 +124,7 @@ class WXDLLEXPORT wxExprDatabase;
|
||||
|
||||
|
||||
|
||||
class wxShapeEvtHandler: public wxObject, public wxClientDataContainer
|
||||
class wxShapeEvtHandler: public wxObject
|
||||
{
|
||||
DECLARE_DYNAMIC_CLASS(wxShapeEvtHandler)
|
||||
|
||||
@@ -299,6 +299,8 @@ class wxShape: public wxShapeEvtHandler
|
||||
|
||||
void SetPen(wxPen *pen);
|
||||
void SetBrush(wxBrush *brush);
|
||||
inline void SetClientData(wxObject *client_data) { m_clientData = client_data; };
|
||||
inline wxObject *GetClientData() const { return m_clientData; };
|
||||
|
||||
virtual void Show(bool show);
|
||||
virtual bool IsShown() const { return m_visible; }
|
||||
@@ -513,10 +515,8 @@ class wxShape: public wxShapeEvtHandler
|
||||
// Clears points from a list of wxRealPoints
|
||||
void ClearPointList(wxList& list);
|
||||
|
||||
// Return pen or brush of the right colour for the background
|
||||
wxPen GetBackgroundPen();
|
||||
wxBrush GetBackgroundBrush();
|
||||
|
||||
private:
|
||||
wxObject* m_clientData;
|
||||
|
||||
protected:
|
||||
wxShapeEvtHandler* m_eventHandler;
|
||||
|
@@ -53,20 +53,20 @@ void oglDrawFormattedText(wxDC& context, wxList *text_list,
|
||||
// Give it a list of points, finds the centre.
|
||||
void oglFindPolylineCentroid(wxList *points, double *x, double *y);
|
||||
|
||||
void oglCheckLineIntersection(double x1, double y1, double x2, double y2,
|
||||
void oglCheckLineIntersection(double x1, double y1, double x2, double y2,
|
||||
double x3, double y3, double x4, double y4,
|
||||
double *ratio1, double *ratio2);
|
||||
|
||||
void oglFindEndForPolyline(double n, double xvec[], double yvec[],
|
||||
void oglFindEndForPolyline(double n, double xvec[], double yvec[],
|
||||
double x1, double y1, double x2, double y2, double *x3, double *y3);
|
||||
|
||||
|
||||
void oglFindEndForBox(double width, double height,
|
||||
void oglFindEndForBox(double width, double height,
|
||||
double x1, double y1, // Centre of box (possibly)
|
||||
double x2, double y2, // other end of line
|
||||
double *x3, double *y3); // End on box edge
|
||||
|
||||
void oglFindEndForCircle(double radius,
|
||||
void oglFindEndForCircle(double radius,
|
||||
double x1, double y1, // Centre of circle
|
||||
double x2, double y2, // Other end of line
|
||||
double *x3, double *y3);
|
||||
@@ -83,7 +83,7 @@ void oglGetArrowPoints(double x1, double y1, double x2, double y2,
|
||||
* This function assumes that the centre of the ellipse is at x1, y1, and the
|
||||
* ellipse has a width of a1 and a height of b1. It also assumes you are
|
||||
* wanting to draw an arc FROM point x2, y2 TOWARDS point x3, y3.
|
||||
* This function calculates the x,y coordinates of the intersection point of
|
||||
* This function calculates the x,y coordinates of the intersection point of
|
||||
* the arc with the ellipse.
|
||||
* Author: Ian Harrison
|
||||
*/
|
||||
@@ -99,6 +99,7 @@ extern wxPen* g_oglWhiteBackgroundPen;
|
||||
extern wxPen* g_oglTransparentPen;
|
||||
extern wxBrush* g_oglWhiteBackgroundBrush;
|
||||
extern wxPen* g_oglBlackForegroundPen;
|
||||
extern wxCursor* g_oglBullseyeCursor;
|
||||
|
||||
extern wxFont* oglMatchFont(int point_size);
|
||||
|
||||
|
@@ -1,428 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: plot.h
|
||||
// Purpose: wxPlotWindow
|
||||
// Author: Robert Roebling
|
||||
// Modified by:
|
||||
// Created: 12/1/2000
|
||||
// Copyright: (c) Robert Roebling
|
||||
// RCS-ID: $Id$
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_PLOT_H_
|
||||
#define _WX_PLOT_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "plot.h"
|
||||
#endif
|
||||
|
||||
#include "wx/defs.h"
|
||||
|
||||
#include "wx/scrolwin.h"
|
||||
#include "wx/event.h"
|
||||
#include "wx/dynarray.h"
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// classes
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxPlotEvent;
|
||||
class WXDLLEXPORT wxPlotCurve;
|
||||
class WXDLLEXPORT wxPlotValues;
|
||||
class WXDLLEXPORT wxPlotArea;
|
||||
class WXDLLEXPORT wxPlotXAxisArea;
|
||||
class WXDLLEXPORT wxPlotYAxisArea;
|
||||
class WXDLLEXPORT wxPlotWindow;
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// consts
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
extern const int wxEVT_PLOT_SEL_CHANGING;
|
||||
extern const int wxEVT_PLOT_SEL_CHANGED;
|
||||
extern const int wxEVT_PLOT_CLICKED;
|
||||
extern const int wxEVT_PLOT_DOUBLECLICKED;
|
||||
extern const int wxEVT_PLOT_ZOOM_IN;
|
||||
extern const int wxEVT_PLOT_ZOOM_OUT;
|
||||
extern const int wxEVT_PLOT_VALUE_SEL_CREATING;
|
||||
extern const int wxEVT_PLOT_VALUE_SEL_CREATED;
|
||||
extern const int wxEVT_PLOT_VALUE_SEL_CHANGING;
|
||||
extern const int wxEVT_PLOT_VALUE_SEL_CHANGED;
|
||||
extern const int wxEVT_PLOT_AREA_SEL_CREATING;
|
||||
extern const int wxEVT_PLOT_AREA_SEL_CREATED;
|
||||
extern const int wxEVT_PLOT_AREA_SEL_CHANGING;
|
||||
extern const int wxEVT_PLOT_AREA_SEL_CHANGED;
|
||||
extern const int wxEVT_PLOT_BEGIN_X_LABEL_EDIT;
|
||||
extern const int wxEVT_PLOT_END_X_LABEL_EDIT;
|
||||
extern const int wxEVT_PLOT_BEGIN_Y_LABEL_EDIT;
|
||||
extern const int wxEVT_PLOT_END_Y_LABEL_EDIT;
|
||||
extern const int wxEVT_PLOT_BEGIN_TITLE_EDIT;
|
||||
extern const int wxEVT_PLOT_END_TITLE_EDIT;
|
||||
extern const int wxEVT_PLOT_AREA_CREATE;
|
||||
|
||||
|
||||
#define wxPLOT_X_AXIS 0x0004
|
||||
#define wxPLOT_Y_AXIS 0x0008
|
||||
#define wxPLOT_BUTTON_MOVE 0x0010
|
||||
#define wxPLOT_BUTTON_ZOOM 0x0020
|
||||
#define wxPLOT_BUTTON_ENLARGE 0x0040
|
||||
|
||||
#define wxPLOT_BUTTON_ALL (wxPLOT_BUTTON_MOVE|wxPLOT_BUTTON_ZOOM|wxPLOT_BUTTON_ENLARGE)
|
||||
#define wxPLOT_DEFAULT (wxPLOT_X_AXIS|wxPLOT_Y_AXIS | wxPLOT_BUTTON_ALL)
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// wxPlotEvent
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxPlotEvent: public wxNotifyEvent
|
||||
{
|
||||
public:
|
||||
wxPlotEvent( wxEventType commandType = wxEVT_NULL, int id = 0 );
|
||||
|
||||
wxPlotCurve *GetCurve()
|
||||
{ return m_curve; }
|
||||
void SetCurve( wxPlotCurve *curve )
|
||||
{ m_curve = curve; }
|
||||
|
||||
double GetZoom()
|
||||
{ return m_zoom; }
|
||||
void SetZoom( double zoom )
|
||||
{ m_zoom = zoom; }
|
||||
|
||||
wxInt32 GetPosition()
|
||||
{ return m_position; }
|
||||
void SetPosition( wxInt32 pos )
|
||||
{ m_position = pos; }
|
||||
|
||||
private:
|
||||
wxPlotCurve *m_curve;
|
||||
double m_zoom;
|
||||
wxInt32 m_position;
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// wxPlotCurve
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxPlotCurve: public wxObject
|
||||
{
|
||||
public:
|
||||
wxPlotCurve( int offsetY, double startY, double endY );
|
||||
|
||||
virtual wxInt32 GetStartX() = 0;
|
||||
virtual wxInt32 GetEndX() = 0;
|
||||
|
||||
virtual double GetY( wxInt32 x ) = 0;
|
||||
|
||||
void SetStartY( double startY )
|
||||
{ m_startY = startY; }
|
||||
double GetStartY()
|
||||
{ return m_startY; }
|
||||
void SetEndY( double endY )
|
||||
{ m_endY = endY; }
|
||||
double GetEndY()
|
||||
{ return m_endY; }
|
||||
void SetOffsetY( int offsetY )
|
||||
{ m_offsetY = offsetY; }
|
||||
int GetOffsetY()
|
||||
{ return m_offsetY; }
|
||||
|
||||
void SetPenNormal( const wxPen &pen )
|
||||
{ m_penNormal = pen; }
|
||||
void SetPenSelected( const wxPen &pen )
|
||||
{ m_penSelected = pen; }
|
||||
|
||||
private:
|
||||
int m_offsetY;
|
||||
double m_startY;
|
||||
double m_endY;
|
||||
wxPen m_penNormal;
|
||||
wxPen m_penSelected;
|
||||
|
||||
DECLARE_ABSTRACT_CLASS(wxPlotCurve)
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// wxPlotOnOffCurve
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxPlotOnOff
|
||||
{
|
||||
public:
|
||||
wxPlotOnOff() { }
|
||||
|
||||
wxInt32 m_on;
|
||||
wxInt32 m_off;
|
||||
void *m_clientData;
|
||||
};
|
||||
|
||||
WX_DECLARE_EXPORTED_OBJARRAY(wxPlotOnOff, wxArrayPlotOnOff);
|
||||
|
||||
class WXDLLEXPORT wxPlotOnOffCurve: public wxObject
|
||||
{
|
||||
public:
|
||||
wxPlotOnOffCurve( int offsetY );
|
||||
|
||||
wxInt32 GetStartX()
|
||||
{ return m_minX; }
|
||||
wxInt32 GetEndX()
|
||||
{ return m_maxX; }
|
||||
|
||||
void SetOffsetY( int offsetY )
|
||||
{ m_offsetY = offsetY; }
|
||||
int GetOffsetY()
|
||||
{ return m_offsetY; }
|
||||
|
||||
void Add( wxInt32 on, wxInt32 off, void *clientData = NULL );
|
||||
size_t GetCount();
|
||||
|
||||
wxInt32 GetOn( size_t index );
|
||||
wxInt32 GetOff( size_t index );
|
||||
void* GetClientData( size_t index );
|
||||
wxPlotOnOff *GetAt( size_t index );
|
||||
|
||||
virtual void DrawOnLine( wxDC &dc, wxCoord y, wxCoord start, wxCoord end, void *clientData );
|
||||
virtual void DrawOffLine( wxDC &dc, wxCoord y, wxCoord start, wxCoord end );
|
||||
|
||||
private:
|
||||
int m_offsetY;
|
||||
wxInt32 m_minX;
|
||||
wxInt32 m_maxX;
|
||||
|
||||
wxArrayPlotOnOff m_marks;
|
||||
|
||||
DECLARE_CLASS(wxPlotOnOffCurve)
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// wxPlotArea
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxPlotArea: public wxWindow
|
||||
{
|
||||
public:
|
||||
wxPlotArea() {}
|
||||
wxPlotArea( wxPlotWindow *parent );
|
||||
|
||||
void OnPaint( wxPaintEvent &event );
|
||||
void OnMouse( wxMouseEvent &event );
|
||||
|
||||
void DrawCurve( wxDC *dc, wxPlotCurve *curve, int from = -1, int to = -1 );
|
||||
void DrawOnOffCurve( wxDC *dc, wxPlotOnOffCurve *curve, int from = -1, int to = -1 );
|
||||
void DeleteCurve( wxPlotCurve *curve, int from = -1, int to = -1 );
|
||||
|
||||
virtual void ScrollWindow( int dx, int dy, const wxRect *rect );
|
||||
|
||||
private:
|
||||
wxPlotWindow *m_owner;
|
||||
bool m_zooming;
|
||||
|
||||
DECLARE_CLASS(wxPlotArea)
|
||||
DECLARE_EVENT_TABLE()
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// wxPlotXAxisArea
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxPlotXAxisArea: public wxWindow
|
||||
{
|
||||
public:
|
||||
wxPlotXAxisArea() {}
|
||||
wxPlotXAxisArea( wxPlotWindow *parent );
|
||||
|
||||
void OnPaint( wxPaintEvent &event );
|
||||
void OnMouse( wxMouseEvent &event );
|
||||
|
||||
private:
|
||||
wxPlotWindow *m_owner;
|
||||
|
||||
DECLARE_CLASS(wxPlotXAxisArea)
|
||||
DECLARE_EVENT_TABLE()
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// wxPlotYAxisArea
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxPlotYAxisArea: public wxWindow
|
||||
{
|
||||
public:
|
||||
wxPlotYAxisArea() {}
|
||||
wxPlotYAxisArea( wxPlotWindow *parent );
|
||||
|
||||
void OnPaint( wxPaintEvent &event );
|
||||
void OnMouse( wxMouseEvent &event );
|
||||
|
||||
private:
|
||||
wxPlotWindow *m_owner;
|
||||
|
||||
DECLARE_CLASS(wxPlotYAxisArea)
|
||||
DECLARE_EVENT_TABLE()
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// wxPlotWindow
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxPlotWindow: public wxScrolledWindow
|
||||
{
|
||||
public:
|
||||
wxPlotWindow() {}
|
||||
wxPlotWindow( wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size, int flags = wxPLOT_DEFAULT );
|
||||
~wxPlotWindow();
|
||||
|
||||
// curve accessors
|
||||
// ---------------
|
||||
|
||||
void Add( wxPlotCurve *curve );
|
||||
void Delete( wxPlotCurve* curve );
|
||||
|
||||
size_t GetCount();
|
||||
wxPlotCurve *GetAt( size_t n );
|
||||
|
||||
void SetCurrent( wxPlotCurve* current );
|
||||
wxPlotCurve *GetCurrent();
|
||||
|
||||
// mark list accessors
|
||||
// -------------------
|
||||
|
||||
void Add( wxPlotOnOffCurve *curve );
|
||||
void Delete( wxPlotOnOffCurve* curve );
|
||||
|
||||
size_t GetOnOffCurveCount();
|
||||
wxPlotOnOffCurve *GetOnOffCurveAt( size_t n );
|
||||
|
||||
// vertical representation
|
||||
// -----------------------
|
||||
|
||||
void Move( wxPlotCurve* curve, int pixels_up );
|
||||
void Enlarge( wxPlotCurve *curve, double factor );
|
||||
|
||||
// horizontal representation
|
||||
// -------------------------
|
||||
|
||||
void SetUnitsPerValue( double upv );
|
||||
double GetUnitsPerValue()
|
||||
{ return m_xUnitsPerValue; }
|
||||
|
||||
void SetZoom( double zoom );
|
||||
double GetZoom()
|
||||
{ return m_xZoom; }
|
||||
|
||||
// options
|
||||
// -------
|
||||
|
||||
void SetScrollOnThumbRelease( bool scrollOnThumbRelease = TRUE )
|
||||
{ m_scrollOnThumbRelease = scrollOnThumbRelease; }
|
||||
bool GetScrollOnThumbRelease()
|
||||
{ return m_scrollOnThumbRelease; }
|
||||
|
||||
void SetEnlargeAroundWindowCentre( bool enlargeAroundWindowCentre = TRUE )
|
||||
{ m_enlargeAroundWindowCentre = enlargeAroundWindowCentre; }
|
||||
bool GetEnlargeAroundWindowCentre()
|
||||
{ return m_enlargeAroundWindowCentre; }
|
||||
|
||||
// events (may be overridden)
|
||||
// --------------------------
|
||||
|
||||
void OnMoveUp( wxCommandEvent& event );
|
||||
void OnMoveDown( wxCommandEvent& event );
|
||||
|
||||
void OnEnlarge( wxCommandEvent& event );
|
||||
void OnShrink( wxCommandEvent& event );
|
||||
void OnZoomIn( wxCommandEvent& event );
|
||||
void OnZoomOut( wxCommandEvent& event );
|
||||
|
||||
void OnScroll2( wxScrollWinEvent& event );
|
||||
|
||||
// utilities
|
||||
// ---------
|
||||
|
||||
void RedrawEverything();
|
||||
void RedrawXAxis();
|
||||
void RedrawYAxis();
|
||||
|
||||
void ResetScrollbar();
|
||||
|
||||
private:
|
||||
friend class wxPlotArea;
|
||||
friend class wxPlotXAxisArea;
|
||||
friend class wxPlotYAxisArea;
|
||||
|
||||
double m_xUnitsPerValue;
|
||||
double m_xZoom;
|
||||
|
||||
wxList m_curves;
|
||||
wxList m_onOffCurves;
|
||||
|
||||
wxPlotArea *m_area;
|
||||
wxPlotXAxisArea *m_xaxis;
|
||||
wxPlotYAxisArea *m_yaxis;
|
||||
wxPlotCurve *m_current;
|
||||
|
||||
bool m_scrollOnThumbRelease;
|
||||
bool m_enlargeAroundWindowCentre;
|
||||
|
||||
DECLARE_CLASS(wxPlotWindow)
|
||||
DECLARE_EVENT_TABLE()
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// plot event macros
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
typedef void (wxEvtHandler::*wxPlotEventFunction)(wxPlotEvent&);
|
||||
|
||||
#if WXWIN_COMPATIBILITY_EVENT_TYPES
|
||||
|
||||
#define EVT_PLOT(id, fn) { wxEVT_PLOT_DOUBLECLICKED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL },
|
||||
#define EVT_PLOT_SEL_CHANGING(id, fn) { wxEVT_PLOT_SEL_CHANGING, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL },
|
||||
#define EVT_PLOT_SEL_CHANGED(id, fn) { wxEVT_PLOT_SEL_CHANGED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL },
|
||||
#define EVT_PLOT_CLICKED(id, fn) { wxEVT_PLOT_CLICKED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL },
|
||||
#define EVT_PLOT_DOUBLECLICKED(id, fn) { wxEVT_PLOT_DOUBLECLICKED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL },
|
||||
#define EVT_PLOT_ZOOM_IN(id, fn) { wxEVT_PLOT_ZOOM_IN, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL },
|
||||
#define EVT_PLOT_ZOOM_OUT(id, fn) { wxEVT_PLOT_ZOOM_OUT, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL },
|
||||
#define EVT_PLOT_VALUE_SEL_CREATING(id, fn) { wxEVT_PLOT_VALUE_SEL_CREATING, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL },
|
||||
#define EVT_PLOT_VALUE_SEL_CREATED(id, fn) { wxEVT_PLOT_VALUE_SEL_CREATED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL },
|
||||
#define EVT_PLOT_VALUE_SEL_CHANGING(id, fn) { wxEVT_PLOT_VALUE_SEL_CHANGING, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL },
|
||||
#define EVT_PLOT_VALUE_SEL_CHANGED(id, fn) { wxEVT_PLOT_VALUE_SEL_CHANGED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL },
|
||||
#define EVT_PLOT_AREA_SEL_CREATING(id, fn) { wxEVT_PLOT_AREA_SEL_CREATING, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL },
|
||||
#define EVT_PLOT_AREA_SEL_CREATED(id, fn) { wxEVT_PLOT_AREA_SEL_CREATED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL },
|
||||
#define EVT_PLOT_AREA_SEL_CHANGING(id, fn) { wxEVT_PLOT_AREA_SEL_CHANGING, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL },
|
||||
#define EVT_PLOT_AREA_SEL_CHANGED(id, fn) { wxEVT_PLOT_AREA_SEL_CHANGED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL },
|
||||
#define EVT_PLOT_BEGIN_X_LABEL_EDIT(id, fn) { wxEVT_PLOT_BEGIN_X_LABEL_EDIT, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL },
|
||||
#define EVT_PLOT_END_X_LABEL_EDIT(id, fn) { wxEVT_PLOT_END_X_LABEL_EDIT, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL },
|
||||
#define EVT_PLOT_BEGIN_Y_LABEL_EDIT(id, fn) { wxEVT_PLOT_BEGIN_Y_LABEL_EDIT, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL },
|
||||
#define EVT_PLOT_END_Y_LABEL_EDIT(id, fn) { wxEVT_PLOT_END_Y_LABEL_EDIT, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL },
|
||||
#define EVT_PLOT_BEGIN_TITLE_EDIT(id, fn) { wxEVT_PLOT_BEGIN_TITLE_EDIT, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL },
|
||||
#define EVT_PLOT_END_TITLE_EDIT(id, fn) { wxEVT_PLOT_END_TITLE_EDIT, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL },
|
||||
|
||||
#else
|
||||
|
||||
#define EVT_PLOT(id, fn) DECLARE_EVENT_TABLE_ENTRY(wxEVT_PLOT_DOUBLECLICKED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL ),
|
||||
#define EVT_PLOT_SEL_CHANGING(id, fn) DECLARE_EVENT_TABLE_ENTRY(wxEVT_PLOT_SEL_CHANGING, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL ),
|
||||
#define EVT_PLOT_SEL_CHANGED(id, fn) DECLARE_EVENT_TABLE_ENTRY(wxEVT_PLOT_SEL_CHANGED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL ),
|
||||
#define EVT_PLOT_CLICKED(id, fn) DECLARE_EVENT_TABLE_ENTRY(wxEVT_PLOT_CLICKED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL ),
|
||||
#define EVT_PLOT_DOUBLECLICKED(id, fn) DECLARE_EVENT_TABLE_ENTRY(wxEVT_PLOT_DOUBLECLICKED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL ),
|
||||
#define EVT_PLOT_ZOOM_IN(id, fn) DECLARE_EVENT_TABLE_ENTRY(wxEVT_PLOT_ZOOM_IN, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL ),
|
||||
#define EVT_PLOT_ZOOM_OUT(id, fn) DECLARE_EVENT_TABLE_ENTRY(wxEVT_PLOT_ZOOM_OUT, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL ),
|
||||
#define EVT_PLOT_VALUE_SEL_CREATING(id, fn) DECLARE_EVENT_TABLE_ENTRY(wxEVT_PLOT_VALUE_SEL_CREATING, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL ),
|
||||
#define EVT_PLOT_VALUE_SEL_CREATED(id, fn) DECLARE_EVENT_TABLE_ENTRY(wxEVT_PLOT_VALUE_SEL_CREATED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL ),
|
||||
#define EVT_PLOT_VALUE_SEL_CHANGING(id, fn) DECLARE_EVENT_TABLE_ENTRY(wxEVT_PLOT_VALUE_SEL_CHANGING, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL ),
|
||||
#define EVT_PLOT_VALUE_SEL_CHANGED(id, fn) DECLARE_EVENT_TABLE_ENTRY(wxEVT_PLOT_VALUE_SEL_CHANGED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL ),
|
||||
#define EVT_PLOT_AREA_SEL_CREATING(id, fn) DECLARE_EVENT_TABLE_ENTRY(wxEVT_PLOT_AREA_SEL_CREATING, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL ),
|
||||
#define EVT_PLOT_AREA_SEL_CREATED(id, fn) DECLARE_EVENT_TABLE_ENTRY(wxEVT_PLOT_AREA_SEL_CREATED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL ),
|
||||
#define EVT_PLOT_AREA_SEL_CHANGING(id, fn) DECLARE_EVENT_TABLE_ENTRY(wxEVT_PLOT_AREA_SEL_CHANGING, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL ),
|
||||
#define EVT_PLOT_AREA_SEL_CHANGED(id, fn) DECLARE_EVENT_TABLE_ENTRY(wxEVT_PLOT_AREA_SEL_CHANGED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL ),
|
||||
#define EVT_PLOT_BEGIN_X_LABEL_EDIT(id, fn) DECLARE_EVENT_TABLE_ENTRY(wxEVT_PLOT_BEGIN_X_LABEL_EDIT, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL ),
|
||||
#define EVT_PLOT_END_X_LABEL_EDIT(id, fn) DECLARE_EVENT_TABLE_ENTRY(wxEVT_PLOT_END_X_LABEL_EDIT, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL ),
|
||||
#define EVT_PLOT_BEGIN_Y_LABEL_EDIT(id, fn) DECLARE_EVENT_TABLE_ENTRY(wxEVT_PLOT_BEGIN_Y_LABEL_EDIT, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL ),
|
||||
#define EVT_PLOT_END_Y_LABEL_EDIT(id, fn) DECLARE_EVENT_TABLE_ENTRY(wxEVT_PLOT_END_Y_LABEL_EDIT, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL ),
|
||||
#define EVT_PLOT_BEGIN_TITLE_EDIT(id, fn) DECLARE_EVENT_TABLE_ENTRY(wxEVT_PLOT_BEGIN_TITLE_EDIT, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL ),
|
||||
#define EVT_PLOT_END_TITLE_EDIT(id, fn) DECLARE_EVENT_TABLE_ENTRY(wxEVT_PLOT_END_TITLE_EDIT, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNotifyEventFunction) (wxPlotEventFunction) & fn, (wxObject *) NULL ),
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
// _WX_PLOT_H_
|
@@ -1,8 +0,0 @@
|
||||
|
||||
// For /plot.cpp
|
||||
plot_up_bmp BITMAP "wx/plot/plot_up.bmp"
|
||||
plot_dwn_bmp BITMAP "wx/plot/plot_dwn.bmp"
|
||||
plot_enl_bmp BITMAP "wx/plot/plot_enl.bmp"
|
||||
plot_shr_bmp BITMAP "wx/plot/plot_shr.bmp"
|
||||
plot_zin_bmp BITMAP "wx/plot/plot_zin.bmp"
|
||||
plot_zot_bmp BITMAP "wx/plot/plot_zot.bmp"
|
181
contrib/include/wx/stc/SciLexer.h
Normal file
181
contrib/include/wx/stc/SciLexer.h
Normal file
@@ -0,0 +1,181 @@
|
||||
// Scintilla source code edit control
|
||||
// SciLexer - interface to the added lexer functions in the SciLexer version of the edit control
|
||||
// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
|
||||
// The License.txt file describes the conditions under which this software may be distributed.
|
||||
|
||||
#ifndef SCILEXER_H
|
||||
#define SCILEXER_H
|
||||
|
||||
// SciLexer features - not in standard Scintilla
|
||||
|
||||
#define SCLEX_CONTAINER 0
|
||||
#define SCLEX_NULL 1
|
||||
#define SCLEX_PYTHON 2
|
||||
#define SCLEX_CPP 3
|
||||
#define SCLEX_HTML 4
|
||||
#define SCLEX_XML 5
|
||||
#define SCLEX_PERL 6
|
||||
#define SCLEX_SQL 7
|
||||
#define SCLEX_VB 8
|
||||
#define SCLEX_PROPERTIES 9
|
||||
#define SCLEX_ERRORLIST 10
|
||||
#define SCLEX_MAKEFILE 11
|
||||
#define SCLEX_BATCH 12
|
||||
#define SCLEX_XCODE 13
|
||||
#define SCLEX_LATEX 14
|
||||
|
||||
// Lexical states for SCLEX_PYTHON
|
||||
#define SCE_P_DEFAULT 0
|
||||
#define SCE_P_COMMENTLINE 1
|
||||
#define SCE_P_NUMBER 2
|
||||
#define SCE_P_STRING 3
|
||||
#define SCE_P_CHARACTER 4
|
||||
#define SCE_P_WORD 5
|
||||
#define SCE_P_TRIPLE 6
|
||||
#define SCE_P_TRIPLEDOUBLE 7
|
||||
#define SCE_P_CLASSNAME 8
|
||||
#define SCE_P_DEFNAME 9
|
||||
#define SCE_P_OPERATOR 10
|
||||
#define SCE_P_IDENTIFIER 11
|
||||
#define SCE_P_COMMENTBLOCK 12
|
||||
#define SCE_P_STRINGEOL 13
|
||||
|
||||
// Lexical states for SCLEX_CPP, SCLEX_VB
|
||||
#define SCE_C_DEFAULT 0
|
||||
#define SCE_C_COMMENT 1
|
||||
#define SCE_C_COMMENTLINE 2
|
||||
#define SCE_C_COMMENTDOC 3
|
||||
#define SCE_C_NUMBER 4
|
||||
#define SCE_C_WORD 5
|
||||
#define SCE_C_STRING 6
|
||||
#define SCE_C_CHARACTER 7
|
||||
#define SCE_C_UUID 8
|
||||
#define SCE_C_PREPROCESSOR 9
|
||||
#define SCE_C_OPERATOR 10
|
||||
#define SCE_C_IDENTIFIER 11
|
||||
#define SCE_C_STRINGEOL 12
|
||||
|
||||
// Lexical states for SCLEX_HTML, SCLEX_xML
|
||||
#define SCE_H_DEFAULT 0
|
||||
#define SCE_H_TAG 1
|
||||
#define SCE_H_TAGUNKNOWN 2
|
||||
#define SCE_H_ATTRIBUTE 3
|
||||
#define SCE_H_ATTRIBUTEUNKNOWN 4
|
||||
#define SCE_H_NUMBER 5
|
||||
#define SCE_H_DOUBLESTRING 6
|
||||
#define SCE_H_SINGLESTRING 7
|
||||
#define SCE_H_OTHER 8
|
||||
#define SCE_H_COMMENT 9
|
||||
#define SCE_H_ENTITY 10
|
||||
// XML and ASP
|
||||
#define SCE_H_TAGEND 11
|
||||
#define SCE_H_XMLSTART 12
|
||||
#define SCE_H_XMLEND 13
|
||||
#define SCE_H_SCRIPT 14
|
||||
#define SCE_H_ASP 15
|
||||
#define SCE_H_ASPAT 16
|
||||
// Embedded Javascript
|
||||
#define SCE_HJ_START 40
|
||||
#define SCE_HJ_DEFAULT 41
|
||||
#define SCE_HJ_COMMENT 42
|
||||
#define SCE_HJ_COMMENTLINE 43
|
||||
#define SCE_HJ_COMMENTDOC 44
|
||||
#define SCE_HJ_NUMBER 45
|
||||
#define SCE_HJ_WORD 46
|
||||
#define SCE_HJ_KEYWORD 47
|
||||
#define SCE_HJ_DOUBLESTRING 48
|
||||
#define SCE_HJ_SINGLESTRING 49
|
||||
#define SCE_HJ_SYMBOLS 50
|
||||
#define SCE_HJ_STRINGEOL 51
|
||||
// ASP Javascript
|
||||
#define SCE_HJA_START 55
|
||||
#define SCE_HJA_DEFAULT 56
|
||||
#define SCE_HJA_COMMENT 57
|
||||
#define SCE_HJA_COMMENTLINE 58
|
||||
#define SCE_HJA_COMMENTDOC 59
|
||||
#define SCE_HJA_NUMBER 60
|
||||
#define SCE_HJA_WORD 61
|
||||
#define SCE_HJA_KEYWORD 62
|
||||
#define SCE_HJA_DOUBLESTRING 63
|
||||
#define SCE_HJA_SINGLESTRING 64
|
||||
#define SCE_HJA_SYMBOLS 65
|
||||
#define SCE_HJA_STRINGEOL 66
|
||||
// Embedded VBScript
|
||||
#define SCE_HB_START 70
|
||||
#define SCE_HB_DEFAULT 71
|
||||
#define SCE_HB_COMMENTLINE 72
|
||||
#define SCE_HB_NUMBER 73
|
||||
#define SCE_HB_WORD 74
|
||||
#define SCE_HB_STRING 75
|
||||
#define SCE_HB_IDENTIFIER 76
|
||||
#define SCE_HB_STRINGEOL 77
|
||||
// ASP VBScript
|
||||
#define SCE_HBA_START 80
|
||||
#define SCE_HBA_DEFAULT 81
|
||||
#define SCE_HBA_COMMENTLINE 82
|
||||
#define SCE_HBA_NUMBER 83
|
||||
#define SCE_HBA_WORD 84
|
||||
#define SCE_HBA_STRING 85
|
||||
#define SCE_HBA_IDENTIFIER 86
|
||||
#define SCE_HBA_STRINGEOL 87
|
||||
// Embedded Python
|
||||
#define SCE_HP_START 90
|
||||
#define SCE_HP_DEFAULT 91
|
||||
#define SCE_HP_COMMENTLINE 92
|
||||
#define SCE_HP_NUMBER 93
|
||||
#define SCE_HP_STRING 94
|
||||
#define SCE_HP_CHARACTER 95
|
||||
#define SCE_HP_WORD 96
|
||||
#define SCE_HP_TRIPLE 97
|
||||
#define SCE_HP_TRIPLEDOUBLE 98
|
||||
#define SCE_HP_CLASSNAME 99
|
||||
#define SCE_HP_DEFNAME 100
|
||||
#define SCE_HP_OPERATOR 101
|
||||
#define SCE_HP_IDENTIFIER 102
|
||||
// ASP Python
|
||||
#define SCE_HPA_START 105
|
||||
#define SCE_HPA_DEFAULT 106
|
||||
#define SCE_HPA_COMMENTLINE 107
|
||||
#define SCE_HPA_NUMBER 108
|
||||
#define SCE_HPA_STRING 109
|
||||
#define SCE_HPA_CHARACTER 110
|
||||
#define SCE_HPA_WORD 111
|
||||
#define SCE_HPA_TRIPLE 112
|
||||
#define SCE_HPA_TRIPLEDOUBLE 113
|
||||
#define SCE_HPA_CLASSNAME 114
|
||||
#define SCE_HPA_DEFNAME 115
|
||||
#define SCE_HPA_OPERATOR 116
|
||||
#define SCE_HPA_IDENTIFIER 117
|
||||
|
||||
// Lexical states for SCLEX_PERL
|
||||
#define SCE_PL_DEFAULT 0
|
||||
#define SCE_PL_HERE 1
|
||||
#define SCE_PL_COMMENTLINE 2
|
||||
#define SCE_PL_POD 3
|
||||
#define SCE_PL_NUMBER 4
|
||||
#define SCE_PL_WORD 5
|
||||
#define SCE_PL_STRING 6
|
||||
#define SCE_PL_CHARACTER 7
|
||||
#define SCE_PL_PUNCTUATION 8
|
||||
#define SCE_PL_PREPROCESSOR 9
|
||||
#define SCE_PL_OPERATOR 10
|
||||
#define SCE_PL_IDENTIFIER 11
|
||||
#define SCE_PL_SCALAR 12
|
||||
#define SCE_PL_ARRAY 13
|
||||
#define SCE_PL_HASH 14
|
||||
#define SCE_PL_SYMBOLTABLE 15
|
||||
#define SCE_PL_REF 16
|
||||
#define SCE_PL_REGEX 17
|
||||
#define SCE_PL_REGSUBST 18
|
||||
#define SCE_PL_LONGQUOTE 19
|
||||
#define SCE_PL_BACKTICKS 20
|
||||
#define SCE_PL_DATASECTION 21
|
||||
|
||||
// Lexical states for SCLEX_LATEX
|
||||
#define SCE_L_DEFAULT 0
|
||||
#define SCE_L_COMMAND 1
|
||||
#define SCE_L_TAG 2
|
||||
#define SCE_L_MATH 3
|
||||
#define SCE_L_COMMENT 4
|
||||
|
||||
#endif
|
File diff suppressed because it is too large
Load Diff
@@ -1,49 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_all.h
|
||||
// Purpose: includes all xh_*.h files
|
||||
// Author: Vaclav Slavik
|
||||
// Created: 2000/03/05
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Vaclav Slavik
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_ALL_H_
|
||||
#define _WX_XH_ALL_H_
|
||||
|
||||
|
||||
// Existing handlers:
|
||||
|
||||
#include "wx/xrc/xh_menu.h"
|
||||
#include "wx/xrc/xh_panel.h"
|
||||
#include "wx/xrc/xh_dlg.h"
|
||||
#include "wx/xrc/xh_bttn.h"
|
||||
#include "wx/xrc/xh_chckb.h"
|
||||
#include "wx/xrc/xh_gauge.h"
|
||||
#include "wx/xrc/xh_html.h"
|
||||
#include "wx/xrc/xh_spin.h"
|
||||
#include "wx/xrc/xh_sttxt.h"
|
||||
#include "wx/xrc/xh_slidr.h"
|
||||
#include "wx/xrc/xh_radbt.h"
|
||||
#include "wx/xrc/xh_radbx.h"
|
||||
#include "wx/xrc/xh_combo.h"
|
||||
#include "wx/xrc/xh_chckl.h"
|
||||
#include "wx/xrc/xh_choic.h"
|
||||
#include "wx/xrc/xh_sizer.h"
|
||||
#include "wx/xrc/xh_stbmp.h"
|
||||
#include "wx/xrc/xh_notbk.h"
|
||||
#include "wx/xrc/xh_text.h"
|
||||
#include "wx/xrc/xh_listb.h"
|
||||
#include "wx/xrc/xh_toolb.h"
|
||||
#include "wx/xrc/xh_bmpbt.h"
|
||||
#include "wx/xrc/xh_stbox.h"
|
||||
#include "wx/xrc/xh_scrol.h"
|
||||
#include "wx/xrc/xh_tree.h"
|
||||
#include "wx/xrc/xh_cald.h"
|
||||
#include "wx/xrc/xh_listc.h"
|
||||
#include "wx/xrc/xh_stlin.h"
|
||||
#include "wx/xrc/xh_bmp.h"
|
||||
#include "wx/xrc/xh_unkwn.h"
|
||||
#include "wx/xrc/xh_frame.h"
|
||||
|
||||
#endif // _WX_XMLRES_H_
|
@@ -1,38 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_bmp.h
|
||||
// Purpose: XML resource handler for wxBitmap and wxIcon
|
||||
// Author: Vaclav Slavik
|
||||
// Created: 2000/09/00
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Vaclav Slavik
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_BMP_H_
|
||||
#define _WX_XH_BMP_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_bmp.h"
|
||||
#endif
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
|
||||
|
||||
class WXXMLDLLEXPORT wxBitmapXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
public:
|
||||
wxBitmapXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
};
|
||||
|
||||
class WXXMLDLLEXPORT wxIconXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
public:
|
||||
wxIconXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
};
|
||||
|
||||
|
||||
#endif // _WX_XH_BMP_H_
|
@@ -1,30 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_bmpbt.h
|
||||
// Purpose: XML resource handler for bitmap buttons
|
||||
// Author: Brian Gavin
|
||||
// Created: 2000/03/05
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Brian Gavin
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_BMPBT_H_
|
||||
#define _WX_XH_BMPBT_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_bmpbt.h"
|
||||
#endif
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
|
||||
|
||||
class WXXMLDLLEXPORT wxBitmapButtonXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
public:
|
||||
wxBitmapButtonXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
};
|
||||
|
||||
|
||||
#endif // _WX_XH_BMPBT_H_
|
@@ -1,29 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_bttn.h
|
||||
// Purpose: XML resource handler for buttons
|
||||
// Author: Vaclav Slavik
|
||||
// Created: 2000/03/05
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Vaclav Slavik
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_BTTN_H_
|
||||
#define _WX_XH_BTTN_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_bttn.h"
|
||||
#endif
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
|
||||
class WXXMLDLLEXPORT wxButtonXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
public:
|
||||
wxButtonXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
};
|
||||
|
||||
|
||||
#endif // _WX_XH_BTTN_H_
|
@@ -1,29 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_cald.h
|
||||
// Purpose: XML resource handler for wxCalendarCtrl
|
||||
// Author: Brian Gavin
|
||||
// Created: 2000/09/09
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Brian Gavin
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_CALD_H_
|
||||
#define _WX_XH_CALD_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_cald.h"
|
||||
#endif
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
|
||||
class WXXMLDLLEXPORT wxCalendarCtrlXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
public:
|
||||
wxCalendarCtrlXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
};
|
||||
|
||||
|
||||
#endif // _WX_XH_CALD_H_
|
@@ -1,35 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_chckb.h
|
||||
// Purpose: XML resource handler for wxCheckBox
|
||||
// Author: Bob Mitchell
|
||||
// Created: 2000/03/21
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Bob Mitchell and Verant Interactive
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_CHCKB_H_
|
||||
#define _WX_XH_CHCKB_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_chckb.h"
|
||||
#endif
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
#include "wx/defs.h"
|
||||
|
||||
#if wxUSE_CHECKBOX
|
||||
|
||||
class WXXMLDLLEXPORT wxCheckBoxXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
public:
|
||||
wxCheckBoxXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#endif // _WX_XH_CHECKBOX_H_
|
||||
|
@@ -1,33 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_chckl.h
|
||||
// Purpose: XML resource handler for wxCheckListBox
|
||||
// Author: Bob Mitchell
|
||||
// Created: 2000/03/21
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Bob Mitchell and Verant Interactive
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_CHCKL_H_
|
||||
#define _WX_XH_CHCKL_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_chckl.h"
|
||||
#endif
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
|
||||
class WXXMLDLLEXPORT wxCheckListXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
public:
|
||||
wxCheckListXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
private:
|
||||
bool m_insideBox;
|
||||
wxArrayString strList;
|
||||
};
|
||||
|
||||
|
||||
|
||||
#endif // _WX_XH_CHECKLIST_H_
|
@@ -1,32 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_choic.h
|
||||
// Purpose: XML resource handler for wxChoice
|
||||
// Author: Bob Mitchell
|
||||
// Created: 2000/03/21
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Bob Mitchell and Verant Interactive
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_CHOIC_H_
|
||||
#define _WX_XH_CHOIC_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_choic.h"
|
||||
#endif
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
|
||||
class WXXMLDLLEXPORT wxChoiceXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
public:
|
||||
wxChoiceXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
private:
|
||||
bool m_insideBox;
|
||||
wxArrayString strList;
|
||||
};
|
||||
|
||||
|
||||
#endif // _WX_XH_CHOIC_H_
|
@@ -1,35 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_combo.h
|
||||
// Purpose: XML resource handler for wxComboBox
|
||||
// Author: Bob Mitchell
|
||||
// Created: 2000/03/21
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Bob Mitchell and Verant Interactive
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_COMBO_H_
|
||||
#define _WX_XH_COMBO_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_combo.h"
|
||||
#endif
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
|
||||
#if wxUSE_COMBOBOX
|
||||
|
||||
class WXXMLDLLEXPORT wxComboBoxXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
public:
|
||||
wxComboBoxXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
private:
|
||||
bool m_insideBox;
|
||||
wxArrayString strList;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
#endif // _WX_XH_COMBO_H_
|
@@ -1,29 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_dlg.h
|
||||
// Purpose: XML resource handler for dialogs
|
||||
// Author: Vaclav Slavik
|
||||
// Created: 2000/03/05
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Vaclav Slavik
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_DLG_H_
|
||||
#define _WX_XH_DLG_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_dlg.h"
|
||||
#endif
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
|
||||
class WXXMLDLLEXPORT wxDialogXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
public:
|
||||
wxDialogXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
};
|
||||
|
||||
|
||||
#endif // _WX_XH_DLG_H_
|
@@ -1,29 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_frame.h
|
||||
// Purpose: XML resource handler for dialogs
|
||||
// Author: Vaclav Slavik & Aleks.
|
||||
// Created: 2000/03/05
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Vaclav Slavik
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_FRAME_H_
|
||||
#define _WX_XH_FRAME_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_frame.h"
|
||||
#endif
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
|
||||
class WXXMLDLLEXPORT wxFrameXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
public:
|
||||
wxFrameXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
};
|
||||
|
||||
|
||||
#endif // _WX_XH_FRAME_H_
|
@@ -1,40 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_gauge.h
|
||||
// Purpose: XML resource handler for wxGauge
|
||||
// Author: Bob Mitchell
|
||||
// Created: 2000/03/21
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Bob Mitchell and Verant Interactive
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_GAUGE_H_
|
||||
#define _WX_XH_GAUGE_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_gauge.h"
|
||||
#endif
|
||||
|
||||
#include "wx/defs.h"
|
||||
|
||||
#if wxUSE_GAUGE
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
|
||||
|
||||
class WXXMLDLLEXPORT wxGaugeXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
enum
|
||||
{
|
||||
wxGAUGE_DEFAULT_RANGE = 100
|
||||
};
|
||||
|
||||
public:
|
||||
wxGaugeXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
#endif // _WX_XH_GAUGE_H_
|
@@ -1,34 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_html.h
|
||||
// Purpose: XML resource handler for wxHtmlWindow
|
||||
// Author: Bob Mitchell
|
||||
// Created: 2000/03/21
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Bob Mitchell and Verant Interactive
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_HTML_H_
|
||||
#define _WX_XH_HTML_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_html.h"
|
||||
#endif
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
|
||||
#include "wx/defs.h"
|
||||
|
||||
#if wxUSE_HTML
|
||||
|
||||
class WXXMLDLLEXPORT wxHtmlWindowXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
public:
|
||||
wxHtmlWindowXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
#endif // _WX_XH_SLIDER_H_
|
@@ -1,35 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_listb.h
|
||||
// Purpose: XML resource handler for wxListbox
|
||||
// Author: Bob Mitchell & Vaclav Slavik
|
||||
// Created: 2000/07/29
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Bob Mitchell & Vaclav Slavik
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_LISTB_H_
|
||||
#define _WX_XH_LISTB_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_listb.h"
|
||||
#endif
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
|
||||
#if wxUSE_LISTBOX
|
||||
|
||||
class WXXMLDLLEXPORT wxListBoxXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
public:
|
||||
wxListBoxXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
private:
|
||||
bool m_insideBox;
|
||||
wxArrayString strList;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
#endif // _WX_XH_LISTB_H_
|
@@ -1,29 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_listc.h
|
||||
// Purpose: XML resource handler for wxCalendarCtrl
|
||||
// Author: Brian Gavin
|
||||
// Created: 2000/09/09
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Brian Gavin
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_LISTC_H_
|
||||
#define _WX_XH_LISTC_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_listc.h"
|
||||
#endif
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
|
||||
class WXXMLDLLEXPORT wxListCtrlXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
public:
|
||||
wxListCtrlXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
};
|
||||
|
||||
|
||||
#endif // _WX_XH_LISTC_H_
|
@@ -1,40 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_menu.h
|
||||
// Purpose: XML resource handler for menus/menubars
|
||||
// Author: Vaclav Slavik
|
||||
// Created: 2000/03/05
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Vaclav Slavik
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_MENU_H_
|
||||
#define _WX_XH_MENU_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_menu.h"
|
||||
#endif
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
|
||||
class WXXMLDLLEXPORT wxMenuXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
public:
|
||||
wxMenuXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
|
||||
private:
|
||||
bool m_insideMenu;
|
||||
};
|
||||
|
||||
class WXXMLDLLEXPORT wxMenuBarXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
public:
|
||||
wxMenuBarXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
};
|
||||
|
||||
|
||||
#endif // _WX_XH_MENU_H_
|
@@ -1,37 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_notbk.h
|
||||
// Purpose: XML resource handler for wxNotebook
|
||||
// Author: Vaclav Slavik
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Vaclav Slavik
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_NOTBK_H_
|
||||
#define _WX_XH_NOTBK_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_notbk.h"
|
||||
#endif
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
|
||||
#if wxUSE_NOTEBOOK
|
||||
|
||||
class WXDLLEXPORT wxNotebook;
|
||||
|
||||
class WXXMLDLLEXPORT wxNotebookXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
public:
|
||||
wxNotebookXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
|
||||
private:
|
||||
bool m_isInside;
|
||||
wxNotebook *m_notebook;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
#endif // _WX_XH_NOTBK_H_
|
@@ -1,29 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_panel.h
|
||||
// Purpose: XML resource handler for panels
|
||||
// Author: Vaclav Slavik
|
||||
// Created: 2000/03/05
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Vaclav Slavik
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_PANEL_H_
|
||||
#define _WX_XH_PANEL_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_panel.h"
|
||||
#endif
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
|
||||
class WXXMLDLLEXPORT wxPanelXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
public:
|
||||
wxPanelXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
};
|
||||
|
||||
|
||||
#endif // _WX_XH_PANEL_H_
|
@@ -1,33 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_radbt.h
|
||||
// Purpose: XML resource handler for radio buttons
|
||||
// Author: Bob Mitchell
|
||||
// Created: 2000/03/21
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Bob Mitchell and Verant Interactive
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_RADBT_H_
|
||||
#define _WX_XH_RADBT_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_radbt.h"
|
||||
#endif
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
#include "wx/defs.h"
|
||||
|
||||
#if wxUSE_RADIOBOX
|
||||
|
||||
class WXXMLDLLEXPORT wxRadioButtonXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
public:
|
||||
wxRadioButtonXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
#endif // _WX_XH_RADIOBUTTON_H_
|
@@ -1,35 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_radbx.h
|
||||
// Purpose: XML resource handler for radio box
|
||||
// Author: Bob Mitchell
|
||||
// Created: 2000/03/21
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Bob Mitchell and Verant Interactive
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_RADBX_H_
|
||||
#define _WX_XH_RADBX_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_radbx.h"
|
||||
#endif
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
|
||||
#if wxUSE_RADIOBOX
|
||||
|
||||
class WXXMLDLLEXPORT wxRadioBoxXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
public:
|
||||
wxRadioBoxXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
private:
|
||||
bool m_insideBox;
|
||||
wxArrayString strList;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
#endif // _WX_XH_RADBX_H_
|
@@ -1,39 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_scrol.h
|
||||
// Purpose: XML resource handler for wxScrollBar
|
||||
// Author: Brian Gavin
|
||||
// Created: 2000/09/09
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Brian Gavin
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_SCROL_H_
|
||||
#define _WX_XH_SCROL_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_scrol.h"
|
||||
#endif
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
#include "wx/defs.h"
|
||||
|
||||
|
||||
|
||||
class WXXMLDLLEXPORT wxScrollBarXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
enum
|
||||
{
|
||||
wxSL_DEFAULT_VALUE = 0,
|
||||
wxSL_DEFAULT_MIN = 0,
|
||||
wxSL_DEFAULT_MAX = 100
|
||||
};
|
||||
|
||||
public:
|
||||
wxScrollBarXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
};
|
||||
|
||||
|
||||
#endif // _WX_XH_SCROL_H_
|
@@ -1,38 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_sizer.h
|
||||
// Purpose: XML resource handler for wxBoxSizer
|
||||
// Author: Vaclav Slavik
|
||||
// Created: 2000/04/24
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Vaclav Slavik
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_SIZER_H_
|
||||
#define _WX_XH_SIZER_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_sizer.h"
|
||||
#endif
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
|
||||
|
||||
class WXDLLEXPORT wxSizer;
|
||||
|
||||
class WXXMLDLLEXPORT wxSizerXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
public:
|
||||
wxSizerXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
|
||||
private:
|
||||
bool m_isInside;
|
||||
wxSizer *m_parentSizer;
|
||||
|
||||
bool IsSizerNode(wxXmlNode *node);
|
||||
};
|
||||
|
||||
|
||||
#endif // _WX_XH_BOXSIZER_H_
|
@@ -1,40 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_slidr.h
|
||||
// Purpose: XML resource handler for wxSlider
|
||||
// Author: Bob Mitchell
|
||||
// Created: 2000/03/21
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Bob Mitchell and Verant Interactive
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_SLIDR_H_
|
||||
#define _WX_XH_SLIDR_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_slidr.h"
|
||||
#endif
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
#include "wx/defs.h"
|
||||
|
||||
#if wxUSE_SLIDER
|
||||
|
||||
class WXXMLDLLEXPORT wxSliderXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
enum
|
||||
{
|
||||
wxSL_DEFAULT_VALUE = 0,
|
||||
wxSL_DEFAULT_MIN = 0,
|
||||
wxSL_DEFAULT_MAX = 100
|
||||
};
|
||||
|
||||
public:
|
||||
wxSliderXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
#endif // _WX_XH_SLIDER_H_
|
@@ -1,55 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_spin.h
|
||||
// Purpose: XML resource handler for wxSpinButton
|
||||
// Author: Bob Mitchell
|
||||
// Created: 2000/03/21
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Bob Mitchell and Verant Interactive
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_SPIN_H_
|
||||
#define _WX_XH_SPIN_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_spin.h"
|
||||
#endif
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
#include "wx/defs.h"
|
||||
|
||||
#if wxUSE_SPINBTN
|
||||
class WXXMLDLLEXPORT wxSpinButtonXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
enum
|
||||
{
|
||||
wxSP_DEFAULT_VALUE = 0,
|
||||
wxSP_DEFAULT_MIN = 0,
|
||||
wxSP_DEFAULT_MAX = 100
|
||||
};
|
||||
|
||||
public:
|
||||
wxSpinButtonXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
};
|
||||
#endif
|
||||
|
||||
#if wxUSE_SPINCTRL
|
||||
class WXXMLDLLEXPORT wxSpinCtrlXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
enum
|
||||
{
|
||||
wxSP_DEFAULT_VALUE = 0,
|
||||
wxSP_DEFAULT_MIN = 0,
|
||||
wxSP_DEFAULT_MAX = 100
|
||||
};
|
||||
|
||||
public:
|
||||
wxSpinCtrlXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
};
|
||||
#endif
|
||||
|
||||
#endif // _WX_XH_SPIN_H_
|
@@ -1,30 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_stbmp.h
|
||||
// Purpose: XML resource handler for wxStaticBitmap
|
||||
// Author: Vaclav Slavik
|
||||
// Created: 2000/04/22
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Vaclav Slavik
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_STBMP_H_
|
||||
#define _WX_XH_STBMP_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_stbmp.h"
|
||||
#endif
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
|
||||
|
||||
class WXXMLDLLEXPORT wxStaticBitmapXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
public:
|
||||
wxStaticBitmapXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
};
|
||||
|
||||
|
||||
#endif // _WX_XH_STBMP_H_
|
@@ -1,30 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_stbox.h
|
||||
// Purpose: XML resource handler for wxStaticBox
|
||||
// Author: Brian Gavin
|
||||
// Created: 2000/09/00
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Brian Gavin
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_STBOX_H_
|
||||
#define _WX_XH_STBOX_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_stbox.h"
|
||||
#endif
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
|
||||
|
||||
class WXXMLDLLEXPORT wxStaticBoxXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
public:
|
||||
wxStaticBoxXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
};
|
||||
|
||||
|
||||
#endif // _WX_XH_STBOX_H_
|
@@ -1,32 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_stlin.h
|
||||
// Purpose: XML resource handler for wxStaticLine
|
||||
// Author: Vaclav Slavik
|
||||
// Created: 2000/09/00
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Vaclav Slavik
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_STLIN_H_
|
||||
#define _WX_XH_STLIN_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_stlin.h"
|
||||
#endif
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
|
||||
#if wxUSE_STATLINE
|
||||
|
||||
class WXXMLDLLEXPORT wxStaticLineXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
public:
|
||||
wxStaticLineXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
#endif // _WX_XH_STLIN_H_
|
@@ -1,30 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_sttxt.h
|
||||
// Purpose: XML resource handler for wxStaticBitmap
|
||||
// Author: Bob Mitchell
|
||||
// Created: 2000/03/21
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Bob Mitchell
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_STTXT_H_
|
||||
#define _WX_XH_STTXT_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_sttxt.h"
|
||||
#endif
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
|
||||
|
||||
class WXXMLDLLEXPORT wxStaticTextXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
public:
|
||||
wxStaticTextXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
};
|
||||
|
||||
|
||||
#endif // _WX_XH_STBMP_H_
|
@@ -1,30 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_text.h
|
||||
// Purpose: XML resource handler for wxTextCtrl
|
||||
// Author: Aleksandras Gluchovas
|
||||
// Created: 2000/03/21
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Aleksandras Gluchovas
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_TEXT_H_
|
||||
#define _WX_XH_TEXT_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_text.h"
|
||||
#endif
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
|
||||
|
||||
class WXXMLDLLEXPORT wxTextCtrlXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
public:
|
||||
wxTextCtrlXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
};
|
||||
|
||||
|
||||
#endif // _WX_XH_TEXT_H_
|
@@ -1,38 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_toolb.h
|
||||
// Purpose: XML resource handler for wxBoxSizer
|
||||
// Author: Vaclav Slavik
|
||||
// Created: 2000/08/11
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Vaclav Slavik
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_TOOLB_H_
|
||||
#define _WX_XH_TOOLB_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_toolb.h"
|
||||
#endif
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
|
||||
#if wxUSE_TOOLBAR
|
||||
|
||||
class WXDLLEXPORT wxToolBar;
|
||||
|
||||
class WXXMLDLLEXPORT wxToolBarXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
public:
|
||||
wxToolBarXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
|
||||
private:
|
||||
bool m_isInside;
|
||||
wxToolBar *m_toolbar;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
#endif // _WX_XH_TOOLBAR_H_
|
@@ -1,29 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_tree.h
|
||||
// Purpose: XML resource handler for wxTreeCtrl
|
||||
// Author: Brian Gavin
|
||||
// Created: 2000/09/09
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Brian Gavin
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_TREE_H_
|
||||
#define _WX_XH_TREE_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_tree.h"
|
||||
#endif
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
|
||||
class WXXMLDLLEXPORT wxTreeCtrlXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
public:
|
||||
wxTreeCtrlXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
};
|
||||
|
||||
|
||||
#endif // _WX_XH_TREE_H_
|
@@ -1,30 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xh_unkwn.h
|
||||
// Purpose: XML resource handler for unkown widget
|
||||
// Author: Vaclav Slavik
|
||||
// Created: 2000/03/05
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Vaclav Slavik
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XH_UNKWN_H_
|
||||
#define _WX_XH_UNKWN_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xh_unkwn.h"
|
||||
#endif
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
|
||||
|
||||
class WXXMLDLLEXPORT wxUnknownWidgetXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
public:
|
||||
wxUnknownWidgetXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
};
|
||||
|
||||
|
||||
#endif // _WX_XH_UNKWN_H_
|
@@ -1,263 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xml.h
|
||||
// Purpose: wxXmlDocument - XML parser & data holder class
|
||||
// Author: Vaclav Slavik
|
||||
// Created: 2000/03/05
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Vaclav Slavik
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XML_H_
|
||||
#define _WX_XML_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xml.h"
|
||||
#endif
|
||||
|
||||
#include "wx/defs.h"
|
||||
#include "wx/string.h"
|
||||
#include "wx/object.h"
|
||||
#include "wx/list.h"
|
||||
|
||||
#ifdef WXXMLISDLL
|
||||
#define WXXMLDLLEXPORT WXDLLEXPORT
|
||||
#else
|
||||
#define WXXMLDLLEXPORT
|
||||
#endif
|
||||
|
||||
class WXXMLDLLEXPORT wxXmlNode;
|
||||
class WXXMLDLLEXPORT wxXmlProperty;
|
||||
class WXXMLDLLEXPORT wxXmlDocument;
|
||||
class WXXMLDLLEXPORT wxXmlIOHandler;
|
||||
class WXDLLEXPORT wxInputStream;
|
||||
class WXDLLEXPORT wxOutputStream;
|
||||
|
||||
|
||||
// Represents XML node type.
|
||||
enum wxXmlNodeType
|
||||
{
|
||||
// note: values are synchronized with xmlElementType from libxml
|
||||
wxXML_ELEMENT_NODE = 1,
|
||||
wxXML_ATTRIBUTE_NODE = 2,
|
||||
wxXML_TEXT_NODE = 3,
|
||||
wxXML_CDATA_SECTION_NODE = 4,
|
||||
wxXML_ENTITY_REF_NODE = 5,
|
||||
wxXML_ENTITY_NODE = 6,
|
||||
wxXML_PI_NODE = 7,
|
||||
wxXML_COMMENT_NODE = 8,
|
||||
wxXML_DOCUMENT_NODE = 9,
|
||||
wxXML_DOCUMENT_TYPE_NODE = 10,
|
||||
wxXML_DOCUMENT_FRAG_NODE = 11,
|
||||
wxXML_NOTATION_NODE = 12,
|
||||
wxXML_HTML_DOCUMENT_NODE = 13
|
||||
};
|
||||
|
||||
|
||||
// Types of XML files:
|
||||
|
||||
enum wxXmlIOType
|
||||
{
|
||||
wxXML_IO_AUTO = 0, // detect it automatically
|
||||
wxXML_IO_EXPAT, // use Expat to load from text/xml document
|
||||
wxXML_IO_TEXT_OUTPUT, // generic saver into text/xml
|
||||
wxXML_IO_BIN, // save in binary uncompressed proprietary format
|
||||
wxXML_IO_BINZ // svae in binary zlib-compressed proprietary format
|
||||
};
|
||||
|
||||
|
||||
// Represents node property(ies).
|
||||
// Example: in <img src="hello.gif" id="3"/> "src" is property with value
|
||||
// "hello.gif" and "id" is prop. with value "3".
|
||||
|
||||
class WXXMLDLLEXPORT wxXmlProperty
|
||||
{
|
||||
public:
|
||||
wxXmlProperty() : m_next(NULL) {}
|
||||
wxXmlProperty(const wxString& name, const wxString& value,
|
||||
wxXmlProperty *next)
|
||||
: m_name(name), m_value(value), m_next(next) {}
|
||||
|
||||
wxString GetName() const { return m_name; }
|
||||
wxString GetValue() const { return m_value; }
|
||||
wxXmlProperty *GetNext() const { return m_next; }
|
||||
|
||||
void SetName(const wxString& name) { m_name = name; }
|
||||
void SetValue(const wxString& value) { m_value = value; }
|
||||
void SetNext(wxXmlProperty *next) { m_next = next; }
|
||||
|
||||
private:
|
||||
wxString m_name;
|
||||
wxString m_value;
|
||||
wxXmlProperty *m_next;
|
||||
};
|
||||
|
||||
|
||||
|
||||
// Represents node in XML document. Node has name and may have content
|
||||
// and properties. Most common node types are wxXML_TEXT_NODE (name and props
|
||||
// are irrelevant) and wxXML_ELEMENT_NODE (e.g. in <title>hi</title> there is
|
||||
// element with name="title", irrelevant content and one child (wxXML_TEXT_NODE
|
||||
// with content="hi").
|
||||
//
|
||||
// If wxUSE_UNICODE is 0, all strings are encoded in UTF-8 encoding (same as
|
||||
// ASCII for characters 0-127). You can use wxMBConvUTF8 to convert then to
|
||||
// desired encoding:
|
||||
//
|
||||
// wxCSConv myConv("iso8859-2");
|
||||
// wxString s(cMB2WC(node->GetContent().c_str()), myConv);
|
||||
|
||||
class WXXMLDLLEXPORT wxXmlNode
|
||||
{
|
||||
public:
|
||||
wxXmlNode() : m_properties(NULL), m_parent(NULL),
|
||||
m_children(NULL), m_next(NULL) {}
|
||||
wxXmlNode(wxXmlNode *parent,wxXmlNodeType type,
|
||||
const wxString& name, const wxString& content,
|
||||
wxXmlProperty *props, wxXmlNode *next);
|
||||
~wxXmlNode();
|
||||
|
||||
// copy ctor & operator=. Note that this does NOT copy syblings
|
||||
// and parent pointer, i.e. m_parent and m_next will be NULL
|
||||
// after using copy ctor and are never unmodified by operator=.
|
||||
// On the other hand, it DOES copy children and properties.
|
||||
wxXmlNode(const wxXmlNode& node);
|
||||
wxXmlNode& operator=(const wxXmlNode& node);
|
||||
|
||||
// user-friendly creation:
|
||||
wxXmlNode(wxXmlNodeType type, const wxString& name,
|
||||
const wxString& content = wxEmptyString);
|
||||
void AddChild(wxXmlNode *child);
|
||||
void InsertChild(wxXmlNode *child, wxXmlNode *before_node);
|
||||
bool RemoveChild(wxXmlNode *child);
|
||||
void AddProperty(const wxString& name, const wxString& value);
|
||||
bool DeleteProperty(const wxString& name);
|
||||
|
||||
// access methods:
|
||||
wxXmlNodeType GetType() const { return m_type; }
|
||||
wxString GetName() const { return m_name; }
|
||||
wxString GetContent() const { return m_content; }
|
||||
|
||||
wxXmlNode *GetParent() const { return m_parent; }
|
||||
wxXmlNode *GetNext() const { return m_next; }
|
||||
wxXmlNode *GetChildren() const { return m_children; }
|
||||
|
||||
wxXmlProperty *GetProperties() const { return m_properties; }
|
||||
bool GetPropVal(const wxString& propName, wxString *value) const;
|
||||
wxString GetPropVal(const wxString& propName,
|
||||
const wxString& defaultVal) const;
|
||||
bool HasProp(const wxString& propName) const;
|
||||
|
||||
void SetType(wxXmlNodeType type) { m_type = type; }
|
||||
void SetName(const wxString& name) { m_name = name; }
|
||||
void SetContent(const wxString& con) { m_content = con; }
|
||||
|
||||
void SetParent(wxXmlNode *parent) { m_parent = parent; }
|
||||
void SetNext(wxXmlNode *next) { m_next = next; }
|
||||
void SetChildren(wxXmlNode *child) { m_children = child; }
|
||||
|
||||
void SetProperties(wxXmlProperty *prop) { m_properties = prop; }
|
||||
void AddProperty(wxXmlProperty *prop);
|
||||
|
||||
private:
|
||||
wxXmlNodeType m_type;
|
||||
wxString m_name;
|
||||
wxString m_content;
|
||||
wxXmlProperty *m_properties;
|
||||
wxXmlNode *m_parent, *m_children, *m_next;
|
||||
|
||||
void DoCopy(const wxXmlNode& node);
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
// This class holds XML data/document as parsed by libxml. Note that
|
||||
// internal representation is independant on libxml and you can use
|
||||
// it without libxml (see Load/SaveBinary).
|
||||
|
||||
class WXXMLDLLEXPORT wxXmlDocument : public wxObject
|
||||
{
|
||||
public:
|
||||
wxXmlDocument() : wxObject(), m_version(wxT("1.0")), m_root(NULL) {}
|
||||
wxXmlDocument(const wxString& filename,
|
||||
wxXmlIOType io_type = wxXML_IO_AUTO);
|
||||
wxXmlDocument(wxInputStream& stream,
|
||||
wxXmlIOType io_type = wxXML_IO_AUTO);
|
||||
~wxXmlDocument() { delete m_root; }
|
||||
|
||||
wxXmlDocument(const wxXmlDocument& doc);
|
||||
wxXmlDocument& operator=(const wxXmlDocument& doc);
|
||||
|
||||
// Parses .xml file and loads data. Returns TRUE on success, FALSE
|
||||
// otherwise.
|
||||
// NOTE: Any call to this method will result into linking against libxml
|
||||
// and app's binary size will grow by ca. 250kB
|
||||
bool Load(const wxString& filename, wxXmlIOType io_type = wxXML_IO_AUTO);
|
||||
bool Load(wxInputStream& stream, wxXmlIOType io_type = wxXML_IO_AUTO);
|
||||
|
||||
// Saves document as .xml file.
|
||||
bool Save(const wxString& filename,
|
||||
wxXmlIOType io_type = wxXML_IO_TEXT_OUTPUT) const;
|
||||
bool Save(wxOutputStream& stream,
|
||||
wxXmlIOType io_type = wxXML_IO_TEXT_OUTPUT) const;
|
||||
|
||||
bool IsOk() const { return m_root != NULL; }
|
||||
|
||||
// Returns root node of the document.
|
||||
wxXmlNode *GetRoot() const { return m_root; }
|
||||
|
||||
// Returns version of document (may be empty).
|
||||
wxString GetVersion() const { return m_version; }
|
||||
// Returns encoding of document (may be empty).
|
||||
// Note: this is the encoding original fail was saved in, *not* the
|
||||
// encoding of in-memory representation! Data in wxXmlNode are always
|
||||
// stored in wchar_t (in Unicode build) or UTF-8 encoded
|
||||
// (if wxUSE_UNICODE is 0).
|
||||
wxString GetEncoding() const { return m_encoding; }
|
||||
|
||||
// Write-access methods:
|
||||
void SetRoot(wxXmlNode *node) { delete m_root ; m_root = node; }
|
||||
void SetVersion(const wxString& version) { m_version = version; }
|
||||
void SetEncoding(const wxString& encoding) { m_encoding = encoding; }
|
||||
|
||||
static void AddHandler(wxXmlIOHandler *handler);
|
||||
static void CleanUpHandlers();
|
||||
static void InitStandardHandlers();
|
||||
|
||||
protected:
|
||||
static wxList *sm_handlers;
|
||||
|
||||
private:
|
||||
wxString m_version, m_encoding;
|
||||
wxXmlNode *m_root;
|
||||
|
||||
void DoCopy(const wxXmlDocument& doc);
|
||||
};
|
||||
|
||||
|
||||
|
||||
// wxXmlIOHandler takes care of loading and/or saving XML data.
|
||||
// see xmlio.h for available handlers
|
||||
|
||||
class WXXMLDLLEXPORT wxXmlIOHandler : public wxObject
|
||||
{
|
||||
public:
|
||||
wxXmlIOHandler() {}
|
||||
|
||||
virtual wxXmlIOType GetType() = 0;
|
||||
virtual bool CanLoad(wxInputStream& stream) = 0;
|
||||
virtual bool CanSave() = 0;
|
||||
|
||||
virtual bool Load(wxInputStream& stream, wxXmlDocument& doc) = 0;
|
||||
virtual bool Save(wxOutputStream& stream, const wxXmlDocument& doc) = 0;
|
||||
};
|
||||
|
||||
|
||||
|
||||
void wxXmlInitXmlModule();
|
||||
|
||||
#endif // _WX_XML_H_
|
@@ -1,85 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xmlio.h
|
||||
// Purpose: wxXmlIOHandler - XML I/O classes
|
||||
// Author: Vaclav Slavik
|
||||
// Created: 2000/07/24
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Vaclav Slavik
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XMLIO_H_
|
||||
#define _WX_XMLIO_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xmlio.h"
|
||||
#endif
|
||||
|
||||
#include "wx/defs.h"
|
||||
#include "wx/string.h"
|
||||
#include "wx/xrc/xml.h"
|
||||
|
||||
|
||||
class WXXMLDLLEXPORT wxXmlIOHandlerExpat : public wxXmlIOHandler
|
||||
{
|
||||
public:
|
||||
virtual wxXmlIOType GetType() { return wxXML_IO_EXPAT; }
|
||||
virtual bool CanLoad(wxInputStream& stream);
|
||||
virtual bool CanSave() { return FALSE; }
|
||||
|
||||
virtual bool Load(wxInputStream& stream, wxXmlDocument& doc);
|
||||
virtual bool Save(wxOutputStream& WXUNUSED(stream), const wxXmlDocument& WXUNUSED(doc))
|
||||
{ return FALSE; }
|
||||
};
|
||||
|
||||
|
||||
class WXXMLDLLEXPORT wxXmlIOHandlerWriter : public wxXmlIOHandler
|
||||
{
|
||||
public:
|
||||
virtual wxXmlIOType GetType() { return wxXML_IO_TEXT_OUTPUT; }
|
||||
virtual bool CanLoad(wxInputStream& WXUNUSED(stream)) { return FALSE; }
|
||||
virtual bool CanSave() { return TRUE; }
|
||||
|
||||
virtual bool Load(wxInputStream& WXUNUSED(stream), wxXmlDocument& WXUNUSED(doc))
|
||||
{ return FALSE; }
|
||||
virtual bool Save(wxOutputStream& stream, const wxXmlDocument& doc);
|
||||
};
|
||||
|
||||
|
||||
class WXXMLDLLEXPORT wxXmlIOHandlerBin : public wxXmlIOHandler
|
||||
{
|
||||
public:
|
||||
wxXmlIOHandlerBin() {}
|
||||
|
||||
virtual wxXmlIOType GetType() { return wxXML_IO_BIN; }
|
||||
virtual bool CanLoad(wxInputStream& stream);
|
||||
virtual bool CanSave() { return TRUE; }
|
||||
|
||||
virtual bool Load(wxInputStream& stream, wxXmlDocument& doc);
|
||||
virtual bool Save(wxOutputStream& stream, const wxXmlDocument& doc);
|
||||
|
||||
protected:
|
||||
wxString ReadHeader(wxInputStream& stream);
|
||||
void WriteHeader(wxOutputStream& stream, const wxString& header);
|
||||
};
|
||||
|
||||
|
||||
|
||||
#if wxUSE_ZLIB
|
||||
|
||||
class WXXMLDLLEXPORT wxXmlIOHandlerBinZ : public wxXmlIOHandlerBin
|
||||
{
|
||||
public:
|
||||
wxXmlIOHandlerBinZ() {}
|
||||
|
||||
virtual wxXmlIOType GetType() { return wxXML_IO_BINZ; }
|
||||
virtual bool CanLoad(wxInputStream& stream);
|
||||
|
||||
virtual bool Load(wxInputStream& stream, wxXmlDocument& doc);
|
||||
virtual bool Save(wxOutputStream& stream, const wxXmlDocument& doc);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#endif // _WX_XMLIO_H_
|
@@ -1,356 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: xmlres.h
|
||||
// Purpose: XML resources
|
||||
// Author: Vaclav Slavik
|
||||
// Created: 2000/03/05
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Vaclav Slavik
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_XMLRES_H_
|
||||
#define _WX_XMLRES_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "xmlres.h"
|
||||
#endif
|
||||
|
||||
#include "wx/defs.h"
|
||||
#include "wx/string.h"
|
||||
#include "wx/dynarray.h"
|
||||
#include "wx/datetime.h"
|
||||
#include "wx/list.h"
|
||||
#include "wx/gdicmn.h"
|
||||
#include "wx/filesys.h"
|
||||
#include "wx/bitmap.h"
|
||||
#include "wx/icon.h"
|
||||
|
||||
#include "wx/xrc/xml.h"
|
||||
|
||||
class WXDLLEXPORT wxMenu;
|
||||
class WXDLLEXPORT wxMenuBar;
|
||||
class WXDLLEXPORT wxDialog;
|
||||
class WXDLLEXPORT wxPanel;
|
||||
class WXDLLEXPORT wxWindow;
|
||||
class WXDLLEXPORT wxFrame;
|
||||
class WXDLLEXPORT wxToolBar;
|
||||
|
||||
class WXXMLDLLEXPORT wxXmlResourceHandler;
|
||||
|
||||
|
||||
// These macros indicate current version of XML resources (this information is
|
||||
// encoded in root node of XRC file as "version" property).
|
||||
//
|
||||
// Rules for increasing version number:
|
||||
// - change it only if you made incompatible change to the format. Addition of new
|
||||
// attribute to control handler is _not_ incompatible change, because older
|
||||
// versions of the library may ignore it.
|
||||
// - if you change version number, follow these steps:
|
||||
// - set major, minor and release numbers to respective version numbers of
|
||||
// the wxWindows library (see wx/version.h)
|
||||
// - reset revision to 0 unless the first three are same as before, in which
|
||||
// case you should increase revision by one
|
||||
#define WX_XMLRES_CURRENT_VERSION_MAJOR 2
|
||||
#define WX_XMLRES_CURRENT_VERSION_MINOR 3
|
||||
#define WX_XMLRES_CURRENT_VERSION_RELEASE 0
|
||||
#define WX_XMLRES_CURRENT_VERSION_REVISION 1
|
||||
#define WX_XMLRES_CURRENT_VERSION_STRING "2.3.0.1"
|
||||
|
||||
#define WX_XMLRES_CURRENT_VERSION \
|
||||
(WX_XMLRES_CURRENT_VERSION_MAJOR * 256*256*256 + \
|
||||
WX_XMLRES_CURRENT_VERSION_MINOR * 256*256 + \
|
||||
WX_XMLRES_CURRENT_VERSION_RELEASE * 256 + \
|
||||
WX_XMLRES_CURRENT_VERSION_REVISION)
|
||||
|
||||
class WXXMLDLLEXPORT wxXmlResourceDataRecord
|
||||
{
|
||||
public:
|
||||
wxXmlResourceDataRecord() : Doc(NULL), Time(wxDateTime::Now()) {}
|
||||
~wxXmlResourceDataRecord() {delete Doc;}
|
||||
|
||||
wxString File;
|
||||
wxXmlDocument *Doc;
|
||||
wxDateTime Time;
|
||||
};
|
||||
|
||||
|
||||
#ifdef WXXMLISDLL
|
||||
WX_DECLARE_EXPORTED_OBJARRAY(wxXmlResourceDataRecord, wxXmlResourceDataRecords);
|
||||
#else
|
||||
WX_DECLARE_OBJARRAY(wxXmlResourceDataRecord, wxXmlResourceDataRecords);
|
||||
#endif
|
||||
|
||||
|
||||
// This class holds XML resources from one or more .xml files
|
||||
// (or derived forms, either binary or zipped -- see manual for
|
||||
// details).
|
||||
|
||||
class WXXMLDLLEXPORT wxXmlResource : public wxObject
|
||||
{
|
||||
public:
|
||||
// Ctor. If use_locale is TRUE, translatable strings are
|
||||
// translated via _(). You can disable it by passing use_locale=FALSE
|
||||
// (for example if you provide resource file for each locale)
|
||||
wxXmlResource(bool use_locale = TRUE);
|
||||
wxXmlResource(const wxString& filemask, bool use_locale = TRUE);
|
||||
~wxXmlResource();
|
||||
|
||||
// Loads resources from XML files that match given filemask.
|
||||
// This method understands VFS (see filesys.h).
|
||||
bool Load(const wxString& filemask);
|
||||
|
||||
// Initialize handlers for all supported controls/windows. This will
|
||||
// make the executable quite big because it forces linking against
|
||||
// most of wxWin library
|
||||
void InitAllHandlers();
|
||||
|
||||
// Initialize only specific handler (or custom handler). Convention says
|
||||
// that handler name is equal to control's name plus 'XmlHandler', e.g.
|
||||
// wxTextCtrlXmlHandler, wxHtmlWindowXmlHandler. XML resource compiler
|
||||
// (xmlres) can create include file that contains initialization code for
|
||||
// all controls used within the resource.
|
||||
void AddHandler(wxXmlResourceHandler *handler);
|
||||
|
||||
// Removes all handlers
|
||||
void ClearHandlers();
|
||||
|
||||
// Loads menu from resource. Returns NULL on failure.
|
||||
wxMenu *LoadMenu(const wxString& name);
|
||||
|
||||
// Loads menubar from resource. Returns NULL on failure.
|
||||
wxMenuBar *LoadMenuBar(const wxString& name);
|
||||
|
||||
#if wxUSE_TOOLBAR
|
||||
// Loads toolbar
|
||||
wxToolBar *LoadToolBar(wxWindow *parent, const wxString& name);
|
||||
#endif
|
||||
|
||||
// Loads dialog. dlg points to parent window (if any). Second form
|
||||
// is used to finish creation of already existing instance (main reason
|
||||
// for this is that you may want to use derived class with new event table)
|
||||
// Example (typical usage):
|
||||
// MyDialog dlg;
|
||||
// wxTheXmlResource->LoadDialog(&dlg, mainFrame, "my_dialog");
|
||||
// dlg->ShowModal();
|
||||
wxDialog *LoadDialog(wxWindow *parent, const wxString& name);
|
||||
bool LoadDialog(wxDialog *dlg, wxWindow *parent, const wxString& name);
|
||||
|
||||
// Loads panel. panel points to parent window (if any). Second form
|
||||
// is used to finish creation of already existing instance.
|
||||
wxPanel *LoadPanel(wxWindow *parent, const wxString& name);
|
||||
bool LoadPanel(wxPanel *panel, wxWindow *parent, const wxString& name);
|
||||
|
||||
bool LoadFrame(wxFrame* frame, wxWindow *parent, const wxString& name);
|
||||
|
||||
// Loads bitmap or icon resource from file:
|
||||
wxBitmap LoadBitmap(const wxString& name);
|
||||
wxIcon LoadIcon(const wxString& name);
|
||||
|
||||
// Attaches unknown control into given panel/window/dialog:
|
||||
// (unknown controls are used in conjunction with <object class="unknown">)
|
||||
bool AttachUnknownControl(const wxString& name, wxWindow *control,
|
||||
wxWindow *parent = NULL);
|
||||
|
||||
// Returns numeric ID that is equivalent to string id used in XML
|
||||
// resource. To be used in event tables
|
||||
// Macro XMLID is provided for convenience
|
||||
static int GetXMLID(const wxChar *str_id);
|
||||
|
||||
// Returns version info (a.b.c.d = d+ 256*c + 256^2*b + 256^3*a)
|
||||
long GetVersion() const { return m_version; }
|
||||
|
||||
// Compares resources version to argument. Returns -1 if resources version
|
||||
// is less than the argument, +1 if greater and 0 if they equal.
|
||||
int CompareVersion(int major, int minor, int release, int revision) const
|
||||
{ return GetVersion() -
|
||||
(major*256*256*256 + minor*256*256 + release*256 + revision); }
|
||||
|
||||
protected:
|
||||
// Scans resources list for unloaded files and loads them. Also reloads
|
||||
// files that have been modified since last loading.
|
||||
void UpdateResources();
|
||||
|
||||
// Finds resource (calls UpdateResources) and returns node containing it
|
||||
wxXmlNode *FindResource(const wxString& name, const wxString& classname);
|
||||
|
||||
// Creates resource from info in given node:
|
||||
wxObject *CreateResFromNode(wxXmlNode *node, wxObject *parent, wxObject *instance = NULL);
|
||||
|
||||
bool GetUseLocale() { return m_useLocale; }
|
||||
|
||||
private:
|
||||
long m_version;
|
||||
|
||||
bool m_useLocale;
|
||||
wxList m_handlers;
|
||||
wxXmlResourceDataRecords m_data;
|
||||
#if wxUSE_FILESYSTEM
|
||||
wxFileSystem m_curFileSystem;
|
||||
wxFileSystem& GetCurFileSystem() { return m_curFileSystem; }
|
||||
#endif
|
||||
|
||||
friend class wxXmlResourceHandler;
|
||||
};
|
||||
|
||||
|
||||
// Global instance of resource class. For your convenience.
|
||||
extern WXXMLDLLEXPORT wxXmlResource *wxTheXmlResource;
|
||||
|
||||
// This macro translates string identifier (as used in XML resource,
|
||||
// e.g. <menuitem id="my_menu">...</menuitem>) to integer id that is needed by
|
||||
// wxWindows event tables.
|
||||
// Example:
|
||||
// BEGIN_EVENT_TABLE(MyFrame, wxFrame)
|
||||
// EVT_MENU(XMLID("quit"), MyFrame::OnQuit)
|
||||
// EVT_MENU(XMLID("about"), MyFrame::OnAbout)
|
||||
// EVT_MENU(XMLID("new"), MyFrame::OnNew)
|
||||
// EVT_MENU(XMLID("open"), MyFrame::OnOpen)
|
||||
// END_EVENT_TABLE()
|
||||
|
||||
#define XMLID(str_id) \
|
||||
wxXmlResource::GetXMLID(wxT(str_id))
|
||||
|
||||
|
||||
// This macro returns pointer to particular control in dialog
|
||||
// created using XML resources. You can use it to set/get values from
|
||||
// controls.
|
||||
// Example:
|
||||
// wxDialog dlg;
|
||||
// wxTheXmlResource->LoadDialog(&dlg, mainFrame, "my_dialog");
|
||||
// XMLCTRL(dlg, "my_textctrl", wxTextCtrl)->SetValue(wxT("default value"));
|
||||
|
||||
#ifdef __WXDEBUG__
|
||||
#define XMLCTRL(window, id, type) \
|
||||
(wxDynamicCast((window).FindWindow(XMLID(id)), type))
|
||||
#else
|
||||
#define XMLCTRL(window, id, type) \
|
||||
((type*)((window).FindWindow(XMLID(id))))
|
||||
#endif
|
||||
|
||||
|
||||
class WXXMLDLLEXPORT wxXmlResourceHandler : public wxObject
|
||||
{
|
||||
public:
|
||||
wxXmlResourceHandler();
|
||||
virtual ~wxXmlResourceHandler() {}
|
||||
|
||||
// Creates object (menu, dialog, control, ...) from XML node.
|
||||
// Should check for validity.
|
||||
// parent is higher-level object (usually window, dialog or panel)
|
||||
// that is often neccessary to create resource
|
||||
// if instance != NULL it should not create new instance via 'new' but
|
||||
// rather use this one and call its Create method
|
||||
wxObject *CreateResource(wxXmlNode *node, wxObject *parent,
|
||||
wxObject *instance);
|
||||
|
||||
// This one is called from CreateResource after variables
|
||||
// were filled
|
||||
virtual wxObject *DoCreateResource() = 0;
|
||||
|
||||
// Returns TRUE if it understands this node and can create
|
||||
// resource from it, FALSE otherwise.
|
||||
virtual bool CanHandle(wxXmlNode *node) = 0;
|
||||
|
||||
void SetParentResource(wxXmlResource *res) { m_resource = res; }
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
wxXmlResource *m_resource;
|
||||
wxArrayString m_styleNames;
|
||||
wxArrayInt m_styleValues;
|
||||
|
||||
// Variables (filled by CreateResource)
|
||||
wxXmlNode *m_node;
|
||||
wxString m_class;
|
||||
wxObject *m_parent, *m_instance;
|
||||
wxWindow *m_parentAsWindow, *m_instanceAsWindow;
|
||||
|
||||
// --- Handy methods:
|
||||
|
||||
// Returns true if the node has property class equal to classname,
|
||||
// e.g. <object class="wxDialog">
|
||||
bool IsOfClass(wxXmlNode *node, const wxString& classname)
|
||||
{ return node->GetPropVal(wxT("class"), wxEmptyString) == classname; }
|
||||
|
||||
// Gets node content from wxXML_ENTITY_NODE
|
||||
// (the problem is, <tag>content<tag> is represented as
|
||||
// wxXML_ENTITY_NODE name="tag", content=""
|
||||
// |-- wxXML_TEXT_NODE or
|
||||
// wxXML_CDATA_SECTION_NODE name="" content="content"
|
||||
wxString GetNodeContent(wxXmlNode *node);
|
||||
|
||||
// Check to see if a param exists
|
||||
bool HasParam(const wxString& param);
|
||||
|
||||
// Finds the node or returns NULL
|
||||
wxXmlNode *GetParamNode(const wxString& param);
|
||||
wxString GetParamValue(const wxString& param);
|
||||
|
||||
// Add style flag (e.g. wxMB_DOCKABLE) to list of flags
|
||||
// understood by this handler
|
||||
void AddStyle(const wxString& name, int value);
|
||||
|
||||
// Add styles common to all wxWindow-derived classes
|
||||
void AddWindowStyles();
|
||||
|
||||
// Gets style flags from text in form "flag | flag2| flag3 |..."
|
||||
// Only understads flags added with AddStyle
|
||||
int GetStyle(const wxString& param = wxT("style"), int defaults = 0);
|
||||
|
||||
// Gets text from param and does some convertions:
|
||||
// - replaces \n, \r, \t by respective chars (according to C syntax)
|
||||
// - replaces $ by & and $$ by $ (needed for $File => &File because of XML)
|
||||
// - calls wxGetTranslations (unless disabled in wxXmlResource)
|
||||
wxString GetText(const wxString& param);
|
||||
|
||||
// Return XMLID
|
||||
int GetID();
|
||||
wxString GetName();
|
||||
|
||||
// Get bool flag (1,t,yes,on,true are TRUE, everything else is FALSE)
|
||||
bool GetBool(const wxString& param, bool defaultv = FALSE);
|
||||
|
||||
// Get integer value from param
|
||||
long GetLong( const wxString& param, long defaultv = 0 );
|
||||
|
||||
// Get colour in HTML syntax (#RRGGBB)
|
||||
wxColour GetColour(const wxString& param);
|
||||
|
||||
// Get size/position (may be in dlg units):
|
||||
wxSize GetSize(const wxString& param = wxT("size"));
|
||||
wxPoint GetPosition(const wxString& param = wxT("pos"));
|
||||
|
||||
// Get dimension (may be in dlg units):
|
||||
wxCoord GetDimension(const wxString& param, wxCoord defaultv = 0);
|
||||
|
||||
// Get bitmap:
|
||||
wxBitmap GetBitmap(const wxString& param = wxT("bitmap"),
|
||||
wxSize size = wxDefaultSize);
|
||||
wxIcon GetIcon(const wxString& param = wxT("icon"),
|
||||
wxSize size = wxDefaultSize);
|
||||
|
||||
// Get font:
|
||||
wxFont GetFont(const wxString& param = wxT("font"));
|
||||
|
||||
// Sets common window options:
|
||||
void SetupWindow(wxWindow *wnd);
|
||||
|
||||
void CreateChildren(wxObject *parent, bool this_hnd_only = FALSE);
|
||||
void CreateChildrenPrivately(wxObject *parent, wxXmlNode *rootnode = NULL);
|
||||
wxObject *CreateResFromNode(wxXmlNode *node,
|
||||
wxObject *parent, wxObject *instance = NULL)
|
||||
{ return m_resource->CreateResFromNode(node, parent, instance); }
|
||||
|
||||
// helper
|
||||
#if wxUSE_FILESYSTEM
|
||||
wxFileSystem& GetCurFileSystem() { return m_resource->GetCurFileSystem(); }
|
||||
#endif
|
||||
};
|
||||
|
||||
#define ADD_STYLE(style) AddStyle(wxT(#style), style)
|
||||
|
||||
|
||||
void wxXmlInitResourceModule();
|
||||
|
||||
#endif // _WX_XMLRES_H_
|
@@ -1,6 +1,6 @@
|
||||
# $Id$
|
||||
|
||||
CONTRIB_SAMPLES=canvas fl gizmos mmedia net ogl plot stc xrc #applet
|
||||
CONTRIB_SAMPLES=mmedia ogl stc
|
||||
|
||||
all:
|
||||
@for d in $(CONTRIB_SAMPLES); do (cd $$d && $(MAKE)); done
|
||||
|
@@ -1,225 +0,0 @@
|
||||
# Microsoft Developer Studio Project File - Name="AniTestVC" - Package Owner=<4>
|
||||
# Microsoft Developer Studio Generated Build File, Format Version 6.00
|
||||
# ** DO NOT EDIT **
|
||||
|
||||
# TARGTYPE "Win32 (x86) Application" 0x0101
|
||||
|
||||
CFG=AniTestVC - Win32 UnivDebug
|
||||
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
|
||||
!MESSAGE use the Export Makefile command and run
|
||||
!MESSAGE
|
||||
!MESSAGE NMAKE /f "AniTestVC.mak".
|
||||
!MESSAGE
|
||||
!MESSAGE You can specify a configuration when running NMAKE
|
||||
!MESSAGE by defining the macro CFG on the command line. For example:
|
||||
!MESSAGE
|
||||
!MESSAGE NMAKE /f "AniTestVC.mak" CFG="AniTestVC - Win32 UnivDebug"
|
||||
!MESSAGE
|
||||
!MESSAGE Possible choices for configuration are:
|
||||
!MESSAGE
|
||||
!MESSAGE "AniTestVC - Win32 Release" (based on "Win32 (x86) Application")
|
||||
!MESSAGE "AniTestVC - Win32 Debug" (based on "Win32 (x86) Application")
|
||||
!MESSAGE "AniTestVC - Win32 Debug DLL" (based on "Win32 (x86) Application")
|
||||
!MESSAGE "AniTestVC - Win32 Release DLL" (based on "Win32 (x86) Application")
|
||||
!MESSAGE "AniTestVC - Win32 UnivRelease" (based on "Win32 (x86) Application")
|
||||
!MESSAGE "AniTestVC - Win32 UnivDebug" (based on "Win32 (x86) Application")
|
||||
!MESSAGE
|
||||
|
||||
# Begin Project
|
||||
# PROP AllowPerConfigDependencies 0
|
||||
# PROP Scc_ProjName ""
|
||||
# PROP Scc_LocalPath ""
|
||||
CPP=cl.exe
|
||||
MTL=midl.exe
|
||||
RSC=rc.exe
|
||||
|
||||
!IF "$(CFG)" == "AniTestVC - Win32 Release"
|
||||
|
||||
# PROP BASE Use_MFC 0
|
||||
# PROP BASE Use_Debug_Libraries 0
|
||||
# PROP BASE Output_Dir "Release"
|
||||
# PROP BASE Intermediate_Dir "Release"
|
||||
# PROP BASE Target_Dir ""
|
||||
# PROP Use_MFC 0
|
||||
# PROP Use_Debug_Libraries 0
|
||||
# PROP Output_Dir "Release"
|
||||
# PROP Intermediate_Dir "Release"
|
||||
# PROP Ignore_Export_Lib 0
|
||||
# PROP Target_Dir ""
|
||||
# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c
|
||||
# ADD CPP /nologo /MD /W3 /GX /O1 /Ob2 /I "../../../include" /I "../../../contrib/include" /I "../../../lib/msw" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "__WINDOWS__" /D "__WXMSW__" /D "__WIN95__" /D "__WIN32__" /D WINVER=0x0400 /D "STRICT" /FD /c
|
||||
# SUBTRACT CPP /YX
|
||||
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /o "NUL" /win32
|
||||
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /o "NUL" /win32
|
||||
# ADD BASE RSC /l 0x809 /d "NDEBUG"
|
||||
# ADD RSC /l 0x809 /d "NDEBUG"
|
||||
BSC32=bscmake.exe
|
||||
# ADD BASE BSC32 /nologo
|
||||
# ADD BSC32 /nologo
|
||||
LINK32=link.exe
|
||||
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib winmm.lib /nologo /subsystem:windows /machine:I386
|
||||
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib rpcrt4.lib wsock32.lib winmm.lib wxmsw.lib png.lib zlib.lib jpeg.lib tiff.lib regex.lib anim.lib /nologo /subsystem:windows /machine:I386 /nodefaultlib:"libc.lib" /nodefaultlib:"libci.lib" /nodefaultlib:"msvcrtd.lib" /out:"Release/anitest.exe" /libpath:"../../../lib"
|
||||
|
||||
!ELSEIF "$(CFG)" == "AniTestVC - Win32 Debug"
|
||||
|
||||
# PROP BASE Use_MFC 0
|
||||
# PROP BASE Use_Debug_Libraries 1
|
||||
# PROP BASE Output_Dir "Debug"
|
||||
# PROP BASE Intermediate_Dir "Debug"
|
||||
# PROP BASE Target_Dir ""
|
||||
# PROP Use_MFC 0
|
||||
# PROP Use_Debug_Libraries 1
|
||||
# PROP Output_Dir "Debug"
|
||||
# PROP Intermediate_Dir "Debug"
|
||||
# PROP Ignore_Export_Lib 0
|
||||
# PROP Target_Dir ""
|
||||
# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /FD /c
|
||||
# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "../../../include" /I "../../../contrib/include" /I "../../../lib/mswd" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "__WINDOWS__" /D "__WXMSW__" /D DEBUG=1 /D "__WXDEBUG__" /D "__WIN95__" /D "__WIN32__" /D WINVER=0x0400 /D "STRICT" /FD /c
|
||||
# SUBTRACT CPP /YX /Yc /Yu
|
||||
# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /o "NUL" /win32
|
||||
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /o "NUL" /win32
|
||||
# ADD BASE RSC /l 0x809 /d "_DEBUG"
|
||||
# ADD RSC /l 0x809 /d "_DEBUG"
|
||||
BSC32=bscmake.exe
|
||||
# ADD BASE BSC32 /nologo
|
||||
# ADD BSC32 /nologo
|
||||
LINK32=link.exe
|
||||
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib winmm.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
|
||||
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib rpcrt4.lib wsock32.lib winmm.lib wxmswd.lib pngd.lib zlibd.lib jpegd.lib tiffd.lib regexd.lib animd.lib /nologo /subsystem:windows /debug /machine:I386 /nodefaultlib:"libcd.lib" /nodefaultlib:"libcid.lib" /nodefaultlib:"msvcrt.lib" /out:"Debug/anitest.exe" /pdbtype:sept /libpath:"../../../lib"
|
||||
|
||||
!ELSEIF "$(CFG)" == "AniTestVC - Win32 Debug DLL"
|
||||
|
||||
# PROP BASE Use_MFC 0
|
||||
# PROP BASE Use_Debug_Libraries 1
|
||||
# PROP BASE Output_Dir "DebugDLL"
|
||||
# PROP BASE Intermediate_Dir "DebugDLL"
|
||||
# PROP BASE Target_Dir ""
|
||||
# PROP Use_MFC 0
|
||||
# PROP Use_Debug_Libraries 1
|
||||
# PROP Output_Dir "DebugDLL"
|
||||
# PROP Intermediate_Dir "DebugDLL"
|
||||
# PROP Ignore_Export_Lib 0
|
||||
# PROP Target_Dir ""
|
||||
# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /FD /c
|
||||
# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "../../../include" /I "../../../contrib/include" /I "../../../lib/mswdlld" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "__WINDOWS__" /D "__WXMSW__" /D DEBUG=1 /D "__WXDEBUG__" /D "__WIN95__" /D "__WIN32__" /D WINVER=0x0400 /D "STRICT" /D WXUSINGDLL=1 /Yu"wx/wxprec.h" /FD /c
|
||||
# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /o "NUL" /win32
|
||||
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /o "NUL" /win32
|
||||
# ADD BASE RSC /l 0x809 /d "_DEBUG"
|
||||
# ADD RSC /l 0x809 /d "_DEBUG"
|
||||
BSC32=bscmake.exe
|
||||
# ADD BASE BSC32 /nologo
|
||||
# ADD BSC32 /nologo
|
||||
LINK32=link.exe
|
||||
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib winmm.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
|
||||
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib rpcrt4.lib wsock32.lib winmm.lib wxmsw232d.lib animd.lib /nologo /subsystem:windows /debug /machine:I386 /nodefaultlib:"libcd.lib" /nodefaultlib:"libcid.lib" /out:"DebugDLL/anitest.exe" /pdbtype:sept /libpath:"../../../lib"
|
||||
|
||||
!ELSEIF "$(CFG)" == "AniTestVC - Win32 Release DLL"
|
||||
|
||||
# PROP BASE Use_MFC 0
|
||||
# PROP BASE Use_Debug_Libraries 0
|
||||
# PROP BASE Output_Dir "ReleaseDLL"
|
||||
# PROP BASE Intermediate_Dir "ReleaseDLL"
|
||||
# PROP BASE Target_Dir ""
|
||||
# PROP Use_MFC 0
|
||||
# PROP Use_Debug_Libraries 0
|
||||
# PROP Output_Dir "ReleaseDLL"
|
||||
# PROP Intermediate_Dir "ReleaseDLL"
|
||||
# PROP Ignore_Export_Lib 0
|
||||
# PROP Target_Dir ""
|
||||
# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c
|
||||
# ADD CPP /nologo /MD /W3 /GX /O1 /Ob2 /I "../../../include" /I "../../../contrib/include" /I "../../../lib/mswdll" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "__WINDOWS__" /D "__WXMSW__" /D "__WIN95__" /D "__WIN32__" /D WINVER=0x0400 /D "STRICT" /D WXUSINGDLL=1 /FD /c
|
||||
# SUBTRACT CPP /YX
|
||||
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /o "NUL" /win32
|
||||
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /o "NUL" /win32
|
||||
# ADD BASE RSC /l 0x809 /d "NDEBUG"
|
||||
# ADD RSC /l 0x809 /d "NDEBUG"
|
||||
BSC32=bscmake.exe
|
||||
# ADD BASE BSC32 /nologo
|
||||
# ADD BSC32 /nologo
|
||||
LINK32=link.exe
|
||||
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib winmm.lib /nologo /subsystem:windows /machine:I386
|
||||
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib rpcrt4.lib wsock32.lib winmm.lib wxmsw232.lib anim.lib /nologo /subsystem:windows /machine:I386 /nodefaultlib:"libc.lib" /nodefaultlib:"libci.lib" /out:"ReleaseDLL/anitest.exe" /libpath:"../../../lib"
|
||||
|
||||
!ELSEIF "$(CFG)" == "AniTestVC - Win32 UnivRelease"
|
||||
|
||||
# PROP BASE Use_MFC 0
|
||||
# PROP BASE Use_Debug_Libraries 0
|
||||
# PROP BASE Output_Dir "UnivRelease"
|
||||
# PROP BASE Intermediate_Dir "UnivRelease"
|
||||
# PROP BASE Ignore_Export_Lib 0
|
||||
# PROP BASE Target_Dir ""
|
||||
# PROP Use_MFC 0
|
||||
# PROP Use_Debug_Libraries 0
|
||||
# PROP Output_Dir "UnivRelease"
|
||||
# PROP Intermediate_Dir "UnivRelease"
|
||||
# PROP Ignore_Export_Lib 0
|
||||
# PROP Target_Dir ""
|
||||
# ADD BASE CPP /nologo /MD /W3 /GX /O1 /Ob2 /I "../../../include" /I "../../../contrib/include" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "__WINDOWS__" /D "__WXMSW__" /D "__WIN95__" /D "__WIN32__" /D WINVER=0x0400 /D "STRICT" /FD /c
|
||||
# SUBTRACT BASE CPP /YX
|
||||
# ADD CPP /nologo /MD /W3 /GX /O1 /Ob2 /I "../../../include" /I "../../../contrib/include" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "__WINDOWS__" /D "__WXMSW__" /D "__WXUNIVERSAL__" /D "__WIN95__" /D "__WIN32__" /D WINVER=0x0400 /D "STRICT" /FD /c
|
||||
# SUBTRACT CPP /YX
|
||||
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /o "NUL" /win32
|
||||
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /o "NUL" /win32
|
||||
# ADD BASE RSC /l 0x809 /d "NDEBUG"
|
||||
# ADD RSC /l 0x809 /d "NDEBUG"
|
||||
BSC32=bscmake.exe
|
||||
# ADD BASE BSC32 /nologo
|
||||
# ADD BSC32 /nologo
|
||||
LINK32=link.exe
|
||||
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib rpcrt4.lib wsock32.lib winmm.lib wx.lib png.lib zlib.lib jpeg.lib tiff.lib regex.lib /nologo /subsystem:windows /machine:I386 /nodefaultlib:"libc.lib" /nodefaultlib:"libci.lib" /nodefaultlib:"msvcrtd.lib" /out:"Release/minimal.exe" /libpath:"../../lib" /libpath:"../../contrib/lib"
|
||||
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib rpcrt4.lib wsock32.lib winmm.lib wx_univ.lib png.lib zlib.lib jpeg.lib tiff.lib regex.lib anim.lib /nologo /subsystem:windows /machine:I386 /nodefaultlib:"libc.lib" /nodefaultlib:"libci.lib" /nodefaultlib:"msvcrtd.lib" /out:"UnivRelease/anitest.exe" /libpath:"../../../lib"
|
||||
|
||||
!ELSEIF "$(CFG)" == "AniTestVC - Win32 UnivDebug"
|
||||
|
||||
# PROP BASE Use_MFC 0
|
||||
# PROP BASE Use_Debug_Libraries 1
|
||||
# PROP BASE Output_Dir "UnivDebug"
|
||||
# PROP BASE Intermediate_Dir "UnivDebug"
|
||||
# PROP BASE Ignore_Export_Lib 0
|
||||
# PROP BASE Target_Dir ""
|
||||
# PROP Use_MFC 0
|
||||
# PROP Use_Debug_Libraries 1
|
||||
# PROP Output_Dir "UnivDebug"
|
||||
# PROP Intermediate_Dir "UnivDebug"
|
||||
# PROP Ignore_Export_Lib 0
|
||||
# PROP Target_Dir ""
|
||||
# ADD BASE CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "../../../include" /I "../../../contrib/include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "__WINDOWS__" /D "__WXMSW__" /D DEBUG=1 /D "__WXDEBUG__" /D "__WIN95__" /D "__WIN32__" /D WINVER=0x0400 /D "STRICT" /Yu"wx/wxprec.h" /FD /c
|
||||
# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "../../../include" /I "../../../contrib/include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "__WINDOWS__" /D "__WXMSW__" /D "__WXUNIVERSAL__" /D DEBUG=1 /D "__WXDEBUG__" /D "__WIN95__" /D "__WIN32__" /D WINVER=0x0400 /D "STRICT" /FD /c
|
||||
# SUBTRACT CPP /YX /Yc /Yu
|
||||
# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /o "NUL" /win32
|
||||
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /o "NUL" /win32
|
||||
# ADD BASE RSC /l 0x809 /d "_DEBUG"
|
||||
# ADD RSC /l 0x809 /d "_DEBUG"
|
||||
BSC32=bscmake.exe
|
||||
# ADD BASE BSC32 /nologo
|
||||
# ADD BSC32 /nologo
|
||||
LINK32=link.exe
|
||||
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib rpcrt4.lib wsock32.lib winmm.lib wxd.lib pngd.lib zlibd.lib jpegd.lib tiffd.lib regexd.lib /nologo /subsystem:windows /debug /machine:I386 /nodefaultlib:"libcd.lib" /nodefaultlib:"libcid.lib" /nodefaultlib:"msvcrt.lib" /out:"Debug/minimal.exe" /pdbtype:sept /libpath:"../../lib" /libpath:"../../contrib/lib"
|
||||
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib rpcrt4.lib wsock32.lib winmm.lib wx_univd.lib pngd.lib zlibd.lib jpegd.lib tiffd.lib regexd.lib animd.lib /nologo /subsystem:windows /debug /machine:I386 /nodefaultlib:"libcd.lib" /nodefaultlib:"libcid.lib" /nodefaultlib:"msvcrt.lib" /out:"UnivDebug/anitest.exe" /pdbtype:sept /libpath:"../../../lib"
|
||||
|
||||
!ENDIF
|
||||
|
||||
# Begin Target
|
||||
|
||||
# Name "AniTestVC - Win32 Release"
|
||||
# Name "AniTestVC - Win32 Debug"
|
||||
# Name "AniTestVC - Win32 Debug DLL"
|
||||
# Name "AniTestVC - Win32 Release DLL"
|
||||
# Name "AniTestVC - Win32 UnivRelease"
|
||||
# Name "AniTestVC - Win32 UnivDebug"
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\anitest.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\anitest.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\anitest.rc
|
||||
# ADD BASE RSC /l 0x809
|
||||
# ADD RSC /l 0x809 /i "../../../include"
|
||||
# End Source File
|
||||
# End Target
|
||||
# End Project
|
@@ -1,29 +0,0 @@
|
||||
Microsoft Developer Studio Workspace File, Format Version 5.00
|
||||
# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
|
||||
|
||||
###############################################################################
|
||||
|
||||
Project: "AniTestVC"=.\AniTestVC.dsp - Package Owner=<4>
|
||||
|
||||
Package=<5>
|
||||
{{{
|
||||
}}}
|
||||
|
||||
Package=<4>
|
||||
{{{
|
||||
}}}
|
||||
|
||||
###############################################################################
|
||||
|
||||
Global:
|
||||
|
||||
Package=<5>
|
||||
{{{
|
||||
}}}
|
||||
|
||||
Package=<3>
|
||||
{{{
|
||||
}}}
|
||||
|
||||
###############################################################################
|
||||
|
@@ -1,24 +0,0 @@
|
||||
#
|
||||
# File: makefile.unx
|
||||
# Author: Julian Smart
|
||||
# Created: 1998
|
||||
# Updated:
|
||||
# Copyright: (c) 1998 Julian Smart
|
||||
#
|
||||
# "%W% %G%"
|
||||
#
|
||||
# Makefile for anitest example (UNIX).
|
||||
|
||||
top_srcdir = @top_srcdir@/..
|
||||
top_builddir = ../../..
|
||||
program_dir = contrib/samples/animate
|
||||
|
||||
PROGRAM=anitest
|
||||
|
||||
OBJECTS=$(PROGRAM).o
|
||||
|
||||
APPEXTRALIBS=$(top_builddir)/lib/libwx_anim.@WX_TARGET_LIBRARY_TYPE@
|
||||
APPEXTRADEFS=-I$(top_srcdir)/contrib/include
|
||||
|
||||
include $(top_builddir)/src/makeprog.env
|
||||
|
@@ -1,197 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: anitest.cpp
|
||||
// Purpose: Animation sample
|
||||
// Author: Julian Smart
|
||||
// Modified by:
|
||||
// Created: 02/07/2001
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) Julian Smart
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// ===========================================================================
|
||||
// declarations
|
||||
// ===========================================================================
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// headers
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
// For compilers that support precompilation, includes "wx/wx.h".
|
||||
#include "wx/wxprec.h"
|
||||
|
||||
#ifdef __BORLANDC__
|
||||
#pragma hdrstop
|
||||
#endif
|
||||
|
||||
#ifndef WX_PRECOMP
|
||||
#include "wx/wx.h"
|
||||
#endif
|
||||
|
||||
#if defined(__WXGTK__) || defined(__WXMOTIF__) || defined(__WXMAC__)
|
||||
#include "mondrian.xpm"
|
||||
#endif
|
||||
|
||||
#include "anitest.h"
|
||||
|
||||
IMPLEMENT_APP(MyApp)
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// global variables
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// event tables
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
BEGIN_EVENT_TABLE(MyFrame, wxFrame)
|
||||
EVT_MENU(ANITEST_ABOUT, MyFrame::OnAbout)
|
||||
EVT_MENU(ANITEST_QUIT, MyFrame::OnQuit)
|
||||
EVT_MENU(ANITEST_OPEN, MyFrame::OnOpen)
|
||||
|
||||
EVT_SIZE(MyFrame::OnSize)
|
||||
END_EVENT_TABLE()
|
||||
|
||||
// ===========================================================================
|
||||
// implementation
|
||||
// ===========================================================================
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// MyApp
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
// Initialise this in OnInit, not statically
|
||||
bool MyApp::OnInit()
|
||||
{
|
||||
// Create the main frame window
|
||||
|
||||
MyFrame* frame = new MyFrame((wxFrame *)NULL, -1, "Animation Demo",
|
||||
wxPoint(-1, -1), wxSize(500, 400),
|
||||
wxDEFAULT_FRAME_STYLE);
|
||||
|
||||
// Give it an icon
|
||||
#ifdef __WXMSW__
|
||||
frame->SetIcon(wxIcon("mdi_icn"));
|
||||
#else
|
||||
frame->SetIcon(wxIcon( mondrian_xpm ));
|
||||
#endif
|
||||
|
||||
// Make a menubar
|
||||
wxMenu *file_menu = new wxMenu;
|
||||
|
||||
file_menu->Append(ANITEST_OPEN, "&Open Animation...\tCtrl+O", "Open a GIF animation");
|
||||
file_menu->Append(ANITEST_QUIT, "&Exit\tAlt+X", "Quit the program");
|
||||
|
||||
wxMenu *help_menu = new wxMenu;
|
||||
help_menu->Append(ANITEST_ABOUT, "&About\tF1");
|
||||
|
||||
wxMenuBar *menu_bar = new wxMenuBar;
|
||||
|
||||
menu_bar->Append(file_menu, "&File");
|
||||
menu_bar->Append(help_menu, "&Help");
|
||||
|
||||
// Associate the menu bar with the frame
|
||||
frame->SetMenuBar(menu_bar);
|
||||
|
||||
frame->CreateStatusBar();
|
||||
|
||||
frame->Show(TRUE);
|
||||
|
||||
SetTopWindow(frame);
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// MyFrame
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
// Define my frame constructor
|
||||
MyFrame::MyFrame(wxWindow *parent,
|
||||
const wxWindowID id,
|
||||
const wxString& title,
|
||||
const wxPoint& pos,
|
||||
const wxSize& size,
|
||||
const long style)
|
||||
: wxFrame(parent, id, title, pos, size,
|
||||
style | wxNO_FULL_REPAINT_ON_RESIZE)
|
||||
{
|
||||
// m_animation = NULL;
|
||||
m_canvas = new MyCanvas(this, wxPoint(0, 0), wxSize(-1, -1));
|
||||
#if 0
|
||||
m_player.SetDestroyAnimation(FALSE);
|
||||
m_player.SetWindow(m_canvas);
|
||||
m_player.SetPosition(wxPoint(0, 0));
|
||||
#endif
|
||||
m_animationCtrl = new wxGIFAnimationCtrl(m_canvas, -1, wxEmptyString,
|
||||
wxPoint(0, 0), wxSize(200, 200));
|
||||
}
|
||||
|
||||
MyFrame::~MyFrame()
|
||||
{
|
||||
// m_player.Stop();
|
||||
}
|
||||
|
||||
void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
|
||||
{
|
||||
Close();
|
||||
}
|
||||
|
||||
void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event) )
|
||||
{
|
||||
(void)wxMessageBox("wxWindows 2 Animation Demo\n"
|
||||
"Author: Julian Smart (c) 2001\n",
|
||||
"About Animation Demo");
|
||||
}
|
||||
|
||||
void MyFrame::OnOpen(wxCommandEvent& event)
|
||||
{
|
||||
wxFileDialog dialog(this, wxT("Please choose an animated GIF"),
|
||||
wxEmptyString, wxEmptyString, wxT("*.gif"), wxOPEN);
|
||||
if (dialog.ShowModal() == wxID_OK)
|
||||
{
|
||||
wxString filename(dialog.GetPath());
|
||||
|
||||
m_animationCtrl->Stop();
|
||||
if (m_animationCtrl->LoadFile(filename))
|
||||
{
|
||||
m_animationCtrl->Play();
|
||||
}
|
||||
else
|
||||
{
|
||||
wxMessageBox("Sorry, this animation was not a valid animated GIF.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// MyCanvas
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
BEGIN_EVENT_TABLE(MyCanvas, wxScrolledWindow)
|
||||
EVT_PAINT(MyCanvas::OnPaint)
|
||||
END_EVENT_TABLE()
|
||||
|
||||
// Define a constructor for my canvas
|
||||
MyCanvas::MyCanvas(wxWindow *parent, const wxPoint& pos, const wxSize& size)
|
||||
: wxScrolledWindow(parent, -1, pos, size,
|
||||
wxSUNKEN_BORDER |
|
||||
wxNO_FULL_REPAINT_ON_RESIZE |
|
||||
wxVSCROLL | wxHSCROLL)
|
||||
{
|
||||
SetBackgroundColour(wxColour("YELLOW"));
|
||||
}
|
||||
|
||||
void MyCanvas::OnPaint(wxPaintEvent& event)
|
||||
{
|
||||
wxPaintDC dc(this);
|
||||
#if 0
|
||||
MyFrame* frame = (MyFrame*) GetParent();
|
||||
if (frame->GetPlayer().IsPlaying())
|
||||
{
|
||||
frame->GetPlayer().Draw(dc);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
@@ -1,71 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: anitest.cpp
|
||||
// Purpose: anitest sample
|
||||
// Author: Julian Smart
|
||||
// Modified by:
|
||||
// Created: 02/07/2001
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) Julian Smart
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include "wx/animate/animate.h"
|
||||
|
||||
// Define a new application
|
||||
class MyApp : public wxApp
|
||||
{
|
||||
public:
|
||||
bool OnInit();
|
||||
};
|
||||
|
||||
class MyCanvas : public wxScrolledWindow
|
||||
{
|
||||
public:
|
||||
MyCanvas(wxWindow *parent, const wxPoint& pos, const wxSize& size);
|
||||
void OnPaint(wxPaintEvent& event);
|
||||
|
||||
private:
|
||||
|
||||
DECLARE_EVENT_TABLE()
|
||||
};
|
||||
|
||||
// Define a new frame
|
||||
class MyFrame : public wxFrame
|
||||
{
|
||||
public:
|
||||
|
||||
MyFrame(wxWindow *parent, const wxWindowID id, const wxString& title,
|
||||
const wxPoint& pos, const wxSize& size, const long style);
|
||||
~MyFrame();
|
||||
|
||||
void OnAbout(wxCommandEvent& event);
|
||||
void OnQuit(wxCommandEvent& event);
|
||||
|
||||
void OnOpen(wxCommandEvent& event);
|
||||
|
||||
MyCanvas* GetCanvas() const { return m_canvas; }
|
||||
wxGIFAnimationCtrl* GetAnimationCtrl() const { return m_animationCtrl; }
|
||||
|
||||
#if 0
|
||||
wxAnimationPlayer& GetPlayer() { return m_player; }
|
||||
wxAnimationBase& GetAnimation() { return m_animation; }
|
||||
#endif
|
||||
|
||||
DECLARE_EVENT_TABLE()
|
||||
|
||||
protected:
|
||||
MyCanvas* m_canvas;
|
||||
wxGIFAnimationCtrl* m_animationCtrl;
|
||||
#if 0
|
||||
wxAnimationPlayer m_player;
|
||||
wxGIFAnimation m_animation;
|
||||
#endif
|
||||
};
|
||||
|
||||
// menu items ids
|
||||
enum
|
||||
{
|
||||
ANITEST_QUIT = 100,
|
||||
ANITEST_OPEN,
|
||||
ANITEST_ABOUT
|
||||
};
|
@@ -1,3 +0,0 @@
|
||||
mondrian ICON "mondrian.ico"
|
||||
#include "wx/msw/wx.rc"
|
||||
|
Binary file not shown.
Before Width: | Height: | Size: 7.1 KiB |
Binary file not shown.
Before Width: | Height: | Size: 34 KiB |
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user