Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Gizmos has been moved to wxCode.

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@45221 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Robin Dunn
2007-04-02 21:19:13 +00:00
parent e5abfc486b
commit 828ed945a7
29 changed files with 5564 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files

463
wxPython/contrib/gizmos/wxCode/src/gizmos/Makefile.in Normal file
View File

@@ -0,0 +1,463 @@
# =========================================================================
# This makefile was generated by
# Bakefile 0.2.1 (http://bakefile.sourceforge.net)
# Do not modify, all changes will be overwritten!
# =========================================================================
@MAKE_SET@
prefix = @prefix@
exec_prefix = @exec_prefix@
INSTALL = @INSTALL@
SHARED_LD_CXX = @SHARED_LD_CXX@
LIBEXT = @LIBEXT@
LIBPREFIX = @LIBPREFIX@
SO_SUFFIX = @SO_SUFFIX@
DLLIMP_SUFFIX = @DLLIMP_SUFFIX@
LN_S = @LN_S@
WINDRES = @WINDRES@
PIC_FLAG = @PIC_FLAG@
SONAME_FLAG = @SONAME_FLAG@
STRIP = @STRIP@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_DIR = @INSTALL_DIR@
BK_DEPS = @BK_DEPS@
BK_MAKE_PCH = @BK_MAKE_PCH@
srcdir = @srcdir@
top_srcdir = @top_srcdir@
libdir = @libdir@
includedir = @includedir@
DLLPREFIX = @DLLPREFIX@
LIBS = @LIBS@
AR = @AR@
AROPTIONS = @AROPTIONS@
RANLIB = @RANLIB@
CXX = @CXX@
CXXFLAGS = @CXXFLAGS@
CPPFLAGS = @CPPFLAGS@
LDFLAGS = @LDFLAGS@
VENDOR = @VENDOR@
WX_FLAVOUR = @WX_FLAVOUR@
WX_LIB_FLAVOUR = @WX_LIB_FLAVOUR@
TOOLKIT = @TOOLKIT@
TOOLKIT_LOWERCASE = @TOOLKIT_LOWERCASE@
TOOLKIT_VERSION = @TOOLKIT_VERSION@
TOOLCHAIN_FULLNAME = @TOOLCHAIN_FULLNAME@
EXTRALIBS = @EXTRALIBS@
EXTRALIBS_XML = @EXTRALIBS_XML@
EXTRALIBS_GUI = @EXTRALIBS_GUI@
HOST_SUFFIX = @HOST_SUFFIX@
wx_top_builddir = @wx_top_builddir@
### Variables: ###
DESTDIR =
WX_RELEASE = 2.9
WX_RELEASE_NODOT = 29
WX_VERSION_NODOT = $(WX_RELEASE_NODOT)0
LIBDIRNAME = $(wx_top_builddir)/lib
GIZMOSDLL_CXXFLAGS = $(__gizmosdll_PCH_INC) -D__WX$(TOOLKIT)__ \
$(__WXUNIV_DEFINE_p) $(__EXCEPTIONS_DEFINE_p) $(__RTTI_DEFINE_p) \
$(__THREAD_DEFINE_p) -I$(srcdir)/../../include -DWXUSINGDLL \
-DWXMAKINGDLL_GIZMOS $(PIC_FLAG) $(CPPFLAGS) $(CXXFLAGS)
GIZMOSDLL_OBJECTS = \
$(__gizmosdll___win32rc) \
gizmosdll_dynamicsash.o \
gizmosdll_editlbox.o \
gizmosdll_ledctrl.o \
gizmosdll_multicell.o \
gizmosdll_splittree.o \
gizmosdll_statpict.o
GIZMOSDLL_ODEP = $(___pch_wxprec_gizmosdll_wx_wxprec_h_gch___depname)
GIZMOS_XRCDLL_CXXFLAGS = $(__gizmos_xrcdll_PCH_INC) -D__WX$(TOOLKIT)__ \
$(__WXUNIV_DEFINE_p) $(__EXCEPTIONS_DEFINE_p) $(__RTTI_DEFINE_p) \
$(__THREAD_DEFINE_p) -I$(srcdir)/../../include -DWXUSINGDLL \
-DWXMAKINGDLL_GIZMOS_XRC $(PIC_FLAG) $(CPPFLAGS) $(CXXFLAGS)
GIZMOS_XRCDLL_OBJECTS = \
$(__gizmos_xrcdll___win32rc) \
gizmos_xrcdll_xh_statpict.o
GIZMOS_XRCDLL_ODEP = \
$(___pch_wxprec_gizmos_xrcdll_wx_wxprec_h_gch___depname)
GIZMOSLIB_CXXFLAGS = $(__gizmoslib_PCH_INC) -D__WX$(TOOLKIT)__ \
$(__WXUNIV_DEFINE_p) $(__EXCEPTIONS_DEFINE_p) $(__RTTI_DEFINE_p) \
$(__THREAD_DEFINE_p) -I$(srcdir)/../../include $(CPPFLAGS) $(CXXFLAGS)
GIZMOSLIB_OBJECTS = \
gizmoslib_dynamicsash.o \
gizmoslib_editlbox.o \
gizmoslib_ledctrl.o \
gizmoslib_multicell.o \
gizmoslib_splittree.o \
gizmoslib_statpict.o
GIZMOSLIB_ODEP = $(___pch_wxprec_gizmoslib_wx_wxprec_h_gch___depname)
GIZMOS_XRCLIB_CXXFLAGS = $(__gizmos_xrclib_PCH_INC) -D__WX$(TOOLKIT)__ \
$(__WXUNIV_DEFINE_p) $(__EXCEPTIONS_DEFINE_p) $(__RTTI_DEFINE_p) \
$(__THREAD_DEFINE_p) -I$(srcdir)/../../include $(CPPFLAGS) $(CXXFLAGS)
GIZMOS_XRCLIB_OBJECTS = \
gizmos_xrclib_xh_statpict.o
GIZMOS_XRCLIB_ODEP = \
$(___pch_wxprec_gizmos_xrclib_wx_wxprec_h_gch___depname)
### Conditionally set variables: ###
@COND_DEPS_TRACKING_0@CXXC = $(CXX)
@COND_DEPS_TRACKING_1@CXXC = $(BK_DEPS) $(CXX)
@COND_PLATFORM_MACOSX_1@WXMACVERSION_CMD = \
@COND_PLATFORM_MACOSX_1@ -compatibility_version 1.0 -current_version 1.0
@COND_USE_GUI_0@PORTNAME = base
@COND_USE_GUI_1@PORTNAME = $(TOOLKIT_LOWERCASE)$(TOOLKIT_VERSION)
@COND_TOOLKIT_MAC@WXBASEPORT = _carbon
@COND_PLATFORM_WIN32_1@WXCOMPILER = _gcc
@COND_OFFICIAL_BUILD_0_PLATFORM_WIN32_1@VENDORTAG = _$(VENDOR)
@COND_OFFICIAL_BUILD_1_PLATFORM_WIN32_1@VENDORTAG =
@COND_BUILD_DEBUG_DEBUG_FLAG_DEFAULT@WXDEBUGFLAG = d
@COND_DEBUG_FLAG_1@WXDEBUGFLAG = d
@COND_UNICODE_1@WXUNICODEFLAG = u
@COND_WXUNIV_1@WXUNIVNAME = univ
@COND_PLATFORM_WIN32_0@WXDLLNAMEPREFIXGUI = wx_$(PORTNAME)$(WXUNIVNAME)
@COND_PLATFORM_WIN32_1@WXDLLNAMEPREFIXGUI = \
@COND_PLATFORM_WIN32_1@ wx$(PORTNAME)$(WXUNIVNAME)$(WX_VERSION_NODOT)
@COND_PLATFORM_WIN32_0@WXDLLVERSIONTAG = -$(WX_RELEASE)
@COND_PLATFORM_WIN32_1@WXDLLVERSIONTAG =
@COND_MONOLITHIC_0@EXTRALIBS_FOR_BASE = $(EXTRALIBS)
@COND_MONOLITHIC_1@EXTRALIBS_FOR_BASE = $(EXTRALIBS) $(EXTRALIBS_GUI)
@COND_MONOLITHIC_0@EXTRALIBS_FOR_GUI = $(EXTRALIBS_GUI)
@COND_MONOLITHIC_1@EXTRALIBS_FOR_GUI =
COND_SHARED_1___gizmosdll___depname = \
$(LIBDIRNAME)/$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos_0)
@COND_SHARED_1@__gizmosdll___depname = $(COND_SHARED_1___gizmosdll___depname)
@COND_SHARED_1@__install_gizmosdll___depname = install_gizmosdll
@COND_SHARED_1@__uninstall_gizmosdll___depname = uninstall_gizmosdll
COND_PLATFORM_MACOSX_1___gizmosdll___macinstnamecmd = -install_name \
$(libdir)/$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos)
@COND_PLATFORM_MACOSX_1@__gizmosdll___macinstnamecmd = $(COND_PLATFORM_MACOSX_1___gizmosdll___macinstnamecmd)
COND_PLATFORM_OS2_1___gizmosdll___importlib = -import \
$(LIBDIRNAME)/$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos-$(WX_RELEASE)$(HOST_SUFFIX).$(DLLIMP_SUFFIX)
@COND_PLATFORM_OS2_1@__gizmosdll___importlib = $(COND_PLATFORM_OS2_1___gizmosdll___importlib)
COND_WINDOWS_IMPLIB_1___gizmosdll___importlib = \
-Wl,--out-implib=$(LIBDIRNAME)/$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos-$(WX_RELEASE)$(HOST_SUFFIX).$(DLLIMP_SUFFIX)
@COND_WINDOWS_IMPLIB_1@__gizmosdll___importlib = $(COND_WINDOWS_IMPLIB_1___gizmosdll___importlib)
@COND_GCC_PCH_1@__gizmosdll_PCH_INC = -I.pch/wxprec_gizmosdll
@COND_ICC_PCH_1@__gizmosdll_PCH_INC = -use_pch \
@COND_ICC_PCH_1@ .pch/wxprec_gizmosdll/wx/wxprec.h.gch
@COND_USE_PCH_1@___pch_wxprec_gizmosdll_wx_wxprec_h_gch___depname \
@COND_USE_PCH_1@ = .pch/wxprec_gizmosdll/wx/wxprec.h.gch
COND_USE_SOVERLINUX_1___gizmosdll___soname_flags = \
$(SONAME_FLAG)$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos)
@COND_USE_SOVERLINUX_1@__gizmosdll___soname_flags = $(COND_USE_SOVERLINUX_1___gizmosdll___soname_flags)
COND_USE_SOVERSOLARIS_1___gizmosdll___soname_flags = \
$(SONAME_FLAG)$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos_0)
@COND_USE_SOVERSOLARIS_1@__gizmosdll___soname_flags = $(COND_USE_SOVERSOLARIS_1___gizmosdll___soname_flags)
COND_USE_SOSYMLINKS_1___gizmosdll___so_symlinks_cmd = (cd $(LIBDIRNAME)/; rm -f \
$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos-$(WX_RELEASE)$(HOST_SUFFIX).$(DLLIMP_SUFFIX) \
$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos); \
$(LN_S) \
$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos_0) \
$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos); \
$(LN_S) \
$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos) \
$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos-$(WX_RELEASE)$(HOST_SUFFIX).$(DLLIMP_SUFFIX))
@COND_USE_SOSYMLINKS_1@__gizmosdll___so_symlinks_cmd = $(COND_USE_SOSYMLINKS_1___gizmosdll___so_symlinks_cmd)
COND_USE_SOSYMLINKS_1___gizmosdll___so_symlinks_inst_cmd = rm -f \
$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos-$(WX_RELEASE)$(HOST_SUFFIX).$(DLLIMP_SUFFIX) \
$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos); \
$(LN_S) \
$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos_0) \
$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos); \
$(LN_S) \
$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos) \
$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos-$(WX_RELEASE)$(HOST_SUFFIX).$(DLLIMP_SUFFIX)
@COND_USE_SOSYMLINKS_1@__gizmosdll___so_symlinks_inst_cmd = $(COND_USE_SOSYMLINKS_1___gizmosdll___so_symlinks_inst_cmd)
COND_USE_SOSYMLINKS_1___gizmosdll___so_symlinks_uninst_cmd = rm -f \
$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos) \
$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos-$(WX_RELEASE)$(HOST_SUFFIX).$(DLLIMP_SUFFIX)
@COND_USE_SOSYMLINKS_1@__gizmosdll___so_symlinks_uninst_cmd = $(COND_USE_SOSYMLINKS_1___gizmosdll___so_symlinks_uninst_cmd)
@COND_PLATFORM_WIN32_1@__gizmosdll___win32rc = gizmosdll_version_rc.o
COND_SHARED_1_USE_XRC_1___gizmos_xrcdll___depname = \
$(LIBDIRNAME)/$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos_0)
@COND_SHARED_1_USE_XRC_1@__gizmos_xrcdll___depname = $(COND_SHARED_1_USE_XRC_1___gizmos_xrcdll___depname)
@COND_SHARED_1_USE_XRC_1@__install_gizmos_xrcdll___depname \
@COND_SHARED_1_USE_XRC_1@ = install_gizmos_xrcdll
@COND_SHARED_1_USE_XRC_1@__uninstall_gizmos_xrcdll___depname \
@COND_SHARED_1_USE_XRC_1@ = uninstall_gizmos_xrcdll
COND_PLATFORM_MACOSX_1___gizmos_xrcdll___macinstnamecmd = -install_name \
$(libdir)/$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos)
@COND_PLATFORM_MACOSX_1@__gizmos_xrcdll___macinstnamecmd = $(COND_PLATFORM_MACOSX_1___gizmos_xrcdll___macinstnamecmd)
COND_PLATFORM_OS2_1___gizmos_xrcdll___importlib = -import \
$(LIBDIRNAME)/$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc-$(WX_RELEASE)$(HOST_SUFFIX).$(DLLIMP_SUFFIX)
@COND_PLATFORM_OS2_1@__gizmos_xrcdll___importlib = $(COND_PLATFORM_OS2_1___gizmos_xrcdll___importlib)
COND_WINDOWS_IMPLIB_1___gizmos_xrcdll___importlib = \
-Wl,--out-implib=$(LIBDIRNAME)/$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc-$(WX_RELEASE)$(HOST_SUFFIX).$(DLLIMP_SUFFIX)
@COND_WINDOWS_IMPLIB_1@__gizmos_xrcdll___importlib = $(COND_WINDOWS_IMPLIB_1___gizmos_xrcdll___importlib)
@COND_GCC_PCH_1@__gizmos_xrcdll_PCH_INC = -I.pch/wxprec_gizmos_xrcdll
@COND_ICC_PCH_1@__gizmos_xrcdll_PCH_INC = -use_pch \
@COND_ICC_PCH_1@ .pch/wxprec_gizmos_xrcdll/wx/wxprec.h.gch
@COND_USE_PCH_1@___pch_wxprec_gizmos_xrcdll_wx_wxprec_h_gch___depname \
@COND_USE_PCH_1@ = .pch/wxprec_gizmos_xrcdll/wx/wxprec.h.gch
COND_USE_SOVERLINUX_1___gizmos_xrcdll___soname_flags = \
$(SONAME_FLAG)$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos)
@COND_USE_SOVERLINUX_1@__gizmos_xrcdll___soname_flags = $(COND_USE_SOVERLINUX_1___gizmos_xrcdll___soname_flags)
COND_USE_SOVERSOLARIS_1___gizmos_xrcdll___soname_flags = \
$(SONAME_FLAG)$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos_0)
@COND_USE_SOVERSOLARIS_1@__gizmos_xrcdll___soname_flags = $(COND_USE_SOVERSOLARIS_1___gizmos_xrcdll___soname_flags)
COND_USE_SOSYMLINKS_1___gizmos_xrcdll___so_symlinks_cmd = (cd $(LIBDIRNAME)/; \
rm -f \
$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc-$(WX_RELEASE)$(HOST_SUFFIX).$(DLLIMP_SUFFIX) \
$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos); \
$(LN_S) \
$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos_0) \
$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos); \
$(LN_S) \
$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos) \
$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc-$(WX_RELEASE)$(HOST_SUFFIX).$(DLLIMP_SUFFIX))
@COND_USE_SOSYMLINKS_1@__gizmos_xrcdll___so_symlinks_cmd = $(COND_USE_SOSYMLINKS_1___gizmos_xrcdll___so_symlinks_cmd)
COND_USE_SOSYMLINKS_1___gizmos_xrcdll___so_symlinks_inst_cmd = rm -f \
$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc-$(WX_RELEASE)$(HOST_SUFFIX).$(DLLIMP_SUFFIX) \
$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos); \
$(LN_S) \
$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos_0) \
$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos); \
$(LN_S) \
$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos) \
$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc-$(WX_RELEASE)$(HOST_SUFFIX).$(DLLIMP_SUFFIX)
@COND_USE_SOSYMLINKS_1@__gizmos_xrcdll___so_symlinks_inst_cmd = $(COND_USE_SOSYMLINKS_1___gizmos_xrcdll___so_symlinks_inst_cmd)
COND_USE_SOSYMLINKS_1___gizmos_xrcdll___so_symlinks_uninst_cmd = rm -f \
$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos) \
$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc-$(WX_RELEASE)$(HOST_SUFFIX).$(DLLIMP_SUFFIX)
@COND_USE_SOSYMLINKS_1@__gizmos_xrcdll___so_symlinks_uninst_cmd = $(COND_USE_SOSYMLINKS_1___gizmos_xrcdll___so_symlinks_uninst_cmd)
@COND_PLATFORM_WIN32_1@__gizmos_xrcdll___win32rc = \
@COND_PLATFORM_WIN32_1@ gizmos_xrcdll_version_rc.o
COND_MONOLITHIC_0___WXLIB_XRC_p = \
-lwx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_xrc-$(WX_RELEASE)$(HOST_SUFFIX)
@COND_MONOLITHIC_0@__WXLIB_XRC_p = $(COND_MONOLITHIC_0___WXLIB_XRC_p)
COND_MONOLITHIC_0___WXLIB_XML_p = \
-lwx_base$(WXBASEPORT)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_xml-$(WX_RELEASE)$(HOST_SUFFIX)
@COND_MONOLITHIC_0@__WXLIB_XML_p = $(COND_MONOLITHIC_0___WXLIB_XML_p)
COND_SHARED_0___gizmoslib___depname = \
$(LIBDIRNAME)/$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos-$(WX_RELEASE)$(HOST_SUFFIX)$(LIBEXT)
@COND_SHARED_0@__gizmoslib___depname = $(COND_SHARED_0___gizmoslib___depname)
@COND_SHARED_0@__install_gizmoslib___depname = install_gizmoslib
@COND_SHARED_0@__uninstall_gizmoslib___depname = uninstall_gizmoslib
@COND_GCC_PCH_1@__gizmoslib_PCH_INC = -I.pch/wxprec_gizmoslib
@COND_ICC_PCH_1@__gizmoslib_PCH_INC = -use_pch \
@COND_ICC_PCH_1@ .pch/wxprec_gizmoslib/wx/wxprec.h.gch
@COND_USE_PCH_1@___pch_wxprec_gizmoslib_wx_wxprec_h_gch___depname \
@COND_USE_PCH_1@ = .pch/wxprec_gizmoslib/wx/wxprec.h.gch
COND_SHARED_0_USE_XRC_1___gizmos_xrclib___depname = \
$(LIBDIRNAME)/$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc-$(WX_RELEASE)$(HOST_SUFFIX)$(LIBEXT)
@COND_SHARED_0_USE_XRC_1@__gizmos_xrclib___depname = $(COND_SHARED_0_USE_XRC_1___gizmos_xrclib___depname)
@COND_SHARED_0_USE_XRC_1@__install_gizmos_xrclib___depname \
@COND_SHARED_0_USE_XRC_1@ = install_gizmos_xrclib
@COND_SHARED_0_USE_XRC_1@__uninstall_gizmos_xrclib___depname \
@COND_SHARED_0_USE_XRC_1@ = uninstall_gizmos_xrclib
@COND_GCC_PCH_1@__gizmos_xrclib_PCH_INC = -I.pch/wxprec_gizmos_xrclib
@COND_ICC_PCH_1@__gizmos_xrclib_PCH_INC = -use_pch \
@COND_ICC_PCH_1@ .pch/wxprec_gizmos_xrclib/wx/wxprec.h.gch
@COND_USE_PCH_1@___pch_wxprec_gizmos_xrclib_wx_wxprec_h_gch___depname \
@COND_USE_PCH_1@ = .pch/wxprec_gizmos_xrclib/wx/wxprec.h.gch
@COND_WXUNIV_1@__WXUNIV_DEFINE_p_0 = --define __WXUNIVERSAL__
@COND_USE_EXCEPTIONS_0@__EXCEPTIONS_DEFINE_p_0 = --define wxNO_EXCEPTIONS
@COND_USE_RTTI_0@__RTTI_DEFINE_p_0 = --define wxNO_RTTI
@COND_USE_THREADS_0@__THREAD_DEFINE_p_0 = --define wxNO_THREADS
@COND_PLATFORM_MACOSX_0_USE_SOVERSION_1@__gizmos = .$(SO_SUFFIX).0
@COND_PLATFORM_MACOSX_1_USE_SOVERSION_1@__gizmos = .0.$(SO_SUFFIX)
@COND_USE_SOVERSION_0@__gizmos = .$(SO_SUFFIX)
@COND_PLATFORM_MACOSX_0_USE_SOVERCYGWIN_0_USE_SOVERSION_1@__gizmos_0 \
@COND_PLATFORM_MACOSX_0_USE_SOVERCYGWIN_0_USE_SOVERSION_1@ = \
@COND_PLATFORM_MACOSX_0_USE_SOVERCYGWIN_0_USE_SOVERSION_1@ .$(SO_SUFFIX).0.0.0
@COND_PLATFORM_MACOSX_1_USE_SOVERSION_1@__gizmos_0 = .0.0.0.$(SO_SUFFIX)
@COND_USE_SOVERCYGWIN_1_USE_SOVERSION_1@__gizmos_0 = -0.$(SO_SUFFIX)
@COND_USE_SOVERSION_0@__gizmos_0 = .$(SO_SUFFIX)
@COND_TOOLKIT_MSW@__RCDEFDIR_p = --include-dir \
@COND_TOOLKIT_MSW@ $(LIBDIRNAME)/wx/include/$(TOOLCHAIN_FULLNAME)
COND_MONOLITHIC_1___WXLIB_MONO_p = \
-lwx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)-$(WX_RELEASE)$(HOST_SUFFIX)
@COND_MONOLITHIC_1@__WXLIB_MONO_p = $(COND_MONOLITHIC_1___WXLIB_MONO_p)
@COND_USE_GUI_1_WXUSE_LIBTIFF_BUILTIN@__LIB_TIFF_p \
@COND_USE_GUI_1_WXUSE_LIBTIFF_BUILTIN@ = \
@COND_USE_GUI_1_WXUSE_LIBTIFF_BUILTIN@ -lwxtiff$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)-$(WX_RELEASE)$(HOST_SUFFIX)
@COND_USE_GUI_1_WXUSE_LIBJPEG_BUILTIN@__LIB_JPEG_p \
@COND_USE_GUI_1_WXUSE_LIBJPEG_BUILTIN@ = \
@COND_USE_GUI_1_WXUSE_LIBJPEG_BUILTIN@ -lwxjpeg$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)-$(WX_RELEASE)$(HOST_SUFFIX)
@COND_USE_GUI_1_WXUSE_LIBPNG_BUILTIN@__LIB_PNG_p \
@COND_USE_GUI_1_WXUSE_LIBPNG_BUILTIN@ = \
@COND_USE_GUI_1_WXUSE_LIBPNG_BUILTIN@ -lwxpng$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)-$(WX_RELEASE)$(HOST_SUFFIX)
@COND_WXUSE_ZLIB_BUILTIN@__LIB_ZLIB_p = \
@COND_WXUSE_ZLIB_BUILTIN@ -lwxzlib$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)-$(WX_RELEASE)$(HOST_SUFFIX)
@COND_WXUSE_ODBC_BUILTIN@__LIB_ODBC_p = \
@COND_WXUSE_ODBC_BUILTIN@ -lwxodbc$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)-$(WX_RELEASE)$(HOST_SUFFIX)
COND_WXUSE_REGEX_BUILTIN___LIB_REGEX_p = \
-lwxregex$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)-$(WX_RELEASE)$(HOST_SUFFIX)
@COND_WXUSE_REGEX_BUILTIN@__LIB_REGEX_p = $(COND_WXUSE_REGEX_BUILTIN___LIB_REGEX_p)
@COND_WXUSE_EXPAT_BUILTIN@__LIB_EXPAT_p = \
@COND_WXUSE_EXPAT_BUILTIN@ -lwxexpat$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)-$(WX_RELEASE)$(HOST_SUFFIX)
COND_MONOLITHIC_0___WXLIB_CORE_p = \
-lwx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_core-$(WX_RELEASE)$(HOST_SUFFIX)
@COND_MONOLITHIC_0@__WXLIB_CORE_p = $(COND_MONOLITHIC_0___WXLIB_CORE_p)
COND_MONOLITHIC_0___WXLIB_BASE_p = \
-lwx_base$(WXBASEPORT)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)-$(WX_RELEASE)$(HOST_SUFFIX)
@COND_MONOLITHIC_0@__WXLIB_BASE_p = $(COND_MONOLITHIC_0___WXLIB_BASE_p)
@COND_WXUNIV_1@__WXUNIV_DEFINE_p = -D__WXUNIVERSAL__
@COND_USE_EXCEPTIONS_0@__EXCEPTIONS_DEFINE_p = -DwxNO_EXCEPTIONS
@COND_USE_RTTI_0@__RTTI_DEFINE_p = -DwxNO_RTTI
@COND_USE_THREADS_0@__THREAD_DEFINE_p = -DwxNO_THREADS
### Targets: ###
all: $(__gizmosdll___depname) $(__gizmos_xrcdll___depname) $(__gizmoslib___depname) $(__gizmos_xrclib___depname)
install: all $(__install_gizmosdll___depname) $(__install_gizmos_xrcdll___depname) $(__install_gizmoslib___depname) $(__install_gizmos_xrclib___depname)
$(INSTALL_DIR) $(DESTDIR)$(includedir)/wx-$(WX_RELEASE)$(WX_FLAVOUR)
for f in wx/gizmos/dynamicsash.h wx/gizmos/editlbox.h wx/gizmos/ledctrl.h wx/gizmos/multicell.h wx/gizmos/splittree.h wx/gizmos/statpict.h wx/gizmos/gizmos.h wx/gizmos/xh_statpict.h; do \
if test ! -d $(DESTDIR)$(includedir)/wx-$(WX_RELEASE)$(WX_FLAVOUR)/`dirname $$f` ; then \
$(INSTALL_DIR) $(DESTDIR)$(includedir)/wx-$(WX_RELEASE)$(WX_FLAVOUR)/`dirname $$f`; \
fi; \
$(INSTALL_DATA) $(srcdir)/../../include//$$f $(DESTDIR)$(includedir)/wx-$(WX_RELEASE)$(WX_FLAVOUR)/$$f; \
done
uninstall: $(__uninstall_gizmosdll___depname) $(__uninstall_gizmos_xrcdll___depname) $(__uninstall_gizmoslib___depname) $(__uninstall_gizmos_xrclib___depname)
for f in wx/gizmos/dynamicsash.h wx/gizmos/editlbox.h wx/gizmos/ledctrl.h wx/gizmos/multicell.h wx/gizmos/splittree.h wx/gizmos/statpict.h wx/gizmos/gizmos.h wx/gizmos/xh_statpict.h; do \
rm -f $(DESTDIR)$(includedir)/wx-$(WX_RELEASE)$(WX_FLAVOUR)/$$f; \
done
install-strip: install
$(STRIP) $(DESTDIR)$(libdir)/$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos_0)
$(STRIP) $(DESTDIR)$(libdir)/$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos_0)
clean:
rm -rf ./.deps ./.pch
rm -f ./*.o
rm -f $(LIBDIRNAME)/$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos_0)
rm -f $(LIBDIRNAME)/$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos-$(WX_RELEASE)$(HOST_SUFFIX).$(DLLIMP_SUFFIX)
rm -f $(LIBDIRNAME)/$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos-$(WX_RELEASE)$(HOST_SUFFIX).$(DLLIMP_SUFFIX) $(LIBDIRNAME)/$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos)
rm -f $(LIBDIRNAME)/$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos_0)
rm -f $(LIBDIRNAME)/$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc-$(WX_RELEASE)$(HOST_SUFFIX).$(DLLIMP_SUFFIX)
rm -f $(LIBDIRNAME)/$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc-$(WX_RELEASE)$(HOST_SUFFIX).$(DLLIMP_SUFFIX) $(LIBDIRNAME)/$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos)
rm -f $(LIBDIRNAME)/$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos-$(WX_RELEASE)$(HOST_SUFFIX)$(LIBEXT)
rm -f $(LIBDIRNAME)/$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc-$(WX_RELEASE)$(HOST_SUFFIX)$(LIBEXT)
distclean: clean
rm -f config.cache config.log config.status bk-deps bk-make-pch shared-ld-sh Makefile
@COND_SHARED_1@$(LIBDIRNAME)/$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos_0): $(GIZMOSDLL_OBJECTS) $(__gizmosdll___win32rc)
@COND_SHARED_1@ $(SHARED_LD_CXX) $@ $(GIZMOSDLL_OBJECTS) $(LDFLAGS) -L$(LIBDIRNAME) $(__gizmosdll___macinstnamecmd) $(__gizmosdll___importlib) $(__gizmosdll___soname_flags) $(WXMACVERSION_CMD) $(LIBS) $(__WXLIB_MONO_p) $(__LIB_TIFF_p) $(__LIB_JPEG_p) $(__LIB_PNG_p) $(EXTRALIBS_FOR_GUI) $(__LIB_ZLIB_p) $(__LIB_ODBC_p) $(__LIB_REGEX_p) $(__LIB_EXPAT_p) $(EXTRALIBS_FOR_BASE) $(__WXLIB_CORE_p) $(__WXLIB_BASE_p)
@COND_SHARED_1@
@COND_SHARED_1@ $(__gizmosdll___so_symlinks_cmd)
@COND_SHARED_1@install_gizmosdll:
@COND_SHARED_1@ $(INSTALL_DIR) $(DESTDIR)$(libdir)
@COND_SHARED_1@ $(INSTALL_DATA) $(LIBDIRNAME)/$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos-$(WX_RELEASE)$(HOST_SUFFIX).$(DLLIMP_SUFFIX) $(DESTDIR)$(libdir)
@COND_SHARED_1@ $(INSTALL_PROGRAM) $(LIBDIRNAME)/$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos_0) $(DESTDIR)$(libdir)
@COND_SHARED_1@ (cd $(DESTDIR)$(libdir) ; $(__gizmosdll___so_symlinks_inst_cmd))
@COND_SHARED_1@uninstall_gizmosdll:
@COND_SHARED_1@ rm -f $(DESTDIR)$(libdir)/$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos-$(WX_RELEASE)$(HOST_SUFFIX).$(DLLIMP_SUFFIX)
@COND_SHARED_1@ rm -f $(DESTDIR)$(libdir)/$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos_0)
@COND_SHARED_1@ (cd $(DESTDIR)$(libdir) ; $(__gizmosdll___so_symlinks_uninst_cmd))
@COND_USE_PCH_1@.pch/wxprec_gizmosdll/wx/wxprec.h.gch:
@COND_USE_PCH_1@ $(BK_MAKE_PCH) .pch/wxprec_gizmosdll/wx/wxprec.h.gch wx/wxprec.h $(CXX) $(GIZMOSDLL_CXXFLAGS)
@COND_SHARED_1_USE_XRC_1@$(LIBDIRNAME)/$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos_0): $(GIZMOS_XRCDLL_OBJECTS) $(__gizmos_xrcdll___win32rc) $(__gizmosdll___depname)
@COND_SHARED_1_USE_XRC_1@ $(SHARED_LD_CXX) $@ $(GIZMOS_XRCDLL_OBJECTS) -L$(LIBDIRNAME) $(LDFLAGS) -L$(LIBDIRNAME) $(__gizmos_xrcdll___macinstnamecmd) $(__gizmos_xrcdll___importlib) $(__gizmos_xrcdll___soname_flags) $(WXMACVERSION_CMD) $(LIBS) $(__WXLIB_MONO_p) $(__LIB_TIFF_p) $(__LIB_JPEG_p) $(__LIB_PNG_p) $(EXTRALIBS_FOR_GUI) $(__LIB_ZLIB_p) $(__LIB_ODBC_p) $(__LIB_REGEX_p) $(__LIB_EXPAT_p) $(EXTRALIBS_FOR_BASE) -lwx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos-$(WX_RELEASE)$(HOST_SUFFIX) $(__WXLIB_XRC_p) $(__WXLIB_XML_p) $(EXTRALIBS_XML) $(__WXLIB_CORE_p) $(__WXLIB_BASE_p)
@COND_SHARED_1_USE_XRC_1@
@COND_SHARED_1_USE_XRC_1@ $(__gizmos_xrcdll___so_symlinks_cmd)
@COND_SHARED_1_USE_XRC_1@install_gizmos_xrcdll:
@COND_SHARED_1_USE_XRC_1@ $(INSTALL_DIR) $(DESTDIR)$(libdir)
@COND_SHARED_1_USE_XRC_1@ $(INSTALL_DATA) $(LIBDIRNAME)/$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc-$(WX_RELEASE)$(HOST_SUFFIX).$(DLLIMP_SUFFIX) $(DESTDIR)$(libdir)
@COND_SHARED_1_USE_XRC_1@ $(INSTALL_PROGRAM) $(LIBDIRNAME)/$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos_0) $(DESTDIR)$(libdir)
@COND_SHARED_1_USE_XRC_1@ (cd $(DESTDIR)$(libdir) ; $(__gizmos_xrcdll___so_symlinks_inst_cmd))
@COND_SHARED_1_USE_XRC_1@uninstall_gizmos_xrcdll:
@COND_SHARED_1_USE_XRC_1@ rm -f $(DESTDIR)$(libdir)/$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc-$(WX_RELEASE)$(HOST_SUFFIX).$(DLLIMP_SUFFIX)
@COND_SHARED_1_USE_XRC_1@ rm -f $(DESTDIR)$(libdir)/$(DLLPREFIX)$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG)$(__gizmos_0)
@COND_SHARED_1_USE_XRC_1@ (cd $(DESTDIR)$(libdir) ; $(__gizmos_xrcdll___so_symlinks_uninst_cmd))
@COND_USE_PCH_1@.pch/wxprec_gizmos_xrcdll/wx/wxprec.h.gch:
@COND_USE_PCH_1@ $(BK_MAKE_PCH) .pch/wxprec_gizmos_xrcdll/wx/wxprec.h.gch wx/wxprec.h $(CXX) $(GIZMOS_XRCDLL_CXXFLAGS)
@COND_SHARED_0@$(LIBDIRNAME)/$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos-$(WX_RELEASE)$(HOST_SUFFIX)$(LIBEXT): $(GIZMOSLIB_OBJECTS)
@COND_SHARED_0@ rm -f $@
@COND_SHARED_0@ $(AR) $(AROPTIONS) $@ $(GIZMOSLIB_OBJECTS)
@COND_SHARED_0@ $(RANLIB) $@
@COND_SHARED_0@install_gizmoslib:
@COND_SHARED_0@ $(INSTALL_DIR) $(DESTDIR)$(libdir)
@COND_SHARED_0@ $(INSTALL_DATA) $(LIBDIRNAME)/$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos-$(WX_RELEASE)$(HOST_SUFFIX)$(LIBEXT) $(DESTDIR)$(libdir)
@COND_SHARED_0@uninstall_gizmoslib:
@COND_SHARED_0@ rm -f $(DESTDIR)$(libdir)/$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos-$(WX_RELEASE)$(HOST_SUFFIX)$(LIBEXT)
@COND_USE_PCH_1@.pch/wxprec_gizmoslib/wx/wxprec.h.gch:
@COND_USE_PCH_1@ $(BK_MAKE_PCH) .pch/wxprec_gizmoslib/wx/wxprec.h.gch wx/wxprec.h $(CXX) $(GIZMOSLIB_CXXFLAGS)
@COND_SHARED_0_USE_XRC_1@$(LIBDIRNAME)/$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc-$(WX_RELEASE)$(HOST_SUFFIX)$(LIBEXT): $(GIZMOS_XRCLIB_OBJECTS)
@COND_SHARED_0_USE_XRC_1@ rm -f $@
@COND_SHARED_0_USE_XRC_1@ $(AR) $(AROPTIONS) $@ $(GIZMOS_XRCLIB_OBJECTS)
@COND_SHARED_0_USE_XRC_1@ $(RANLIB) $@
@COND_SHARED_0_USE_XRC_1@install_gizmos_xrclib:
@COND_SHARED_0_USE_XRC_1@ $(INSTALL_DIR) $(DESTDIR)$(libdir)
@COND_SHARED_0_USE_XRC_1@ $(INSTALL_DATA) $(LIBDIRNAME)/$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc-$(WX_RELEASE)$(HOST_SUFFIX)$(LIBEXT) $(DESTDIR)$(libdir)
@COND_SHARED_0_USE_XRC_1@uninstall_gizmos_xrclib:
@COND_SHARED_0_USE_XRC_1@ rm -f $(DESTDIR)$(libdir)/$(LIBPREFIX)wx_$(PORTNAME)$(WXUNIVNAME)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc-$(WX_RELEASE)$(HOST_SUFFIX)$(LIBEXT)
@COND_USE_PCH_1@.pch/wxprec_gizmos_xrclib/wx/wxprec.h.gch:
@COND_USE_PCH_1@ $(BK_MAKE_PCH) .pch/wxprec_gizmos_xrclib/wx/wxprec.h.gch wx/wxprec.h $(CXX) $(GIZMOS_XRCLIB_CXXFLAGS)
gizmosdll_version_rc.o: $(srcdir)/../../../src/msw/version.rc $(GIZMOSDLL_ODEP)
$(WINDRES) -i$< -o$@ --define __WX$(TOOLKIT)__ $(__WXUNIV_DEFINE_p_0) $(__EXCEPTIONS_DEFINE_p_0) $(__RTTI_DEFINE_p_0) $(__THREAD_DEFINE_p_0) --define WXDLLNAME=$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG) $(__RCDEFDIR_p) --include-dir $(top_srcdir)/include
gizmosdll_dynamicsash.o: $(srcdir)/dynamicsash.cpp $(GIZMOSDLL_ODEP)
$(CXXC) -c -o $@ $(GIZMOSDLL_CXXFLAGS) $(srcdir)/dynamicsash.cpp
gizmosdll_editlbox.o: $(srcdir)/editlbox.cpp $(GIZMOSDLL_ODEP)
$(CXXC) -c -o $@ $(GIZMOSDLL_CXXFLAGS) $(srcdir)/editlbox.cpp
gizmosdll_ledctrl.o: $(srcdir)/ledctrl.cpp $(GIZMOSDLL_ODEP)
$(CXXC) -c -o $@ $(GIZMOSDLL_CXXFLAGS) $(srcdir)/ledctrl.cpp
gizmosdll_multicell.o: $(srcdir)/multicell.cpp $(GIZMOSDLL_ODEP)
$(CXXC) -c -o $@ $(GIZMOSDLL_CXXFLAGS) $(srcdir)/multicell.cpp
gizmosdll_splittree.o: $(srcdir)/splittree.cpp $(GIZMOSDLL_ODEP)
$(CXXC) -c -o $@ $(GIZMOSDLL_CXXFLAGS) $(srcdir)/splittree.cpp
gizmosdll_statpict.o: $(srcdir)/statpict.cpp $(GIZMOSDLL_ODEP)
$(CXXC) -c -o $@ $(GIZMOSDLL_CXXFLAGS) $(srcdir)/statpict.cpp
gizmos_xrcdll_version_rc.o: $(srcdir)/../../../src/msw/version.rc $(GIZMOS_XRCDLL_ODEP)
$(WINDRES) -i$< -o$@ --define __WX$(TOOLKIT)__ $(__WXUNIV_DEFINE_p_0) $(__EXCEPTIONS_DEFINE_p_0) $(__RTTI_DEFINE_p_0) $(__THREAD_DEFINE_p_0) --define WXDLLNAME=$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gizmos_xrc$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG) $(__RCDEFDIR_p) --include-dir $(top_srcdir)/include
gizmos_xrcdll_xh_statpict.o: $(srcdir)/xh_statpict.cpp $(GIZMOS_XRCDLL_ODEP)
$(CXXC) -c -o $@ $(GIZMOS_XRCDLL_CXXFLAGS) $(srcdir)/xh_statpict.cpp
gizmoslib_dynamicsash.o: $(srcdir)/dynamicsash.cpp $(GIZMOSLIB_ODEP)
$(CXXC) -c -o $@ $(GIZMOSLIB_CXXFLAGS) $(srcdir)/dynamicsash.cpp
gizmoslib_editlbox.o: $(srcdir)/editlbox.cpp $(GIZMOSLIB_ODEP)
$(CXXC) -c -o $@ $(GIZMOSLIB_CXXFLAGS) $(srcdir)/editlbox.cpp
gizmoslib_ledctrl.o: $(srcdir)/ledctrl.cpp $(GIZMOSLIB_ODEP)
$(CXXC) -c -o $@ $(GIZMOSLIB_CXXFLAGS) $(srcdir)/ledctrl.cpp
gizmoslib_multicell.o: $(srcdir)/multicell.cpp $(GIZMOSLIB_ODEP)
$(CXXC) -c -o $@ $(GIZMOSLIB_CXXFLAGS) $(srcdir)/multicell.cpp
gizmoslib_splittree.o: $(srcdir)/splittree.cpp $(GIZMOSLIB_ODEP)
$(CXXC) -c -o $@ $(GIZMOSLIB_CXXFLAGS) $(srcdir)/splittree.cpp
gizmoslib_statpict.o: $(srcdir)/statpict.cpp $(GIZMOSLIB_ODEP)
$(CXXC) -c -o $@ $(GIZMOSLIB_CXXFLAGS) $(srcdir)/statpict.cpp
gizmos_xrclib_xh_statpict.o: $(srcdir)/xh_statpict.cpp $(GIZMOS_XRCLIB_ODEP)
$(CXXC) -c -o $@ $(GIZMOS_XRCLIB_CXXFLAGS) $(srcdir)/xh_statpict.cpp
# Include dependency info, if present:
@IF_GNU_MAKE@-include .deps/*.d
.PHONY: all install uninstall clean distclean install_gizmosdll uninstall_gizmosdll install_gizmos_xrcdll uninstall_gizmos_xrcdll install_gizmoslib uninstall_gizmoslib install_gizmos_xrclib uninstall_gizmos_xrclib

1471
wxPython/contrib/gizmos/wxCode/src/gizmos/dynamicsash.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

277
wxPython/contrib/gizmos/wxCode/src/gizmos/editlbox.cpp Normal file
View File

@@ -0,0 +1,277 @@
/////////////////////////////////////////////////////////////////////////////
// Name: editlbox.cpp
// Purpose: ListBox with editable items
// Author: Vaclav Slavik
// RCS-ID: $Id$
// Copyright: (c) Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
// for all others, include the necessary headers (this file is usually all you
// need because it includes almost all "standard" wxWidgets headers)
#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif
#include "wx/gizmos/editlbox.h"
#include "wx/sizer.h"
#include "wx/listctrl.h"
// list control with auto-resizable column:
class CleverListCtrl : public wxListCtrl
{
public:
CleverListCtrl(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint &pos = wxDefaultPosition,
const wxSize &size = wxDefaultSize,
long style = wxLC_ICON,
const wxValidator& validator = wxDefaultValidator,
const wxString &name = wxListCtrlNameStr)
: wxListCtrl(parent, id, pos, size, style, validator, name)
{
CreateColumns();
}
void CreateColumns()
{
InsertColumn(0, _T("item"));
SizeColumns();
}
void SizeColumns()
{
int w = GetSize().x;
#ifdef __WXMSW__
w -= wxSystemSettings::GetMetric(wxSYS_VSCROLL_X) + 6;
#else
w -= 2*wxSystemSettings::GetMetric(wxSYS_VSCROLL_X);
#endif
SetColumnWidth(0, w);
}
private:
DECLARE_EVENT_TABLE()
void OnSize(wxSizeEvent& event)
{
SizeColumns();
event.Skip();
}
};
BEGIN_EVENT_TABLE(CleverListCtrl, wxListCtrl)
EVT_SIZE(CleverListCtrl::OnSize)
END_EVENT_TABLE()
#include "eldel.xpm"
#include "eldown.xpm"
#include "eledit.xpm"
#include "elnew.xpm"
#include "elup.xpm"
IMPLEMENT_CLASS(wxEditableListBox, wxPanel)
// NB: generate the IDs at runtime to avoid conflict with XRCID values,
// they could cause XRCCTRL() failures in XRC-based dialogs
const int wxID_ELB_DELETE = wxNewId();
const int wxID_ELB_EDIT = wxNewId();
const int wxID_ELB_NEW = wxNewId();
const int wxID_ELB_UP = wxNewId();
const int wxID_ELB_DOWN = wxNewId();
const int wxID_ELB_LISTCTRL = wxNewId();
BEGIN_EVENT_TABLE(wxEditableListBox, wxPanel)
EVT_LIST_ITEM_SELECTED(wxID_ELB_LISTCTRL, wxEditableListBox::OnItemSelected)
EVT_LIST_END_LABEL_EDIT(wxID_ELB_LISTCTRL, wxEditableListBox::OnEndLabelEdit)
EVT_BUTTON(wxID_ELB_NEW, wxEditableListBox::OnNewItem)
EVT_BUTTON(wxID_ELB_UP, wxEditableListBox::OnUpItem)
EVT_BUTTON(wxID_ELB_DOWN, wxEditableListBox::OnDownItem)
EVT_BUTTON(wxID_ELB_EDIT, wxEditableListBox::OnEditItem)
EVT_BUTTON(wxID_ELB_DELETE, wxEditableListBox::OnDelItem)
END_EVENT_TABLE()
wxEditableListBox::wxEditableListBox(wxWindow *parent, wxWindowID id,
const wxString& label,
const wxPoint& pos, const wxSize& size,
long style,
const wxString& name)
: wxPanel(parent, id, pos, size, wxTAB_TRAVERSAL, name)
{
m_style = style;
m_bEdit = m_bNew = m_bDel = m_bUp = m_bDown = NULL;
wxSizer *sizer = new wxBoxSizer(wxVERTICAL);
wxPanel *subp = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxDefaultSize,
wxSUNKEN_BORDER | wxTAB_TRAVERSAL);
wxSizer *subsizer = new wxBoxSizer(wxHORIZONTAL);
subsizer->Add(new wxStaticText(subp, wxID_ANY, label), 1, wxALIGN_CENTRE_VERTICAL | wxLEFT, 4);
#ifdef __WXMSW__
#define BTN_BORDER 4
// FIXME - why is this needed? There's some reason why sunken border is
// ignored by sizers in wxMSW but not in wxGTK that I can't
// figure out...
#else
#define BTN_BORDER 0
#endif
if ( m_style & wxEL_ALLOW_EDIT )
{
m_bEdit = new wxBitmapButton(subp, wxID_ELB_EDIT, wxBitmap(eledit_xpm));
subsizer->Add(m_bEdit, 0, wxALIGN_CENTRE_VERTICAL | wxTOP | wxBOTTOM, BTN_BORDER);
}
if ( m_style & wxEL_ALLOW_NEW )
{
m_bNew = new wxBitmapButton(subp, wxID_ELB_NEW, wxBitmap(elnew_xpm));
subsizer->Add(m_bNew, 0, wxALIGN_CENTRE_VERTICAL | wxTOP | wxBOTTOM, BTN_BORDER);
}
if ( m_style & wxEL_ALLOW_DELETE )
{
m_bDel = new wxBitmapButton(subp, wxID_ELB_DELETE, wxBitmap(eldel_xpm));
subsizer->Add(m_bDel, 0, wxALIGN_CENTRE_VERTICAL | wxTOP | wxBOTTOM, BTN_BORDER);
}
if (!(m_style & wxEL_NO_REORDER))
{
m_bUp = new wxBitmapButton(subp, wxID_ELB_UP, wxBitmap(elup_xpm));
subsizer->Add(m_bUp, 0, wxALIGN_CENTRE_VERTICAL | wxTOP | wxBOTTOM, BTN_BORDER);
m_bDown = new wxBitmapButton(subp, wxID_ELB_DOWN, wxBitmap(eldown_xpm));
subsizer->Add(m_bDown, 0, wxALIGN_CENTRE_VERTICAL | wxTOP | wxBOTTOM, BTN_BORDER);
}
#if wxUSE_TOOLTIPS
if ( m_bEdit ) m_bEdit->SetToolTip(_("Edit item"));
if ( m_bNew ) m_bNew->SetToolTip(_("New item"));
if ( m_bDel ) m_bDel->SetToolTip(_("Delete item"));
if ( m_bUp ) m_bUp->SetToolTip(_("Move up"));
if ( m_bDown ) m_bDown->SetToolTip(_("Move down"));
#endif
subp->SetSizer(subsizer);
subsizer->Fit(subp);
sizer->Add(subp, 0, wxEXPAND);
long st = wxLC_REPORT | wxLC_NO_HEADER | wxLC_SINGLE_SEL | wxSUNKEN_BORDER;
if ( style & wxEL_ALLOW_EDIT )
st |= wxLC_EDIT_LABELS;
m_listCtrl = new CleverListCtrl(this, wxID_ELB_LISTCTRL,
wxDefaultPosition, wxDefaultSize, st);
wxArrayString empty_ar;
SetStrings(empty_ar);
sizer->Add(m_listCtrl, 1, wxEXPAND);
SetSizer(sizer);
Layout();
}
void wxEditableListBox::SetStrings(const wxArrayString& strings)
{
m_listCtrl->DeleteAllItems();
size_t i;
for (i = 0; i < strings.GetCount(); i++)
m_listCtrl->InsertItem(i, strings[i]);
m_listCtrl->InsertItem(strings.GetCount(), wxEmptyString);
m_listCtrl->SetItemState(0, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
}
void wxEditableListBox::GetStrings(wxArrayString& strings) const
{
strings.Clear();
for (int i = 0; i < m_listCtrl->GetItemCount()-1; i++)
strings.Add(m_listCtrl->GetItemText(i));
}
void wxEditableListBox::OnItemSelected(wxListEvent& event)
{
m_selection = event.GetIndex();
if (!(m_style & wxEL_NO_REORDER))
{
m_bUp->Enable(m_selection != 0 && m_selection < m_listCtrl->GetItemCount()-1);
m_bDown->Enable(m_selection < m_listCtrl->GetItemCount()-2);
}
if (m_style & wxEL_ALLOW_EDIT)
m_bEdit->Enable(m_selection < m_listCtrl->GetItemCount()-1);
if (m_style & wxEL_ALLOW_DELETE)
m_bDel->Enable(m_selection < m_listCtrl->GetItemCount()-1);
}
void wxEditableListBox::OnNewItem(wxCommandEvent& WXUNUSED(event))
{
m_listCtrl->SetItemState(m_listCtrl->GetItemCount()-1,
wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
m_listCtrl->EditLabel(m_selection);
}
void wxEditableListBox::OnEndLabelEdit(wxListEvent& event)
{
if ( event.GetIndex() == m_listCtrl->GetItemCount()-1 &&
!event.GetText().empty() )
{
// The user edited last (empty) line, i.e. added new entry. We have to
// add new empty line here so that adding one more line is still
// possible:
m_listCtrl->InsertItem(m_listCtrl->GetItemCount(), wxEmptyString);
// Simulate a wxEVT_COMMAND_LIST_ITEM_SELECTED event for the new item,
// so that the buttons are enabled/disabled properly
wxListEvent selectionEvent(wxEVT_COMMAND_LIST_ITEM_SELECTED, m_listCtrl->GetId());
selectionEvent.m_itemIndex = event.GetIndex();
m_listCtrl->GetEventHandler()->ProcessEvent(selectionEvent);
}
}
void wxEditableListBox::OnDelItem(wxCommandEvent& WXUNUSED(event))
{
m_listCtrl->DeleteItem(m_selection);
m_listCtrl->SetItemState(m_selection,
wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
}
void wxEditableListBox::OnEditItem(wxCommandEvent& WXUNUSED(event))
{
m_listCtrl->EditLabel(m_selection);
}
void wxEditableListBox::OnUpItem(wxCommandEvent& WXUNUSED(event))
{
wxString t1, t2;
t1 = m_listCtrl->GetItemText(m_selection - 1);
t2 = m_listCtrl->GetItemText(m_selection);
m_listCtrl->SetItemText(m_selection - 1, t2);
m_listCtrl->SetItemText(m_selection, t1);
m_listCtrl->SetItemState(m_selection - 1,
wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
}
void wxEditableListBox::OnDownItem(wxCommandEvent& WXUNUSED(event))
{
wxString t1, t2;
t1 = m_listCtrl->GetItemText(m_selection + 1);
t2 = m_listCtrl->GetItemText(m_selection);
m_listCtrl->SetItemText(m_selection + 1, t2);
m_listCtrl->SetItemText(m_selection, t1);
m_listCtrl->SetItemState(m_selection + 1,
wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
}

22
wxPython/contrib/gizmos/wxCode/src/gizmos/eldel.xpm Normal file
View File

@@ -0,0 +1,22 @@
/* XPM */
static char * eldel_xpm[] = {
"16 16 3 1",
" c None",
". c #7F0000",
"+ c #FFFFFF",
" ",
" ",
" ",
" ..+ ..+ ",
" ....+ ..+ ",
" ....+ ..+ ",
" ...+ .+ ",
" .....+ ",
" ...+ ",
" .....+ ",
" ...+ ..+ ",
" ...+ ..+ ",
" ...+ .+ ",
" ...+ .+ ",
" . . ",
" "};

21
wxPython/contrib/gizmos/wxCode/src/gizmos/eldown.xpm Normal file
View File

@@ -0,0 +1,21 @@
/* XPM */
static char * eldown_xpm[] = {
"16 16 2 1",
" c None",
". c #000000",
" ",
" ",
" ... ",
" ... ",
" ... ",
" ... ",
" ... ",
" ... ",
" ........... ",
" ......... ",
" ....... ",
" ..... ",
" ... ",
" . ",
" ",
" "};

22
wxPython/contrib/gizmos/wxCode/src/gizmos/eledit.xpm Normal file
View File

@@ -0,0 +1,22 @@
/* XPM */
static char * eledit_xpm[] = {
"16 16 3 1",
" c None",
". c #000000",
"+ c #00007F",
" ",
" ",
" .. .. ",
" . ",
" . ",
" ++++ . ++++ ",
" ++ . ++ ++",
" +++++ . ++++++",
" ++ ++ . ++ ",
" ++ ++ . ++ ++",
" +++++ . ++++ ",
" . ",
" . ",
" .. .. ",
" ",
" "};

24
wxPython/contrib/gizmos/wxCode/src/gizmos/elnew.xpm Normal file
View File

@@ -0,0 +1,24 @@
/* XPM */
static char * elnew_xpm[] = {
"16 16 5 1",
" c None",
". c #7F7F7F",
"+ c #FFFFFF",
"@ c #FFFF00",
"# c #000000",
" ",
" ",
" . .+ .@ ",
" . .@.@# # # ",
" @.@+.... # ",
" ... @@ ",
" @ . @. # ",
" .# .@ ",
" . # ",
" # ",
" # ",
" # ",
" # ",
" # # # # # # ",
" ",
" "};

21
wxPython/contrib/gizmos/wxCode/src/gizmos/elup.xpm Normal file
View File

@@ -0,0 +1,21 @@
/* XPM */
static char * elup_xpm[] = {
"16 16 2 1",
" c None",
". c #000000",
" ",
" . ",
" ... ",
" ..... ",
" ....... ",
" ......... ",
" ........... ",
" ... ",
" ... ",
" ... ",
" ... ",
" ... ",
" ... ",
" ",
" ",
" "};

392
wxPython/contrib/gizmos/wxCode/src/gizmos/ledctrl.cpp Normal file
View File

@@ -0,0 +1,392 @@
// ============================================================================
// headers
// ============================================================================
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif //__BORLANDC__
#ifndef WX_PRECOMP
#include "wx/dcclient.h"
#include "wx/dcmemory.h"
#include "wx/intl.h"
#endif
#include "wx/gizmos/ledctrl.h"
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
// A LED digit is build up like this, with maximum 7 Lines :
//
// 111
// 6 2
// 777
// 5 3
// 444
//
// Each number contains combinations of the lines, and they are set up below.
const int LINE1 = 1;
const int LINE2 = 2;
const int LINE3 = 4;
const int LINE4 = 8;
const int LINE5 = 16;
const int LINE6 = 32;
const int LINE7 = 64;
const int DECIMALSIGN = 128;
const int DIGIT0 = LINE1 | LINE2 | LINE3 | LINE4 | LINE5 | LINE6;
const int DIGIT1 = LINE2 | LINE3;
const int DIGIT2 = LINE1 | LINE2 | LINE4 | LINE5 | LINE7;
const int DIGIT3 = LINE1 | LINE2 | LINE3 | LINE4 | LINE7;
const int DIGIT4 = LINE2 | LINE3 | LINE6 | LINE7;
const int DIGIT5 = LINE1 | LINE3 | LINE4 | LINE6 | LINE7;
const int DIGIT6 = LINE1 | LINE3 | LINE4 | LINE5 | LINE6 | LINE7;
const int DIGIT7 = LINE1 | LINE2 | LINE3;
const int DIGIT8 = LINE1 | LINE2 | LINE3 | LINE4 | LINE5 | LINE6 | LINE7;
const int DIGIT9 = LINE1 | LINE2 | LINE3 | LINE6 | LINE7;
const int DASH = LINE7;
const int DIGITALL = -1;
// ============================================================================
// wxLEDNumberCtrl class implementation
// ============================================================================
wxLEDNumberCtrl::wxLEDNumberCtrl()
: m_Alignment(wxLED_ALIGN_LEFT),
m_LineMargin(-1),
m_DigitMargin(-1),
m_LineLength(-1),
m_LineWidth(-1),
m_DrawFaded(false),
m_LeftStartPos(-1)
{
}
wxLEDNumberCtrl::wxLEDNumberCtrl(wxWindow *parent, wxWindowID id,
const wxPoint& pos, const wxSize& size,
long style)
: m_Alignment(wxLED_ALIGN_LEFT),
m_LineMargin(-1),
m_DigitMargin(-1),
m_LineLength(-1),
m_LineWidth(-1),
m_DrawFaded(false),
m_LeftStartPos(-1)
{
Create(parent, id, pos, size, style);
}
bool wxLEDNumberCtrl::Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos, const wxSize& size,
long style)
{
bool RetVal = wxControl::Create(parent, id, pos, size, style);
if ((style & wxLED_DRAW_FADED) != 0)
SetDrawFaded(true);
if ((style & wxLED_ALIGN_MASK) != 0)
SetAlignment((wxLEDValueAlign)(style & wxLED_ALIGN_MASK));
SetBackgroundColour(*wxBLACK);
SetForegroundColour(*wxGREEN);
return RetVal;
}
void wxLEDNumberCtrl::SetAlignment(wxLEDValueAlign Alignment, bool Redraw)
{
if (Alignment != m_Alignment)
{
m_Alignment = Alignment;
RecalcInternals(GetClientSize());
if (Redraw)
Refresh(false);
}
}
void wxLEDNumberCtrl::SetDrawFaded(bool DrawFaded, bool Redraw)
{
if (DrawFaded != m_DrawFaded)
{
m_DrawFaded = DrawFaded;
if (Redraw)
Refresh(false);
}
}
void wxLEDNumberCtrl::SetValue(wxString const &Value, bool Redraw)
{
if (Value != m_Value)
{
#ifdef __WXDEBUG__
if (!Value.empty())
{
for(size_t i=0; i<Value.Length(); i++) {
wxChar ch = Value[i];
wxASSERT_MSG((ch>='0' && ch<='9') || ch=='-' || ch==' ' || ch=='.',
wxT("wxLEDNumberCtrl can only display numeric string values."));
}
}
#endif
m_Value = Value;
RecalcInternals(GetClientSize());
if (Redraw)
Refresh(false);
}
}
BEGIN_EVENT_TABLE(wxLEDNumberCtrl, wxControl)
EVT_ERASE_BACKGROUND(wxLEDNumberCtrl::OnEraseBackground)
EVT_PAINT(wxLEDNumberCtrl::OnPaint)
EVT_SIZE(wxLEDNumberCtrl::OnSize)
END_EVENT_TABLE()
void wxLEDNumberCtrl::OnEraseBackground(wxEraseEvent &WXUNUSED(event))
{
}
void wxLEDNumberCtrl::OnPaint(wxPaintEvent &WXUNUSED(event))
{
wxPaintDC Dc(this);
int Width, Height;
GetClientSize(&Width, &Height);
wxBitmap *pMemoryBitmap = new wxBitmap(Width, Height);
wxMemoryDC MemDc;
MemDc.SelectObject(*pMemoryBitmap);
// Draw background.
MemDc.SetBrush(wxBrush(GetBackgroundColour(), wxSOLID));
MemDc.DrawRectangle(wxRect(0, 0, Width, Height));
MemDc.SetBrush(wxNullBrush);
// Iterate each digit in the value, and draw.
const int DigitCount = m_Value.Len();
for (int offset=0, i = 0; offset < DigitCount; ++offset, ++i)
{
wxChar c = m_Value.GetChar(offset);
// Draw faded lines if wanted.
if (m_DrawFaded && (c != _T('.')))
DrawDigit(MemDc, DIGITALL, i);
// Draw the digits.
switch (c)
{
case _T('0') :
DrawDigit(MemDc, DIGIT0, i);
break;
case _T('1') :
DrawDigit(MemDc, DIGIT1, i);
break;
case _T('2') :
DrawDigit(MemDc, DIGIT2, i);
break;
case _T('3') :
DrawDigit(MemDc, DIGIT3, i);
break;
case _T('4') :
DrawDigit(MemDc, DIGIT4, i);
break;
case _T('5') :
DrawDigit(MemDc, DIGIT5, i);
break;
case _T('6') :
DrawDigit(MemDc, DIGIT6, i);
break;
case _T('7') :
DrawDigit(MemDc, DIGIT7, i);
break;
case _T('8') :
DrawDigit(MemDc, DIGIT8, i);
break;
case _T('9') :
DrawDigit(MemDc, DIGIT9, i);
break;
case _T('-') :
DrawDigit(MemDc, DASH, i);
break;
case _T('.') :
// Display the decimal in the previous segment
i--;
DrawDigit(MemDc, DECIMALSIGN, i);
break;
case _T(' ') :
// just skip it
break;
default :
wxFAIL_MSG(wxT("Unknown digit value"));
break;
}
}
// Blit the memory dc to screen.
Dc.Blit(0, 0, Width, Height, &MemDc, 0, 0, wxCOPY);
delete pMemoryBitmap;
}
void wxLEDNumberCtrl::DrawDigit(wxDC &Dc, int Digit, int Column)
{
wxColour LineColor(GetForegroundColour());
if (Digit == DIGITALL)
{
const unsigned char R = (unsigned char)(LineColor.Red() / 16);
const unsigned char G = (unsigned char)(LineColor.Green() / 16);
const unsigned char B = (unsigned char)(LineColor.Blue() / 16);
LineColor.Set(R, G, B);
}
int XPos = m_LeftStartPos + Column * (m_LineLength + m_DigitMargin);
// Create a pen and draw the lines.
wxPen Pen(LineColor, m_LineWidth, wxSOLID);
Dc.SetPen(Pen);
if ((Digit & LINE1))
{
Dc.DrawLine(XPos + m_LineMargin*2, m_LineMargin,
XPos + m_LineLength + m_LineMargin*2, m_LineMargin);
}
if (Digit & LINE2)
{
Dc.DrawLine(XPos + m_LineLength + m_LineMargin*3, m_LineMargin*2,
XPos + m_LineLength + m_LineMargin*3, m_LineLength + (m_LineMargin*2));
}
if (Digit & LINE3)
{
Dc.DrawLine(XPos + m_LineLength + m_LineMargin*3, m_LineLength + (m_LineMargin*4),
XPos + m_LineLength + m_LineMargin*3, m_LineLength*2 + (m_LineMargin*4));
}
if (Digit & LINE4)
{
Dc.DrawLine(XPos + m_LineMargin*2, m_LineLength*2 + (m_LineMargin*5),
XPos + m_LineLength + m_LineMargin*2, m_LineLength*2 + (m_LineMargin*5));
}
if (Digit & LINE5)
{
Dc.DrawLine(XPos + m_LineMargin, m_LineLength + (m_LineMargin*4),
XPos + m_LineMargin, m_LineLength*2 + (m_LineMargin*4));
}
if (Digit & LINE6)
{
Dc.DrawLine(XPos + m_LineMargin, m_LineMargin*2,
XPos + m_LineMargin, m_LineLength + (m_LineMargin*2));
}
if (Digit & LINE7)
{
Dc.DrawLine(XPos + m_LineMargin*2, m_LineLength + (m_LineMargin*3),
XPos + m_LineMargin*2 + m_LineLength, m_LineLength + (m_LineMargin*3));
}
if (Digit & DECIMALSIGN)
{
Dc.DrawLine(XPos + m_LineLength + m_LineMargin*4, m_LineLength*2 + (m_LineMargin*5),
XPos + m_LineLength + m_LineMargin*4, m_LineLength*2 + (m_LineMargin*5));
}
Dc.SetPen(wxNullPen);
}
void wxLEDNumberCtrl::RecalcInternals(const wxSize &CurrentSize)
{
// Dimensions of LED segments
//
// Size of character is based on the HEIGH of the widget, NOT the width.
// Segment height is calculated as follows:
// Each segment is m_LineLength pixels long.
// There is m_LineMargin pixels at the top and bottom of each line segment
// There is m_LineMargin pixels at the top and bottom of each digit
//
// Therefore, the heigth of each character is:
// m_LineMargin : Top digit boarder
// m_LineMargin+m_LineLength+m_LineMargin : Top half of segment
// m_LineMargin+m_LineLength+m_LineMargin : Bottom half of segment
// m_LineMargin : Bottom digit boarder
// ----------------------
// m_LineMargin*6 + m_LineLength*2 == Total height of digit.
// Therefore, (m_LineMargin*6 + m_LineLength*2) must equal Height
//
// Spacing between characters can then be calculated as follows:
// m_LineMargin : before the digit,
// m_LineMargin+m_LineLength+m_LineMargin : for the digit width
// m_LineMargin : after the digit
// = m_LineMargin*4 + m_LineLength
const int Height = CurrentSize.GetHeight();
if ((Height * 0.075) < 1)
m_LineMargin = 1;
else
m_LineMargin = (int)(Height * 0.075);
if ((Height * 0.275) < 1)
m_LineLength = 1;
else
m_LineLength = (int)(Height * 0.275);
m_LineWidth = m_LineMargin;
m_DigitMargin = m_LineMargin * 4;
// Count the number of characters in the string; '.' characters are not
// included because they do not take up space in the display
int count = 0;
for (unsigned int i = 0; i < m_Value.Len(); i++)
if (m_Value.GetChar(i) != '.')
count++;
const int ValueWidth = (m_LineLength + m_DigitMargin) * count;
const int ClientWidth = CurrentSize.GetWidth();
switch (m_Alignment)
{
case wxLED_ALIGN_LEFT :
m_LeftStartPos = m_LineMargin;
break;
case wxLED_ALIGN_RIGHT :
m_LeftStartPos = ClientWidth - ValueWidth - m_LineMargin;
break;
case wxLED_ALIGN_CENTER :
m_LeftStartPos = (ClientWidth - ValueWidth) / 2;
break;
default :
wxFAIL_MSG(wxT("Unknown alignent value for wxLEDNumberCtrl."));
break;
}
}
void wxLEDNumberCtrl::OnSize(wxSizeEvent &Event)
{
RecalcInternals(Event.GetSize());
Event.Skip();
}

107
wxPython/contrib/gizmos/wxCode/src/gizmos/makedocs.vc Normal file
View File

@@ -0,0 +1,107 @@
#
# File: makefile.vc
WXDIR=$(WXWIN)
NAME=gizmos
WAITFLAG=/WAIT
DOCSOURCEDIR=$(WXDIR)\contrib\docs\latex\$(NAME)
DOCDIR=$(WXDIR)\docs
THISDIR = $(WXDIR)\contrib\src\$(NAME)
DOCSOURCES=$(DOCSOURCEDIR)\manual.tex \
$(DOCSOURCEDIR)\classes.tex $(DOCSOURCEDIR)\topics.tex
alldocs: mkdirs html htmlhelp htb hlp pdfrtf
html: touchmanual $(DOCDIR)\html\$(NAME)\$(NAME).htm
htmlhelp: touchmanual $(DOCDIR)\htmlhelp\$(NAME).chm
htb: $(DOCDIR)\htb\$(NAME).htb
hlp: touchmanual $(DOCDIR)\winhelp\$(NAME).hlp
pdfrtf: $(DOCDIR)\pdf\$(NAME).rtf
ps: $(DOCDIR)\ps\$(NAME).ps
touchmanual:
touch $(DOCSOURCEDIR)\manual.tex
$(DOCDIR)\winhelp\$(NAME).hlp: $(DOCSOURCEDIR)\$(NAME).rtf $(DOCSOURCEDIR)\$(NAME).hpj
cd $(DOCSOURCEDIR)
-erase $(NAME).ph
hcw /c /e $(NAME)
move $(NAME).hlp $(DOCDIR)\winhelp\$(NAME).hlp
move $(NAME).cnt $(DOCDIR)\winhelp\$(NAME).cnt
cd $(THISDIR)
$(DOCSOURCEDIR)\$(NAME).hpj:
echo [OPTIONS] > $(DOCSOURCEDIR)\$(NAME).hpj
echo BMROOT=$(WXDIR)\contrib\docs\latex\$(NAME) >> $(DOCSOURCEDIR)\$(NAME).hpj
echo TITLE=OGL Manual >> $(DOCSOURCEDIR)\$(NAME).hpj
echo CONTENTS=Contents >> $(DOCSOURCEDIR)\$(NAME).hpj
echo COMPRESS=HIGH >> $(DOCSOURCEDIR)\$(NAME).hpj
echo "" >> $(DOCSOURCEDIR)\$(NAME).hpj
echo [FILES] >> $(DOCSOURCEDIR)\$(NAME).hpj
echo $(NAME).rtf >> $(DOCSOURCEDIR)\$(NAME).hpj
echo "" >> $(DOCSOURCEDIR)\$(NAME).hpj
echo [CONFIG] >> $(DOCSOURCEDIR)\$(NAME).hpj
echo CreateButton("Up", "&Up", "JumpId(`$(NAME).hlp', `Contents')") >> $(DOCSOURCEDIR)\$(NAME).hpj
echo BrowseButtons() >> $(DOCSOURCEDIR)\$(NAME).hpj
echo "" >> $(DOCSOURCEDIR)\$(NAME).hpj
echo [MAP] >> $(DOCSOURCEDIR)\$(NAME).hpj
echo "" >> $(DOCSOURCEDIR)\$(NAME).hpj
echo [BITMAPS] >> $(DOCSOURCEDIR)\$(NAME).hpj
$(DOCSOURCEDIR)\$(NAME).rtf: $(DOCSOURCES)
cd $(DOCSOURCEDIR)
-start $(WAITFLAG) tex2rtf $(DOCSOURCEDIR)\manual.tex $(DOCSOURCEDIR)\$(NAME).rtf -twice -winhelp
cd $(THISDIR)
$(DOCDIR)\pdf\$(NAME).rtf: $(DOCSOURCES)
cd $(DOCSOURCEDIR)
-copy *.bmp $(DOCDIR)\pdf
-start $(WAITFLAG) tex2rtf $(DOCSOURCEDIR)\manual.tex $(DOCDIR)\pdf\$(NAME).rtf -twice -rtf
cd $(THISDIR)
$(DOCDIR)\html\$(NAME)\$(NAME).htm: $(DOCSOURCES)
cd $(DOCSOURCEDIR)
-mkdir $(DOCDIR)\html\$(NAME)
copy *.gif $(DOCDIR)\html\$(NAME)
-start $(WAITFLAG) tex2rtf $(DOCSOURCEDIR)\manual.tex $(DOCDIR)\html\$(NAME)\$(NAME) -html -twice
-erase $(DOCDIR)\html\$(NAME)\*.con
-erase *.con
-erase $(DOCDIR)\html\$(NAME)\*.ref
cd $(THISDIR)
$(DOCDIR)\htmlhelp\$(NAME).chm: $(DOCDIR)\html\$(NAME)\$(NAME).htm $(DOCDIR)\html\$(NAME)\$(NAME).hhp
cd $(DOCDIR)\html\$(NAME)
-hhc $(NAME).hhp
-erase $(DOCDIR)\htmlhelp\$(NAME).chm
move $(NAME).chm $(DOCDIR)\htmlhelp\$(NAME).chm
cd $(THISDIR)
# An htb file is a zip file containing the .htm, .gif, .hhp, .hhc and .hhk
# files, renamed to htb.
# This can then be used with e.g. helpview.
# Optionally, a cached version of the .hhp file can be generated with hhp2cached.
$(DOCDIR)\htb\$(NAME).htb: $(DOCDIR)\html\$(NAME)\$(NAME).htm
cd $(DOCDIR)\html\$(NAME)
-erase $(NAME).zip $(NAME).htb
zip $(NAME).zip *.htm *.gif *.hhp *.hhc *.hhk
-mkdir $(DOCDIR)\htb
-erase $(DOCDIR)\htb\$(NAME).htb
-erase $(DOCDIR)\htb\$(NAME).htb
move $(NAME).zip $(DOCDIR)\htb\$(NAME).htb
cd $(THISDIR)
$(DOCSOURCEDIR)\$(NAME).dvi: $(DOCSOURCES)
cd $(DOCSOURCEDIR)
-latex $(NAME)
-latex $(NAME)
-makeindx $(NAME)
-bibtex $(NAME)
-latex $(NAME)
-latex $(NAME)
cd $(THISDIR)
$(WXDIR)\docs\ps\$(NAME).ps: $(DOCSOURCEDIR)\$(NAME).dvi
cd $(DOCSOURCEDIR)
-dvips32 -o $(NAME).ps $(NAME)
move $(NAME).ps $(WXDIR)\docs\ps\$(NAME).ps
cd $(THISDIR)

653
wxPython/contrib/gizmos/wxCode/src/gizmos/multicell.cpp Normal file
View File

@@ -0,0 +1,653 @@
/////////////////////////////////////////////////////////////////////////////
// Name: multicell.cpp
// 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
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif
#include "wx/gizmos/multicell.h"
//---------------------------------------------------------------------------
IMPLEMENT_ABSTRACT_CLASS(wxMultiCellSizer, wxSizer);
IMPLEMENT_ABSTRACT_CLASS(wxMultiCellItemHandle, wxObject);
//---------------------------------------------------------------------------
// wxMultiCellItemHandle
//---------------------------------------------------------------------------
/*
*Function Name: wxMultiCellItemHandle :: wxMultiCellItemHandle
*
*Parameters: int row
* int column
* int height
* int width
* wxSize size
* wxResizable Style
* wxSize weight
* int align
*
*Description: This is the constructor for the class.
*
*/
void wxMultiCellItemHandle :: Initialize( int row, int column, int height, int width, wxSize size, wxResizable Style, wxSize weight, int align)
{
m_column = column;
m_row = row;
m_width = width;
m_height = height;
m_style = Style;
m_fixedSize = size;
m_alignment = align;
m_weight = weight;
}
//---------------------------------------------------------------------------
wxMultiCellItemHandle :: wxMultiCellItemHandle( int row, int column, int height, int width, wxSize size, wxResizable Style, wxSize weight, int align)
{
Initialize(row, column,height, width, size, Style, weight, align);
}
//---------------------------------------------------------------------------
wxMultiCellItemHandle :: wxMultiCellItemHandle( int row, int column, wxSize size, wxResizable style, wxSize weight, int align)
{
Initialize(row, column,1, 1, size, style, weight, align);
}
//---------------------------------------------------------------------------
wxMultiCellItemHandle :: wxMultiCellItemHandle( int row, int column, wxResizable style, wxSize weight, int align)
{
Initialize(row, column, 1, 1, wxSize(1, 1), style, weight, align);
}
//---------------------------------------------------------------------------
int wxMultiCellItemHandle::GetColumn() const
{
return m_column;
}
//---------------------------------------------------------------------------
int wxMultiCellItemHandle::GetRow() const
{
return m_row;
}
//---------------------------------------------------------------------------
int wxMultiCellItemHandle::GetWidth() const
{
return m_width;
}
//---------------------------------------------------------------------------
int wxMultiCellItemHandle::GetHeight() const
{
return m_height;
}
//---------------------------------------------------------------------------
wxResizable wxMultiCellItemHandle :: GetStyle() const
{
return m_style;
};
//---------------------------------------------------------------------------
wxSize wxMultiCellItemHandle :: GetLocalSize() const
{
return m_fixedSize;
};
//---------------------------------------------------------------------------
int wxMultiCellItemHandle :: GetAlignment() const
{
return m_alignment;
};
//---------------------------------------------------------------------------
wxSize wxMultiCellItemHandle :: GetWeight() const
{
return m_weight;
};
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// wxMultiCellSizer
//---------------------------------------------------------------------------
/*
*Function Name: wxMultiCellSizer::Initialize
*
*Parameters: wxsize Initial size of sizer
*
*Description: This is a common function to initialize all the members of
* this class. It is only called from the constructors
*
*/
void wxMultiCellSizer::Initialize( wxSize size )
{
m_cell_count = size;
m_maxHeight = (int *)malloc((1 + m_cell_count.GetHeight()) * sizeof(int));
m_maxWidth = (int *)malloc( (1 + m_cell_count.GetWidth()) * sizeof(int));
m_rowStretch = (int *)malloc( (1 + m_cell_count.GetHeight()) * sizeof(int));
m_colStretch = (int *)malloc((1 + m_cell_count.GetWidth()) * sizeof(int));
m_weights = (wxSize **)malloc((1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth())) * sizeof(wxSize *));
m_minSizes = (wxSize **)malloc((1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth())) * sizeof(wxSize *));
for (int x = 0; x < 1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth()); x++)
{
m_weights[x] = new wxSize(0,0);
m_minSizes[x] = new wxSize(0,0);
}
m_maxWeights = 1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth());
m_defaultCellSize = wxSize(5, 5);
m_win = NULL;
m_pen = wxRED_PEN;
}
//---------------------------------------------------------------------------
wxMultiCellSizer::wxMultiCellSizer( wxSize & size )
{
Initialize(size);
}
//---------------------------------------------------------------------------
wxMultiCellSizer::wxMultiCellSizer( int rows, int cols)
{
wxSize size(cols, rows);
Initialize(size);
}
//---------------------------------------------------------------------------
wxMultiCellSizer::~wxMultiCellSizer()
{
WX_CLEAR_LIST(wxSizerItemList, m_children);
free(m_maxHeight);
free(m_maxWidth);
free(m_rowStretch);
free(m_colStretch);
for (int x = 0; x < 1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth()); x++)
{
delete m_weights[x];
delete m_minSizes[x];
}
free(m_weights);
free(m_minSizes);
}
//---------------------------------------------------------------------------
bool wxMultiCellSizer::EnableGridLines(wxWindow *win)
{
m_win = win;
return true;
}
//---------------------------------------------------------------------------
bool wxMultiCellSizer::SetGridPen(const wxPen *pen)
{
m_pen = pen;
return true;
}
//---------------------------------------------------------------------------
bool wxMultiCellSizer::SetDefaultCellSize(wxSize size)
{
m_defaultCellSize = size;
return true;
}
//---------------------------------------------------------------------------
bool wxMultiCellSizer::SetColumnWidth(int column, int colSize, bool expandable)
{
if (expandable)
{
m_minSizes[column]->SetWidth(-colSize);
}
else
{
m_minSizes[column]->SetWidth(colSize);
}
return true;
}
//---------------------------------------------------------------------------
bool wxMultiCellSizer::SetRowHeight(int row, int rowSize, bool expandable)
{
if (expandable)
{
m_minSizes[row]->SetHeight(-rowSize);
}
else
{
m_minSizes[row]->SetHeight(rowSize);
}
return true;
}
//---------------------------------------------------------------------------
void wxMultiCellSizer::RecalcSizes()
{
if (m_children.GetCount() == 0)
return;
wxSize size = GetSize();
wxPoint pos = GetPosition();
GetMinimums();
// We need to take the unused space and equally give it out to all the rows/columns
// which are stretchable
int unUsedWidth = size.GetWidth() - Sum(m_maxWidth, m_cell_count.GetWidth());
int unUsedHeight = size.GetHeight() - Sum(m_maxHeight, m_cell_count.GetHeight());
int totalWidthWeight = 0;
int totalHeightWeight = 0;
int x;
for (x = 0; x < wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth()); x++)
{
if (m_rowStretch[x])
{
totalHeightWeight += m_weights[x]->GetHeight();
}
if (x < m_cell_count.GetWidth() && m_colStretch[x])
{
totalWidthWeight += m_weights[x]->GetWidth();
}
}
for (x = 0; x < wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth()); x++)
{
if (x < m_cell_count.GetHeight() && m_rowStretch[x])
{
m_maxHeight[x] += unUsedHeight * m_weights[x]->GetHeight() / totalHeightWeight;
}
if (x < m_cell_count.GetWidth() && m_colStretch[x])
{
m_maxWidth[x] += unUsedWidth * m_weights[x]->GetWidth() / totalWidthWeight;
}
}
// We now have everything we need to figure each cell position and size
// The arrays m_maxHeight and m_maxWidth now contain the final widths and height of
// each row and column.
double cell_width = (double)size.GetWidth() / (double)m_cell_count.GetWidth();
double cell_height = (double)size.GetHeight() / (double)m_cell_count.GetHeight();
wxPoint c_point;
wxSize c_size;
wxSizerItemList::compatibility_iterator current = m_children.GetFirst();
while (current)
{
wxSizerItem *item = current->GetData();
wxMultiCellItemHandle *rect;
if (item != NULL &&
(rect = (wxMultiCellItemHandle *)item->GetUserData()) != NULL)
{
c_point.x = pos.x + (int)(rect->GetColumn() * cell_width);
c_point.y = pos.y + (int)(rect->GetRow() * cell_height);
c_point.x = pos.x + Sum(m_maxWidth, rect->GetColumn());
c_point.y = pos.y + Sum(m_maxHeight, rect->GetRow());
c_size = rect->GetLocalSize();
wxSize minSize( item->CalcMin() );
if (c_size.GetHeight() != wxDefaultCoord ||
c_size.GetWidth() != wxDefaultCoord)
{
minSize.SetHeight(wxMax(minSize.GetHeight(), c_size.GetHeight()));
minSize.SetWidth(wxMax(minSize.GetWidth(), c_size.GetWidth()));
}
if (rect->GetStyle() & wxHORIZONTAL_RESIZABLE ||
rect->GetWidth() > 1
|| m_minSizes[rect->GetColumn()]->GetWidth() < 0)
{
int w = 0;
for (int x = 0; x < rect->GetWidth(); x++)
{
w += m_maxWidth[rect->GetColumn() + x];
}
c_size.SetWidth(w);
}
else
{
c_size.SetWidth(minSize.GetWidth() );
}
if (rect->GetStyle() & wxVERTICAL_RESIZABLE ||
rect->GetHeight() > 1 ||
m_minSizes[rect->GetRow()]->GetHeight() < 0)
{
int h = 0;
for (int x = 0; x < rect->GetHeight(); x++)
{
h += m_maxHeight[rect->GetRow() + x];
}
c_size.SetHeight(h);
}
else
{
c_size.SetHeight(minSize.GetHeight());
}
int extraHeight = (m_maxHeight[rect->GetRow()] - c_size.GetHeight());
int extraWidth = (m_maxWidth[rect->GetColumn()] - c_size.GetWidth());
if (rect->GetWidth() == 1 && rect->GetAlignment() & wxALIGN_CENTER_HORIZONTAL)
{
c_point.x += extraWidth / 2;
}
if (rect->GetWidth() == 1 && rect->GetAlignment() & wxALIGN_RIGHT)
{
c_point.x += extraWidth;
}
if (rect->GetHeight() == 1 && rect->GetAlignment() & wxALIGN_CENTER_VERTICAL)
{
c_point.y += extraHeight / 2;
}
if (rect->GetHeight() == 1 && rect->GetAlignment() & wxALIGN_BOTTOM)
{
c_point.y += extraHeight;
}
item->SetDimension(c_point, c_size);
}
current = current->GetNext();
}
}
//---------------------------------------------------------------------------
wxSize wxMultiCellSizer::CalcMin()
{
if (m_children.GetCount() == 0)
return wxSize(10,10);
GetMinimums();
int m_minWidth = Sum(m_maxWidth, m_cell_count.GetWidth());
int m_minHeight = Sum(m_maxHeight, m_cell_count.GetHeight());
return wxSize( m_minWidth, m_minHeight );
}
//---------------------------------------------------------------------------
void wxMultiCellSizer :: GetMinimums()
{
// We first initial all the arrays EXCEPT for the m_minsizes array.
memset(m_maxHeight, 0, sizeof(int) * m_cell_count.GetHeight());
memset(m_maxWidth, 0, sizeof(int) * m_cell_count.GetWidth());
memset(m_rowStretch, 0, sizeof(int) * m_cell_count.GetHeight());
memset(m_colStretch, 0, sizeof(int) * m_cell_count.GetWidth());
for (int x = 0; x < 1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth()); x++)
{
m_weights[x]->SetHeight(0);
m_weights[x]->SetWidth(0);
}
wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
while (node)
{
wxSizerItem *item = node->GetData();
wxMultiCellItemHandle *rect;
if (item != NULL &&
(rect = (wxMultiCellItemHandle *)item->GetUserData()) != NULL)
{
int row = rect->GetRow();
int col = rect->GetColumn();
// First make sure that the control knows about the max rows and columns
int changed = false;
if (row + 1 > m_cell_count.GetHeight())
{
changed++;
m_maxHeight = (int *)realloc(m_maxHeight, (1 + row) * sizeof(int));
m_rowStretch = (int *)realloc(m_rowStretch, (1 + row) * sizeof(int));
for (int x = m_cell_count.GetHeight(); x < row + 1; x++)
{
m_maxHeight[x - 1] = 0;
m_rowStretch[x - 1] = 0;
}
m_cell_count.SetHeight(row + 1);
}
if (col + 1 > m_cell_count.GetWidth())
{
changed++;
m_maxWidth = (int *)realloc(m_maxWidth, (1 + col) * sizeof(int));
m_colStretch = (int *)realloc(m_colStretch, ( 1 + col) * sizeof(int));
for (int x = m_cell_count.GetWidth(); x < col + 1; x++)
{
m_maxWidth[x - 1] = 0;
m_colStretch[x - 1] = 0;
}
m_cell_count.SetWidth(col + 1);
}
if (changed)
{
m_weights = (wxSize **)realloc(m_weights, (1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth())) * sizeof(wxSize *));
m_minSizes = (wxSize **)realloc(m_minSizes, (1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth())) * sizeof(wxSize *));
for (int x = m_maxWeights; x < 1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth()); x++)
{
m_weights[x - 1] = new wxSize(0,0);
m_minSizes[x - 1] = new wxSize(0,0);
}
m_maxWeights = 1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth());
}
// Sum the m_weights for each row/column, but only if they are resizable
wxSize minSize( item->CalcMin() );
wxSize c_size = rect->GetLocalSize();
if (c_size.GetHeight() != wxDefaultCoord ||
c_size.GetWidth() != wxDefaultCoord)
{
minSize.SetHeight(wxMax(minSize.GetHeight(), c_size.GetHeight()));
minSize.SetWidth(wxMax(minSize.GetWidth(), c_size.GetWidth()));
}
// For each row, calculate the max height for those fields which are not
// resizable in the vertical pane
if (!(rect->GetStyle() & wxVERTICAL_RESIZABLE || m_minSizes[row]->GetHeight() < 0))
{
m_maxHeight[row] = wxMax(m_maxHeight[row], minSize.GetHeight() / rect->GetHeight());
}
else
{
m_rowStretch[row] = 1;
if (m_minSizes[row]->GetHeight())
{
m_maxHeight[row] = abs(m_minSizes[row]->GetHeight());
}
else
{
m_maxHeight[row] = wxMax(m_maxHeight[row], m_defaultCellSize.GetHeight());
}
m_weights[row]->SetHeight(wxMax(m_weights[row]->GetHeight(), rect->GetWeight().GetHeight()));
}
// For each column, calculate the max width for those fields which are not
// resizable in the horizontal pane
if (!(rect->GetStyle() & wxHORIZONTAL_RESIZABLE || m_minSizes[col]->GetWidth() < 0))
{
if (m_minSizes[col]->GetWidth())
{
m_maxWidth[col] = abs(m_minSizes[col]->GetWidth());
}
else
{
m_maxWidth[col] = wxMax(m_maxWidth[col], minSize.GetWidth() / rect->GetWidth());
}
}
else
{
m_colStretch[col] = 1;
m_maxWidth[col] = wxMax(m_maxWidth[col], m_defaultCellSize.GetWidth());
m_weights[col]->SetWidth(wxMax(m_weights[col]->GetWidth(), rect->GetWeight().GetWidth()));
}
node = node->GetNext();
}
}
} // wxMultiCellSizer :: GetMinimums
//---------------------------------------------------------------------------
/*
*Function Name: wxMultiCellSizer :: Sum
*
*Parameters: int* pointer to array of ints
* int Number of cells to sum up
*
*Description: This member function sums up all the elements of the array which
* preceed the specified cell.
*
*Returns: int Sum
*
*/
/* static */ int wxMultiCellSizer :: Sum(int *array, int x)
{
int sum = 0;
while (x--)
{
sum += array[x];
}
return sum;
}
//---------------------------------------------------------------------------
/*
*Function Name: wxMultiCellSizer :: DrawGridLines
*
*Parameters: wxDC Device context
*
*Description: This function draws the grid lines in the specified device context.
*
*/
void wxMultiCellSizer :: DrawGridLines(wxDC& dc)
{
RecalcSizes();
int maxW = Sum(m_maxWidth, m_cell_count.GetWidth());
int maxH = Sum(m_maxHeight, m_cell_count.GetHeight());
int x;
// Draw the columns
dc.SetPen(* m_pen);
for (x = 1; x < m_cell_count.GetWidth(); x++)
{
int colPos = Sum(m_maxWidth, x) ;
dc.DrawLine(colPos, 0, colPos, maxH);
}
// Draw the rows
for (x = 1; x < m_cell_count.GetHeight(); x++)
{
int rowPos = Sum(m_maxHeight, x);
dc.DrawLine(0, rowPos, maxW, rowPos);
}
}
//---------------------------------------------------------------------------
// Define the repainting behaviour
/*
*Function Name: wxMultiCellSizer::OnPaint
*
*Parameters: wxDC Device context
*
*Description: This function calls the DrawGridLines() member if a window
* has been previously specified. This functions MUST be called
* from an OnPaint member belonging to the window which the sizer
* is attached to.
*
*/
void wxMultiCellSizer::OnPaint(wxDC& dc )
{
if (m_win)
{
DrawGridLines(dc);
}
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
#define CELL_LOC(row, col) ((row) * m_maxCols + col)
//---------------------------------------------------------------------------
// wxCell
//---------------------------------------------------------------------------
/*
*Function Name: wxCell : wxLayoutConstraints
*
*Description: This class is used by wxMultiCellCanvas for internal storage
*
*/
class wxCell : public wxLayoutConstraints
{
public:
wxCell(wxWindow *win)
{
m_window = win;
};
wxWindow *m_window;
};
//---------------------------------------------------------------------------
// wxMultiCellCanvas
//---------------------------------------------------------------------------
wxMultiCellCanvas :: wxMultiCellCanvas(wxWindow *par, int numRows, int numCols)
: wxFlexGridSizer(numRows, numCols, 0, 0)
{
m_cells = (wxCell **)calloc(numRows * numCols, sizeof(wxCell *));
m_parent = par;
m_maxRows = numRows;
m_maxCols = numCols;
m_minCellSize = wxSize(5, 5);
}
//---------------------------------------------------------------------------
void wxMultiCellCanvas :: Add(wxWindow *win, unsigned int row, unsigned int col)
{
// thanks to unsigned data row and col are always >= 0
wxASSERT_MSG( /* row >= 0 && */ row < m_maxRows,
wxString::Format(_T("Row %d out of bounds (0..%d)"), row, m_maxRows) );
wxASSERT_MSG( /* col >= 0 && */ col < m_maxCols,
wxString::Format(_T("Column %d out of bounds (0..%d)"), col, m_maxCols) );
wxASSERT_MSG(m_cells[CELL_LOC(row, col)] == NULL, wxT("Cell already occupied"));
wxCell *newCell = new wxCell(win);
m_cells[CELL_LOC(row,col)] = newCell;
}
//---------------------------------------------------------------------------
void wxMultiCellCanvas :: CalculateConstraints()
{
unsigned int row, col;
for (row = 0; row < m_maxRows; row++)
{
for (col = 0; col < m_maxCols; col++)
{
if (!m_cells[CELL_LOC(row, col)])
{
// Create an empty static text field as a placeholder
m_cells[CELL_LOC(row, col)] = new wxCell(new wxStaticText(m_parent, wxID_ANY, wxEmptyString));
}
wxFlexGridSizer::Add(m_cells[CELL_LOC(row, col)]->m_window);
}
}
}
/*** End of File ***/

130
wxPython/contrib/gizmos/wxCode/src/gizmos/multicell.txt Normal file
View File

@@ -0,0 +1,130 @@
These two classes make it easier to lay objects out on a screen. The
first class is the wxMultiCellCanvas, which uses the wxFlexGridSizer
control, so it is subject to the same limitations of that control. Among
them is the fact that if the window is resized smaller than the control,
then some of the objects will be obscured by the window edge.
The second class is the wxMultiCellSizer, which is significantly more
powerful than the wxMultiCell Canvas. This control supports resizing of
objects on the fly, objects spanning cells, etc.
Use the wxMultiCellCanvas when you have a simple layout which won't resize
and doesn't have any unusual requirements. Use the wxMultiCellSizer when
your needs are greater
wxMultiCellCanvas
=================
The wxMultiCellCanvas class allows you to add objects to a wxFlexGridSizer
by specifying a row and a column location. When all objects have been
added, you need to call a member function CalculateConstraints(), which
will insert the objects into the wxFlexGridSizer. If there are empty
cells the canvas will insert empty wxStaticText objects as placeholders.
Upon creation of the canvas the size of the canvas needs to be specified.
Attempting to insert a cell outside those limits will cause an assertion
error.
When adding cells, the cell locations are specified as a row,column
location, both being zero-based. 0,0 is the upper left corner of the
canvas.
wxMultiCellSizer
================
The wxMultiCellSizer class manages a collection of child windows in a way
similar to that of data stored in a spreadsheet. A multicell canvas is a
two-dimensional array of cells with an origin of (0,0) in the upper-left
corner. Windows are added to a multicell sizer by first creating a
wxMultiCellItemHandle object which specifies a starting cell and,
optionally, a number of contiguous columns, rows, or a combination
thereof, and then adding it to the sizer.
This class bases the initial cell sizes on the minimum sizes returned by
each child window of the sizer. You can override the minimum sizes
provided by the wxWindows Class Library by doing either of the following:
o Specifying the size when creating the wxMultiCellItemHandle object
o Creating a derived class and implementing a CalcMin function
The wxMultiCellItemHandle must be passed the row and column of the item,
at a minimum. Optionally, more information can be passed:
int row Row position, zero based
int column Column position, zero based
int height Number of rows this cell will occupy, default is 1
int width Number of columns this cell will occupy, default is 1
Note that if the height or width is greater than one that
dimension is assumed to be resizable because it is spanning
multiple cells.
wxSize minSize Minimum size of the object.
wxResizable Style Is this object resizable, and if so, how. Allowable styles are:
wxNOT_RESIZABLE
wxHORIZENTAL_RESIZABLE
wxVERTICAL_RESIZABLE
wxRESIZABLE
wxSize weight If this is a resizable object, the weight applied to the specific dimension.
This is useful if you have several resizable rows and/or columns, and you want
one to get more of the available space than the others.
int align This is a wxAlignment value, it is an integer so you can 'or multiple
values together. The acceptable values are:
wxALIGN_NOT
wxALIGN_CENTER_HORIZONTAL
wxALIGN_CENTRE_HORIZONTAL
wxALIGN_LEFT
wxALIGN_TOP
wxALIGN_RIGHT
wxALIGN_BOTTOM
wxALIGN_CENTER_VERTICAL
wxALIGN_CENTRE_VERTICAL
wxALIGN_CENTER
wxALIGN_CENTRE
Note that some combinations of these make no sense, for example wxALIGN_LEFT | wxALIGN_RIGHT.
See the definition of wxAlignment for more information
Other functions are:
void RecalcSizes() Should not be called by the user, needed by the wxSizer class
wxSize CalcMin() Should not be called by the user, needed by the wxSizer class
bool SetDefaultCellSize Set the default cell size of an empty cell
bool SetColumnWidth Set the width of a column, optionally specifying it as resizable
bool SetRowHeight Set the height of a row, optionally specifying it as resizable
Sometimes it can be very confusing to determine the relationship between rows, columns, and
which ones are resizable or not. Three functions are supplied to make this easier:
bool EnableGridLines(wxWindow *win); Call this to either enable or disable the grid lines.
Pass the window the sizer is on, or NULL to disable.
Currently the window is not used, but it may be in the
future.
bool SetGridPen(wxPen *pen); Set the pen color, the default pen color is red
void OnPaint(wxDC& dc); Call this from an OnPaint function associated with the
window the sizer is attached to. See the example program
mtest.cpp for specific details on how to do this.
Files Description
===== ===========
docs.txt This file
// wxMultiCellCanvas and wxMultiCellSizer
makefile Makefile for the MingW32 compiler
multicell.cpp Class source code file
multicell.h Class header file
//Sample
mtest.cpp Example program, demonstrates both classes
mtest.rc
mtest.gif
makefile
Acknowledgments
===============
This was inspired by the gbsizer class written by Alex Andruschak, and the IMultiCellCanvas
class in the IBM Class Libraries in the VisualeAge C++ compilers.

2
wxPython/contrib/gizmos/wxCode/src/gizmos/multicell_todo.txt Normal file
View File

@@ -0,0 +1,2 @@
2. Documentation

745
wxPython/contrib/gizmos/wxCode/src/gizmos/splittree.cpp Normal file
View File

@@ -0,0 +1,745 @@
/////////////////////////////////////////////////////////////////////////////
// Name: splittree.cpp
// 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
/////////////////////////////////////////////////////////////////////////////
// ============================================================================
// declarations
// ============================================================================
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
// for all others, include the necessary headers (this file is usually all you
// need because it includes almost all "standard" wxWidgets headers)
#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif
#ifdef __WXMSW__
#include <windows.h>
#include "wx/msw/winundef.h"
#endif
#include "wx/gizmos/splittree.h"
#include <math.h>
/*
* wxRemotelyScrolledTreeCtrl
*/
#if USE_GENERIC_TREECTRL
IMPLEMENT_CLASS(wxRemotelyScrolledTreeCtrl, wxGenericTreeCtrl)
#else
IMPLEMENT_CLASS(wxRemotelyScrolledTreeCtrl, wxTreeCtrl)
#endif
#if USE_GENERIC_TREECTRL
BEGIN_EVENT_TABLE(wxRemotelyScrolledTreeCtrl, wxGenericTreeCtrl)
#else
BEGIN_EVENT_TABLE(wxRemotelyScrolledTreeCtrl, wxTreeCtrl)
#endif
EVT_SIZE(wxRemotelyScrolledTreeCtrl::OnSize)
EVT_PAINT(wxRemotelyScrolledTreeCtrl::OnPaint)
EVT_TREE_ITEM_EXPANDED(wxID_ANY, wxRemotelyScrolledTreeCtrl::OnExpand)
EVT_TREE_ITEM_COLLAPSED(wxID_ANY, wxRemotelyScrolledTreeCtrl::OnExpand)
EVT_SCROLLWIN(wxRemotelyScrolledTreeCtrl::OnScroll)
END_EVENT_TABLE()
wxRemotelyScrolledTreeCtrl::wxRemotelyScrolledTreeCtrl(
wxWindow* parent, wxWindowID id, const wxPoint& pt,
const wxSize& sz, long style)
: wxTreeCtrl(parent, id, pt, sz, style & ~wxTR_ROW_LINES)
{
m_companionWindow = NULL;
// We draw the row lines ourself so they match what's done
// by the companion window. That is why the flag is turned
// off above, so wxGenericTreeCtrl doesn't draw them in a
// different colour.
m_drawRowLines = (style & wxTR_ROW_LINES) != 0;
}
wxRemotelyScrolledTreeCtrl::~wxRemotelyScrolledTreeCtrl()
{
}
void wxRemotelyScrolledTreeCtrl::HideVScrollbar()
{
#if defined(__WXMSW__)
#if USE_GENERIC_TREECTRL
if (!IsKindOf(CLASSINFO(wxGenericTreeCtrl)))
#endif
{
::ShowScrollBar((HWND) GetHWND(), SB_VERT, false);
}
#if USE_GENERIC_TREECTRL
else
{
// Implicit in overriding SetScrollbars
}
#endif
#endif
}
// 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
void wxRemotelyScrolledTreeCtrl::SetScrollbars(
#if USE_GENERIC_TREECTRL || !defined(__WXMSW__)
int pixelsPerUnitX, int pixelsPerUnitY,
int noUnitsX, int noUnitsY,
int xPos, int yPos,
bool noRefresh
#else
int WXUNUSED(pixelsPerUnitX), int WXUNUSED(pixelsPerUnitY),
int WXUNUSED(noUnitsX), int WXUNUSED(noUnitsY),
int WXUNUSED(xPos), int WXUNUSED(yPos),
bool WXUNUSED(noRefresh)
#endif
)
{
#if USE_GENERIC_TREECTRL || !defined(__WXMSW__)
if (IsKindOf(CLASSINFO(wxGenericTreeCtrl)))
{
wxGenericTreeCtrl* win = (wxGenericTreeCtrl*) this;
win->wxGenericTreeCtrl::SetScrollbars(pixelsPerUnitX, pixelsPerUnitY, noUnitsX, 0, xPos, 0, /* noRefresh */ true);
wxScrolledWindow* scrolledWindow = GetScrolledWindow();
if (scrolledWindow)
{
scrolledWindow->SetScrollbars(0, pixelsPerUnitY, 0, noUnitsY, 0, yPos, noRefresh);
}
}
#endif
}
// In case we're using the generic tree control.
int wxRemotelyScrolledTreeCtrl::GetScrollPos(
#if USE_GENERIC_TREECTRL || !defined(__WXMSW__)
int orient
#else
int WXUNUSED(orient)
#endif
) const
{
#if USE_GENERIC_TREECTRL || !defined(__WXMSW__)
// this condition fixes extsitence of warning but
wxScrolledWindow* scrolledWindow =
// but GetScrolledWindow is still executed in case internally does something
#endif
GetScrolledWindow();
#if USE_GENERIC_TREECTRL || !defined(__WXMSW__)
if (IsKindOf(CLASSINFO(wxGenericTreeCtrl)))
{
wxGenericTreeCtrl* win = (wxGenericTreeCtrl*) this;
if (orient == wxHORIZONTAL)
return win->wxGenericTreeCtrl::GetScrollPos(orient);
else
{
return scrolledWindow->GetScrollPos(orient);
}
}
#endif
return 0;
}
// In case we're using the generic tree control.
// Get the view start
void wxRemotelyScrolledTreeCtrl::GetViewStart(int *x, int *y) const
{
wxScrolledWindow* scrolledWindow = GetScrolledWindow();
#if USE_GENERIC_TREECTRL || !defined(__WXMSW__)
if (IsKindOf(CLASSINFO(wxGenericTreeCtrl)))
{
wxGenericTreeCtrl* win = (wxGenericTreeCtrl*) this;
int x1, y1, x2, y2;
win->wxGenericTreeCtrl::GetViewStart(& x1, & y1);
* x = x1; * y = y1;
if (!scrolledWindow)
return;
scrolledWindow->GetViewStart(& x2, & y2);
* y = y2;
}
else
#endif
{
// x is wrong since the horizontal scrollbar is controlled by the
// tree control, but we probably don't need it.
scrolledWindow->GetViewStart(x, y);
}
}
// In case we're using the generic tree control.
void wxRemotelyScrolledTreeCtrl::PrepareDC(
#if USE_GENERIC_TREECTRL || !defined(__WXMSW__)
wxDC& dc
#else
wxDC& WXUNUSED(dc)
#endif
)
{
#if USE_GENERIC_TREECTRL || !defined(__WXMSW__)
if (IsKindOf(CLASSINFO(wxGenericTreeCtrl)))
{
wxScrolledWindow* scrolledWindow = GetScrolledWindow();
wxGenericTreeCtrl* win = (wxGenericTreeCtrl*) this;
int startX, startY;
GetViewStart(& startX, & startY);
int xppu1, yppu1, xppu2, yppu2;
win->wxGenericTreeCtrl::GetScrollPixelsPerUnit(& xppu1, & yppu1);
scrolledWindow->GetScrollPixelsPerUnit(& xppu2, & yppu2);
dc.SetDeviceOrigin( -startX * xppu1, -startY * yppu2 );
// dc.SetUserScale( win->GetScaleX(), win->GetScaleY() );
}
#endif
}
// Scroll to the given line (in scroll units where each unit is
// the height of an item)
void wxRemotelyScrolledTreeCtrl::ScrollToLine(int WXUNUSED(posHoriz), int posVert)
{
#ifdef __WXMSW__
#if USE_GENERIC_TREECTRL
if (!IsKindOf(CLASSINFO(wxGenericTreeCtrl)))
#endif // USE_GENERIC_TREECTRL
{
UINT sbCode = SB_THUMBPOSITION;
HWND vertScrollBar = 0;
MSWDefWindowProc((WXUINT) WM_VSCROLL, MAKELONG(sbCode, posVert), (WXLPARAM) vertScrollBar);
}
#if USE_GENERIC_TREECTRL
else
#endif // USE_GENERIC_TREECTRL
#endif // __WXMSW__
#if USE_GENERIC_TREECTRL || !defined(__WXMSW__)
{
wxGenericTreeCtrl* win = (wxGenericTreeCtrl*) this;
win->Refresh();
/* Doesn't work yet because scrolling is ignored by Scroll
int xppu, yppu;
wxScrolledWindow* scrolledWindow = GetScrolledWindow();
if (scrolledWindow)
{
scrolledWindow->GetScrollPixelsPerUnit(& xppu, & yppu);
win->Scroll(-1, posVert*yppu);
}
*/
}
#endif // USE_GENERIC_TREECTRL || !defined(__WXMSW__)
wxUnusedVar(posVert);
}
void wxRemotelyScrolledTreeCtrl::OnSize(wxSizeEvent& event)
{
HideVScrollbar();
AdjustRemoteScrollbars();
event.Skip();
}
void wxRemotelyScrolledTreeCtrl::OnExpand(wxTreeEvent& event)
{
AdjustRemoteScrollbars();
event.Skip();
// If we don't have this, we get some bits of lines still remaining
if (event.GetEventType() == wxEVT_COMMAND_TREE_ITEM_COLLAPSED)
Refresh();
// Pass on the event
if (m_companionWindow)
m_companionWindow->GetEventHandler()->ProcessEvent(event);
}
void wxRemotelyScrolledTreeCtrl::OnPaint(wxPaintEvent& event)
{
wxPaintDC dc(this);
wxTreeCtrl::OnPaint(event);
if (! m_drawRowLines)
return;
// Reset the device origin since it may have been set
dc.SetDeviceOrigin(0, 0);
wxPen pen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DLIGHT), 1, wxSOLID);
dc.SetPen(pen);
dc.SetBrush(* wxTRANSPARENT_BRUSH);
wxSize clientSize = GetClientSize();
wxRect itemRect;
wxTreeItemId h, lastH;
for (h=GetFirstVisibleItem();
h.IsOk();
h=GetNextVisible(h))
{
if (GetBoundingRect(h, itemRect))
{
int cy = itemRect.GetTop();
dc.DrawLine(0, cy, clientSize.x, cy);
lastH = h;
}
if (! IsVisible(h))
break;
}
if (lastH.IsOk() && GetBoundingRect(lastH, itemRect))
{
int cy = itemRect.GetBottom();
dc.DrawLine(0, cy, clientSize.x, cy);
}
}
// Adjust the containing wxScrolledWindow's scrollbars appropriately
void wxRemotelyScrolledTreeCtrl::AdjustRemoteScrollbars()
{
#if USE_GENERIC_TREECTRL || !defined(__WXMSW__)
if (IsKindOf(CLASSINFO(wxGenericTreeCtrl)))
{
// This is for the generic tree control.
// It calls SetScrollbars which has been overridden
// to adjust the parent scrolled window vertical
// scrollbar.
((wxGenericTreeCtrl*) this)->AdjustMyScrollbars();
return;
}
else
#endif
{
// This is for the wxMSW tree control
wxScrolledWindow* scrolledWindow = GetScrolledWindow();
if (scrolledWindow)
{
wxRect itemRect;
if (GetBoundingRect(GetFirstVisibleItem(), itemRect))
{
// Actually, the real height seems to be 1 less than reported
// (e.g. 16 instead of 16)
int itemHeight = itemRect.GetHeight() - 1;
int w, h;
GetClientSize(&w, &h);
wxRect rect(0, 0, 0, 0);
CalcTreeSize(rect);
double f = ((double) (rect.GetHeight()) / (double) itemHeight) ;
int treeViewHeight = (int) ceil(f);
int scrollPixelsPerLine = itemHeight;
int scrollPos = - (itemRect.y / itemHeight);
scrolledWindow->SetScrollbars(0, scrollPixelsPerLine, 0, treeViewHeight, 0, scrollPos);
// Ensure that when a scrollbar becomes hidden or visible,
// the contained window sizes are right.
// Problem: this is called too early (?)
wxSizeEvent event(scrolledWindow->GetSize(), scrolledWindow->GetId());
scrolledWindow->GetEventHandler()->ProcessEvent(event);
}
}
}
}
// Calculate the area that contains both rectangles
static wxRect CombineRectangles(const wxRect& rect1, const wxRect& rect2)
{
wxRect rect;
int right1 = rect1.GetRight();
int bottom1 = rect1.GetBottom();
int right2 = rect2.GetRight();
int bottom2 = rect2.GetBottom();
wxPoint topLeft = wxPoint(wxMin(rect1.x, rect2.x), wxMin(rect1.y, rect2.y));
wxPoint bottomRight = wxPoint(wxMax(right1, right2), wxMax(bottom1, bottom2));
rect.x = topLeft.x; rect.y = topLeft.y;
rect.SetRight(bottomRight.x);
rect.SetBottom(bottomRight.y);
return rect;
}
// Calculate the tree overall size so we can set the scrollbar
// correctly
void wxRemotelyScrolledTreeCtrl::CalcTreeSize(wxRect& rect)
{
CalcTreeSize(GetRootItem(), rect);
}
void wxRemotelyScrolledTreeCtrl::CalcTreeSize(const wxTreeItemId& id, wxRect& rect)
{
// More efficient implementation would be to find the last item (but how?)
// Q: is the bounding rect relative to the top of the virtual tree workspace
// or the top of the window? How would we convert?
wxRect itemSize;
if (GetBoundingRect(id, itemSize))
{
rect = CombineRectangles(rect, itemSize);
}
wxTreeItemIdValue cookie;
wxTreeItemId childId = GetFirstChild(id, cookie);
while (childId)
{
CalcTreeSize(childId, rect);
childId = GetNextChild(childId, cookie);
}
}
// Find the scrolled window that contains this control
wxScrolledWindow* wxRemotelyScrolledTreeCtrl::GetScrolledWindow() const
{
wxWindow* parent = wxWindow::GetParent();
while (parent)
{
if (parent->IsKindOf(CLASSINFO(wxScrolledWindow)))
return (wxScrolledWindow*) parent;
parent = parent->GetParent();
}
return NULL;
}
void wxRemotelyScrolledTreeCtrl::OnScroll(wxScrollWinEvent& event)
{
int orient = event.GetOrientation();
if (orient == wxHORIZONTAL)
{
event.Skip();
return;
}
wxScrolledWindow* scrollWin = GetScrolledWindow();
if (!scrollWin)
return;
int x, y;
scrollWin->GetViewStart(& x, & y);
ScrollToLine(-1, y);
}
/*
* wxTreeCompanionWindow
*
* A window displaying values associated with tree control items.
*/
IMPLEMENT_CLASS(wxTreeCompanionWindow, wxWindow)
BEGIN_EVENT_TABLE(wxTreeCompanionWindow, wxWindow)
EVT_PAINT(wxTreeCompanionWindow::OnPaint)
EVT_SCROLLWIN(wxTreeCompanionWindow::OnScroll)
EVT_TREE_ITEM_EXPANDED(-1, wxTreeCompanionWindow::OnExpand)
EVT_TREE_ITEM_COLLAPSED(-1, wxTreeCompanionWindow::OnExpand)
END_EVENT_TABLE()
wxTreeCompanionWindow::wxTreeCompanionWindow(wxWindow* parent, wxWindowID id,
const wxPoint& pos,
const wxSize& sz,
long style):
wxWindow(parent, id, pos, sz, style)
{
m_treeCtrl = NULL;
}
void wxTreeCompanionWindow::DrawItem(wxDC& dc, wxTreeItemId id, const wxRect& rect)
{
// TEST CODE
#if 1
if (m_treeCtrl)
{
wxString text = m_treeCtrl->GetItemText(id);
dc.SetTextForeground(* wxBLACK);
dc.SetBackgroundMode(wxTRANSPARENT);
int textW, textH;
dc.GetTextExtent(text, & textW, & textH);
int x = 5;
int y = rect.GetY() + wxMax(0, (rect.GetHeight() - textH) / 2);
dc.DrawText(text, x, y);
}
#endif
}
void wxTreeCompanionWindow::OnPaint(wxPaintEvent& WXUNUSED(event))
{
wxPaintDC dc(this);
if (!m_treeCtrl)
return;
wxPen pen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DLIGHT), 1, wxSOLID);
dc.SetPen(pen);
dc.SetBrush(* wxTRANSPARENT_BRUSH);
wxFont font(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
dc.SetFont(font);
wxSize clientSize = GetClientSize();
wxRect itemRect;
wxTreeItemId h, lastH;
for (h=m_treeCtrl->GetFirstVisibleItem();
h.IsOk();
h=m_treeCtrl->GetNextVisible(h))
{
if (m_treeCtrl->GetBoundingRect(h, itemRect))
{
int cy = itemRect.GetTop();
wxRect drawItemRect(0, cy, clientSize.x, itemRect.GetHeight());
lastH = h;
// Draw the actual item
DrawItem(dc, h, drawItemRect);
dc.DrawLine(0, cy, clientSize.x, cy);
}
if (! m_treeCtrl->IsVisible(h))
break;
}
if (lastH.IsOk() && m_treeCtrl->GetBoundingRect(lastH, itemRect))
{
int cy = itemRect.GetBottom();
dc.DrawLine(0, cy, clientSize.x, cy);
}
}
void wxTreeCompanionWindow::OnScroll(wxScrollWinEvent& event)
{
int orient = event.GetOrientation();
if (orient == wxHORIZONTAL)
{
event.Skip();
return;
}
if (!m_treeCtrl)
return;
// TODO: scroll the window physically instead of just refreshing.
Refresh(true);
}
void wxTreeCompanionWindow::OnExpand(wxTreeEvent& WXUNUSED(event))
{
// TODO: something more optimized than simply refresh the whole
// window when the tree is expanded/collapsed. Tricky.
Refresh();
}
/*
* wxThinSplitterWindow
*/
IMPLEMENT_CLASS(wxThinSplitterWindow, wxSplitterWindow)
BEGIN_EVENT_TABLE(wxThinSplitterWindow, wxSplitterWindow)
EVT_SIZE(wxThinSplitterWindow::OnSize)
END_EVENT_TABLE()
wxThinSplitterWindow::wxThinSplitterWindow(wxWindow* parent, wxWindowID id,
const wxPoint& pos,
const wxSize& sz,
long style):
wxSplitterWindow(parent, id, pos, sz, style)
{
wxColour faceColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE));
m_facePen = new wxPen(faceColour, 1, wxSOLID);
m_faceBrush = new wxBrush(faceColour, wxSOLID);
}
wxThinSplitterWindow::~wxThinSplitterWindow()
{
delete m_facePen;
delete m_faceBrush;
}
void wxThinSplitterWindow::SizeWindows()
{
// The client size may have changed inbetween
// the sizing of the first window and the sizing of
// the second. So repeat SizeWindows.
wxSplitterWindow::SizeWindows();
wxSplitterWindow::SizeWindows();
}
// Tests for x, y over sash
bool wxThinSplitterWindow::SashHitTest(int x, int y, int WXUNUSED(tolerance))
{
return wxSplitterWindow::SashHitTest(x, y, 4);
}
void wxThinSplitterWindow::DrawSash(wxDC& dc)
{
if ( m_sashPosition == 0 || !m_windowTwo)
return;
if (GetWindowStyle() & wxSP_NOSASH)
return;
int w, h;
GetClientSize(&w, &h);
if ( m_splitMode == wxSPLIT_VERTICAL )
{
dc.SetPen(* m_facePen);
dc.SetBrush(* m_faceBrush);
int h1 = h-1;
int y1 = 0;
if ( (GetWindowStyleFlag() & wxSP_BORDER) != wxSP_BORDER && (GetWindowStyleFlag() & wxSP_3DBORDER) != wxSP_3DBORDER )
h1 += 1; // Not sure why this is necessary...
if ( (GetWindowStyleFlag() & wxSP_3DBORDER) == wxSP_3DBORDER)
{
y1 = 2; h1 -= 3;
}
dc.DrawRectangle(m_sashPosition, y1, GetSashSize(), h1);
}
else
{
dc.SetPen(* m_facePen);
dc.SetBrush(* m_faceBrush);
int w1 = w-1;
int x1 = 0;
if ( (GetWindowStyleFlag() & wxSP_BORDER) != wxSP_BORDER && (GetWindowStyleFlag() & wxSP_3DBORDER) != wxSP_3DBORDER )
w1 ++;
if ( (GetWindowStyleFlag() & wxSP_3DBORDER) == wxSP_3DBORDER)
{
x1 = 2; w1 -= 3;
}
dc.DrawRectangle(x1, m_sashPosition, w1, GetSashSize());
}
dc.SetPen(wxNullPen);
dc.SetBrush(wxNullBrush);
}
void wxThinSplitterWindow::OnSize(wxSizeEvent& event)
{
wxSplitterWindow::OnSize(event);
}
/*
* wxSplitterScrolledWindow
*/
IMPLEMENT_CLASS(wxSplitterScrolledWindow, wxScrolledWindow)
BEGIN_EVENT_TABLE(wxSplitterScrolledWindow, wxScrolledWindow)
EVT_SCROLLWIN(wxSplitterScrolledWindow::OnScroll)
EVT_SIZE(wxSplitterScrolledWindow::OnSize)
END_EVENT_TABLE()
wxSplitterScrolledWindow::wxSplitterScrolledWindow(wxWindow* parent, wxWindowID id,
const wxPoint& pos,
const wxSize& sz,
long style):
wxScrolledWindow(parent, id, pos, sz, style)
{
}
void wxSplitterScrolledWindow::OnSize(wxSizeEvent& WXUNUSED(event))
{
wxSize sz = GetClientSize();
if (GetChildren().GetFirst())
{
((wxWindow*) GetChildren().GetFirst()->GetData())->SetSize(0, 0, sz.x, sz.y);
}
}
void wxSplitterScrolledWindow::OnScroll(wxScrollWinEvent& event)
{
// Ensure that events being propagated back up the window hierarchy
// don't cause an infinite loop
static bool inOnScroll = false;
if (inOnScroll)
{
event.Skip();
return;
}
inOnScroll = true;
int orient = event.GetOrientation();
int nScrollInc = CalcScrollInc(event);
if (nScrollInc == 0)
{
inOnScroll = false;
return;
}
if (orient == wxHORIZONTAL)
{
inOnScroll = false;
event.Skip();
return;
#if 0
int newPos = m_xScrollPosition + nScrollInc;
SetScrollPos(wxHORIZONTAL, newPos, true );
#endif
}
else
{
int newPos = m_yScrollPosition + nScrollInc;
SetScrollPos(wxVERTICAL, newPos, true );
}
if (orient == wxHORIZONTAL)
{
m_xScrollPosition += nScrollInc;
}
else
{
m_yScrollPosition += nScrollInc;
}
// Find targets in splitter window and send the event to them
wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
while (node)
{
wxWindow* child = (wxWindow*) node->GetData();
if (child->IsKindOf(CLASSINFO(wxSplitterWindow)))
{
wxSplitterWindow* splitter = (wxSplitterWindow*) child;
if (splitter->GetWindow1())
splitter->GetWindow1()->ProcessEvent(event);
if (splitter->GetWindow2())
splitter->GetWindow2()->ProcessEvent(event);
break;
}
node = node->GetNext();
}
m_targetWindow->Update() ;
inOnScroll = false;
}

148
wxPython/contrib/gizmos/wxCode/src/gizmos/statpict.cpp Normal file
View File

@@ -0,0 +1,148 @@
/////////////////////////////////////////////////////////////////////////////
// Name: statpict.cpp
// Purpose: wxStaticPicture
// Author: Wade Brainerd (wadeb@wadeb.com)
// Modified by:
// Created: 2003-05-01
// RCS-ID:
// Copyright: (c) Wade Brainerd
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#include "wx/wxprec.h"
#include "wx/defs.h"
#include "wx/gizmos/statpict.h"
#include "wx/dcclient.h"
IMPLEMENT_DYNAMIC_CLASS(wxStaticPicture, wxControl)
WXDLLIMPEXP_GIZMOS const wxChar * wxStaticPictureNameStr = wxT("staticPicture");
/*
* wxStaticPicture
*/
BEGIN_EVENT_TABLE(wxStaticPicture, wxControl)
EVT_PAINT(wxStaticPicture::OnPaint)
END_EVENT_TABLE()
bool wxStaticPicture::Create(wxWindow *parent, wxWindowID id,
const wxBitmap& bitmap,
const wxPoint& pos,
const wxSize& s,
long style,
const wxString& name)
{
SetName(name);
wxSize size = s ;
if ( bitmap.Ok() )
{
if ( size.x == wxDefaultCoord )
size.x = bitmap.GetWidth() ;
if ( size.y == wxDefaultCoord )
size.y = bitmap.GetHeight() ;
}
m_backgroundColour = parent->GetBackgroundColour() ;
m_foregroundColour = parent->GetForegroundColour() ;
Bitmap = bitmap;
Align = 0;
Scale = 0;
ScaleX = ScaleY = 1;
#ifndef __WXMSW__
LastScaleX = LastScaleY = -1;
if ( Bitmap.Ok() )
OriginalImage = Bitmap.ConvertToImage();
#endif
if ( id == wxID_ANY )
m_windowId = (int)NewControlId();
else
m_windowId = id;
m_windowStyle = style;
bool ret = wxControl::Create( parent, id, pos, size, style, wxDefaultValidator, name );
SetInitialSize( size ) ;
return ret;
}
void wxStaticPicture::SetBitmap( const wxBitmap& bmp )
{
Bitmap = bmp;
#ifndef __WXMSW__
if ( Bitmap.Ok() )
OriginalImage = Bitmap.ConvertToImage();
LastScaleX = LastScaleY = -1;
#endif
}
void wxStaticPicture::OnPaint(wxPaintEvent& WXUNUSED(event))
{
if ( !Bitmap.Ok() )
return;
wxPaintDC dc( this );
PrepareDC( dc );
wxSize sz = GetSize();
wxSize bmpsz( Bitmap.GetWidth(), Bitmap.GetHeight() );
float sx = 1.0f, sy = 1.0f;
if ( Scale & wxSCALE_UNIFORM )
{
float _sx = (float)sz.GetWidth() / (float)bmpsz.GetWidth();
float _sy = (float)sz.GetHeight() / (float)bmpsz.GetHeight();
sx = sy = _sx < _sy ? _sx : _sy;
}
else
if ( Scale & wxSCALE_CUSTOM )
{
sx = ScaleX;
sy = ScaleY;
}
else
{
if ( Scale & wxSCALE_HORIZONTAL )
sx = (float)sz.x/(float)bmpsz.x;
if ( Scale & wxSCALE_VERTICAL )
sy = (float)sz.y/(float)bmpsz.y;
}
bmpsz = wxSize( (int)(bmpsz.x*sx), (int)(bmpsz.y*sy) );
wxPoint pos( 0, 0 );
if ( Align & wxALIGN_CENTER_HORIZONTAL ) pos.x = (sz.x-bmpsz.x)/2;
else if ( Align & wxALIGN_RIGHT ) pos.x = sz.x-bmpsz.x;
if ( Align & wxALIGN_CENTER_VERTICAL ) pos.y = (sz.y-bmpsz.y)/2;
else if ( Align & wxALIGN_BOTTOM ) pos.y = sz.y-bmpsz.y;
if ( Scale )
{
#ifdef __WXMSW__
double ux, uy;
dc.GetUserScale( &ux, &uy );
dc.SetUserScale( ux*sx, uy*sy );
dc.DrawBitmap( Bitmap, (int)((float)pos.x/sx), (int)((float)pos.y/sy) );
dc.SetUserScale( ux, uy );
#else
if ( LastScaleX != sx || LastScaleY != sy )
{
LastScaleX = sx;
LastScaleY = sy;
ScaledBitmap = wxBitmap( OriginalImage.Scale( bmpsz.x, bmpsz.y ) );
}
dc.DrawBitmap( ScaledBitmap, pos.x, pos.y );
#endif
}
else
dc.DrawBitmap( Bitmap, pos.x, pos.y );
}

34
wxPython/contrib/gizmos/wxCode/src/gizmos/statpict.txt Normal file
View File

@@ -0,0 +1,34 @@
wxStaticPicture class
by Wade Brainerd (wadeb@wadeb.com)
Description:
This class is an improved version of wxStaticBitmap.
Rather than using a native bitmap control, it uses DC operations to draw the
control. This makes its appearance more consistent across platforms, and
allows for additional features.
Features include:
wxStaticBitmap compatible API - drop-in replacement. Image alignment - top,
left, bottom, right, center vertical and/or horizontal.
Image scaling - scale horizontally and/or vertically, justified scaling
(maintains image aspect ratio).
Platforms tested:
wxMSW
wxGTK
wxMac
Implementation notes:
Under MSW wxWindows uses the operating system to do an optimized (potentially
hardware accelerated) blit in wxDC::DrawBitmap. This is usually fast enough to
do image scaling without affecting the program's interactivity.
On wxMac and wxGTK however, wxDC::DrawBitmap implicitly calls wxImage::Scale
which is a much slower operation. Therefore, on these platforms wxStaticPicture
caches the scaled image to make updates that don't change the image (overlapping
windows, etc.) faster.

52
wxPython/contrib/gizmos/wxCode/src/gizmos/xh_statpict.cpp Normal file
View File

@@ -0,0 +1,52 @@
/////////////////////////////////////////////////////////////////////////////
// Name: xh_statpict.cpp
// Purpose: XRC resource handler for wxStaticPicture
// Author: David A. Norris
// Created: 2005/03/13
// RCS-ID: $Id$
// Copyright: David A. Norris
// Licence: wxWindows Licence
/////////////////////////////////////////////////////////////////////////////
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#if wxUSE_XRC
#include "wx/gizmos/statpict.h"
#include "wx/gizmos/xh_statpict.h"
// Register with wxWindows' dynamic class subsystem.
IMPLEMENT_DYNAMIC_CLASS(wxStaticPictureXmlHandler, wxXmlResourceHandler)
// Constructor.
wxStaticPictureXmlHandler::wxStaticPictureXmlHandler()
{
AddWindowStyles();
}
// Creates the control and returns a pointer to it.
wxObject *wxStaticPictureXmlHandler::DoCreateResource()
{
XRC_MAKE_INSTANCE(control, wxStaticPicture)
control->Create(m_parentAsWindow, GetID(),
GetBitmap(wxT("bitmap"), wxART_OTHER, GetSize()),
GetPosition(), GetSize(), GetStyle(), GetName());
SetupWindow(control);
return control;
}
// Returns true if we know how to create a control for the given node.
bool wxStaticPictureXmlHandler::CanHandle(wxXmlNode *node)
{
return IsOfClass(node, wxT("wxStaticPicture"));
}
#endif // wxUSE_XRC