diff --git a/.appveyor.yml b/.appveyor.yml new file mode 100644 index 0000000..9fcc639 --- /dev/null +++ b/.appveyor.yml @@ -0,0 +1,44 @@ +environment: + matrix: + - PYTHON: "C:\\PYTHON38-x64" +build: off +install: + - set PATH=C:\msys64\usr\bin;%PATH% + # Load PGP Keys for Msys64 + - bash -lc "curl -O http://repo.msys2.org/msys/x86_64/msys2-keyring-r21.b39fb11-1-any.pkg.tar.xz" + - bash -lc "curl -O http://repo.msys2.org/msys/x86_64/msys2-keyring-r21.b39fb11-1-any.pkg.tar.xz.sig" + - bash -lc "pacman-key --verify msys2-keyring-r21.b39fb11-1-any.pkg.tar.xz.sig" + - bash -lc "pacman -U --noconfirm --config <(echo) msys2-keyring-r21.b39fb11-1-any.pkg.tar.xz" + # Kill gpg-agent due to bug in MSYS + - TaskKill /IM gpg-agent.exe /F + # Update known packages + - bash -lc "pacman --needed --noconfirm -Syu" + - bash -lc "pacman --needed --noconfirm -Sy" + # Install Python build dependencies + - "%PYTHON%\\python.exe -m pip install scikit-build nose" + # Now using MinGW pkg-config and related executables + - set PATH=C:\msys64\mingw64\bin;%PATH% + # Download Dependencies (dependency walker) + - appveyor DownloadFile https://github.com/lucasg/Dependencies/releases/download/v1.10/Dependencies_x64_Release.zip + - 7z e Dependencies_x64_Release.zip -odeps -y + # Add %PYTHON% to the path for libffi-7.dll + - set PATH=%PYTHON%;C:\msys64\mingw64\lib;%PATH% +build_script: + - "%PYTHON%\\python.exe -u setup.py build bdist_wheel" + # Simplify PATH so as to test binary distribution + - set PATH=C:\WINDOWS\system32;C:\WINDOWS +test_script: + - "%PYTHON%\\python.exe -m nose" +artifacts: + - path: "/dist/*.whl" +deploy: + provider: GitHub + auth_token: + secure: QimY++/91urL/oMJL/q2zYFqc1C7747HguEaIbPQovtC3zG8CK+TiCmFOCXy1D6e + artifact: "dist/*.whl" + draft: false + prerelease: false + force_update: true + on: + branch: master + appveyor_repo_tag: true diff --git a/.gitignore b/.gitignore index 796b96d..a2804c8 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1,108 @@ +# Prerequisites +*.d + +# Object files +*.o +*.ko +*.obj +*.elf + +# Linker output +*.ilk +*.map +*.exp + +# Precompiled Headers +*.gch +*.pch + +# Libraries +*.lib +*.a +*.la +*.lo + +# Shared objects (inc. Windows DLLs) +*.dll +*.so +*.so.* +*.dylib + +# Executables +*.exe +*.out +*.app +*.i*86 +*.x86_64 +*.hex + +# Debug files +*.dSYM/ +*.su +*.idb +*.pdb + +# Kernel Module Compile Results +*.mod* +*.cmd +.tmp_versions/ +modules.order +Module.symvers +Mkfile.old +dkms.conf + +# CLion +/.idea + +# CMake +/CMakeFiles +/cmake-build* + +# Code::Blocks +*.layout +*.cbp +*.depend + +# Project Files +Makefile +main-* +layout.* +!layout.rst +/_skbuild + +# CMake +CMakeCache.txt +/CMakeTmp +*CMakeTmp* +*CMakeFiles* +*CMakeCache.txt +*cmake_install.cmake +install_manifest.txt +CTestTestfile.cmake + +# Generated files +/library/pkgIndex.tcl + +# Python packages +/*.egg-info /build +/dist +*.pyc +MANIFEST +/venv + +# Documentation +/docs/_build +/docs/html +/docs/_doctrees +/docs/doxygen/xml +/html +/latex + +# GTK Themes and configuration +/gttk/* +!/gttk/__init__.py +!/gttk/gttk.tcl + +# Dependencies Program +/deps diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 0000000..5decdaa --- /dev/null +++ b/.travis.yml @@ -0,0 +1,32 @@ +language: python +dist: bionic +compiler: gcc +python: + - "3.8" +services: + - xvfb +addons: + apt: + packages: + - libgtk2.0-dev + - libglib2.0-dev + - tcl-dev + - tk-dev +install: + - sudo apt install cmake build-essential + - python -m pip install nose scikit-build +script: + - python setup.py bdist_wheel + - python setup.py install + - rm -rf ./gttk + - python -m nose +deploy: + provider: releases + api_key: + secure: jIWRWxe9KbnrHCYPv0LbGda57N/NeN2ns0C+ZWTzYQYeD11rSv4UKjq0RdzsXicA4XV1sN5bFG0bSdM9ap7NPblFmuFo2VF5hTyS3tv8E3oVHOexIfwb6HSoBHfd8ijhmLxJQ8f057WZE12xBeW4YYwhjCPf3wXEinkg3U1moKZz0FCuLdlALIOMg/qlMzX17w4jIgoU/aHRx0d/eLZBcTr4WNMgE91KK/BMyHrajG+oy8bM4M/Tf0ILynJLiUHMbONGHo43apnr+s4OllEsxZjh4Min25x9CUQzPSm4wFWGM2Ypa+3R+MnqmfYKhDQNW7Cj+4GArDdbaG2oK4BTJZ9wn6YcKVC7saU4vDHdpHrz/DdC0XAuvOobT+hUJcIOmJ5uoJp6H61719SvQmbLtaHvzEVEb66qPvXHGgJkEXhOtkfWQAX4p/2ipL9UMy8cP4lXNG0/ESkBsJj1JbIoh+w+jP8wGzBVuSYsV2ESefTvxRqg5lZqFUmvg+FIjbT2fQEl5G9CTx1nVQ6E91cOaVOZQuNMZ7/XHg90u5O8NsXwtJtYIvSlDgyAggSss7nvrpNq2ej9e2ZC+i7ESik/V6NxzG9CWV7aMXwV8+OUovInNZt2w1ZNpcijRGOzlEduB6MDeRKdq4r1+Zcljf6pwdH40gH4yR01dvc6s8WmmoI= + file: "dist/*.whl" + file_glob: true + skip_cleanup: true + on: + repo: TkinterEP/python-gttk + tags: true diff --git a/CMakeLists.txt b/CMakeLists.txt index a43cedc..d391906 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,55 +1,53 @@ -CMAKE_MINIMUM_REQUIRED ( VERSION 2.8 ) +CMAKE_MINIMUM_REQUIRED(VERSION 2.8) ## =========================================================================== ## Project Information ## =========================================================================== -PROJECT ( gtkTtk ) +PROJECT ( gttk ) ## Package version information. SET ( PKG_NAME ${PROJECT_NAME} ) SET ( PKG_MAJOR_VERSION 0 ) -SET ( PKG_MINOR_VERSION 5 ) -SET ( PKG_BUILD_VERSION 0 ) -SET ( PKG_VERSION - "${PKG_MAJOR_VERSION}.${PKG_MINOR_VERSION}" ) +SET ( PKG_MINOR_VERSION 6 ) +SET ( PKG_BUILD_VERSION 1 ) +SET ( PKG_VERSION "${PKG_MAJOR_VERSION}.${PKG_MINOR_VERSION}" ) SET ( PKG_NAME_VERSION ${PKG_NAME}-${PKG_VERSION} ) -SET ( PKG_VENDOR "Géballin" ) +SET ( PKG_VENDOR "RedFantom" ) SET ( PKG_HOME_DIR ${PROJECT_SOURCE_DIR} ) -SET ( LOAD_GTK_DYNAMICALLY ON ) +SET ( LOAD_GTK_DYNAMICALLY OFF ) SET ( NO_MSVCRT ON ) SET ( USE_GNOME OFF ) SET ( VERBOSE ON ) +SET ( ENABLE_EXPORTS ON ) IF ( VERBOSE ) # SET ( CMAKE_VERBOSE_MAKEFILE ON ) SET ( GTK2_LOGGING_ENABLED ON ) ENDIF ( VERBOSE ) -SET ( PKG_SOURCES - generic/gtkTtk_TreeView.cpp - generic/gtkTtk_Separator.cpp - generic/gtkTtk_Arrows.cpp ) - -SET ( PKG_SOURCES generic/gtkTtk_Init.cpp - generic/gtkTtk_Symbols.cpp - generic/gtkTtk_GtkApp.cpp - generic/gtkTtk_Utilities.cpp - generic/gtkTtk_Background.cpp - generic/gtkTtk_Button.cpp - generic/gtkTtk_CheckButton.cpp - generic/gtkTtk_RadioButton.cpp - generic/gtkTtk_ToolButton.cpp - generic/gtkTtk_Labelframe.cpp - generic/gtkTtk_Entry.cpp - generic/gtkTtk_Menubutton.cpp - generic/gtkTtk_Scrollbar.cpp - generic/gtkTtk_Scale.cpp - generic/gtkTtk_Progress.cpp - generic/gtkTtk_SizeGrip.cpp - generic/gtkTtk_Paned.cpp - generic/gtkTtk_Notebook.cpp - generic/gtkTtk_Combobox.cpp -) +SET ( PKG_SOURCES generic/gttk_TreeView.cpp + generic/gttk_Separator.cpp + generic/gttk_Arrows.cpp ) + +SET ( PKG_SOURCES generic/gttk_Init.cpp + generic/gttk_Symbols.cpp + generic/gttk_GtkApp.cpp + generic/gttk_Utilities.cpp + generic/gttk_Background.cpp + generic/gttk_Button.cpp + generic/gttk_CheckButton.cpp + generic/gttk_RadioButton.cpp + generic/gttk_ToolButton.cpp + generic/gttk_Labelframe.cpp + generic/gttk_Entry.cpp + generic/gttk_Menubutton.cpp + generic/gttk_Scrollbar.cpp + generic/gttk_Scale.cpp + generic/gttk_Progress.cpp + generic/gttk_SizeGrip.cpp + generic/gttk_Paned.cpp + generic/gttk_Notebook.cpp + generic/gttk_Combobox.cpp ) MESSAGE ( STATUS "===========================================================" ) MESSAGE ( STATUS " Welcome to the ${PKG_NAME} ${PKG_VERSION} build system!" ) @@ -62,18 +60,18 @@ MESSAGE ( STATUS "===========================================================" ) ## =========================================================================== ## Locate Tcl/Tk ## =========================================================================== -MESSAGE ( STATUS "Searching for Tcl/Tk..." ) -FIND_PACKAGE ( TCL REQUIRED ) -FIND_PACKAGE ( TclStub REQUIRED ) -MESSAGE ( STATUS " TCL_TCLSH: " ${TCL_TCLSH} ) -MESSAGE ( STATUS " TCL_INCLUDE_PATH: " ${TCL_INCLUDE_PATH} ) -MESSAGE ( STATUS " TCL_STUB_LIBRARY: " ${TCL_STUB_LIBRARY} ) -MESSAGE ( STATUS " TCL_LIBRARY: " ${TCL_LIBRARY} ) -MESSAGE ( STATUS " TK_WISH: " ${TK_WISH} ) -MESSAGE ( STATUS " TK_INCLUDE_PATH: " ${TK_INCLUDE_PATH} ) -MESSAGE ( STATUS " TK_STUB_LIBRARY: " ${TK_STUB_LIBRARY} ) -MESSAGE ( STATUS " TTK_STUB_LIBRARY: " ${TTK_STUB_LIBRARY} ) -MESSAGE ( STATUS " TK_LIBRARY: " ${TK_LIBRARY} ) +MESSAGE(STATUS "Searching for Tcl/Tk...") +FIND_PACKAGE(TCL REQUIRED) +FIND_PACKAGE(TclStub REQUIRED) +MESSAGE(STATUS " TCL_TCLSH: " ${TCL_TCLSH}) +MESSAGE(STATUS " TCL_INCLUDE_PATH: " ${TCL_INCLUDE_PATH}) +MESSAGE(STATUS " TCL_STUB_LIBRARY: " ${TCL_STUB_LIBRARY}) +MESSAGE(STATUS " TCL_LIBRARY: " ${TCL_LIBRARY}) +MESSAGE(STATUS " TK_WISH: " ${TK_WISH}) +MESSAGE(STATUS " TK_INCLUDE_PATH: " ${TK_INCLUDE_PATH}) +MESSAGE(STATUS " TK_STUB_LIBRARY: " ${TK_STUB_LIBRARY}) +MESSAGE(STATUS " TTK_STUB_LIBRARY: " ${TTK_STUB_LIBRARY}) +MESSAGE(STATUS " TK_LIBRARY: " ${TK_LIBRARY}) # STRING ( REPLACE stub "" TCL_LIBRARY_STATIC ${TCL_STUB_LIBRARY} ) # STRING ( REPLACE stub "" TK_LIBRARY_STATIC ${TK_STUB_LIBRARY} ) # MESSAGE ( STATUS " TCL_LIBRARY_STATIC: " ${TCL_LIBRARY_STATIC} ) @@ -84,14 +82,14 @@ IF ( WIN32 AND NO_MSVCRT ) STRING ( REPLACE /MDd /MTd CMAKE_C_FLAGS_DEBUG ${CMAKE_C_FLAGS_DEBUG} ) STRING ( REPLACE /MD /MT CMAKE_CXX_FLAGS_RELEASE ${CMAKE_CXX_FLAGS_RELEASE}) STRING ( REPLACE /MDd /MTd CMAKE_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_DEBUG} ) - SET ( CMAKE_EXE_LINKER_FLAGS - "${CMAKE_EXE_LINKER_FLAGS} /nodefaultlib:MSVCRT.LIB" ) + # SET ( CMAKE_EXE_LINKER_FLAGS + # "${CMAKE_EXE_LINKER_FLAGS} /nodefaultlib:MSVCRT.LIB" ) SET ( CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} LIBCMT.LIB" ) SET ( CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} LIBCMTD.LIB" ) - SET ( CMAKE_SHARED_LINKER_FLAGS - "${CMAKE_SHARED_LINKER_FLAGS} /nodefaultlib:MSVCRT.LIB" ) + # SET ( CMAKE_SHARED_LINKER_FLAGS + # "${CMAKE_SHARED_LINKER_FLAGS} /nodefaultlib:MSVCRT.LIB" ) SET ( CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} LIBCMT.LIB" ) SET ( CMAKE_SHARED_LINKER_FLAGS_DEBUG @@ -112,13 +110,13 @@ ENDIF ( WIN32 ) IF ( LOAD_GTK_DYNAMICALLY ) MESSAGE ( STATUS "GTK+ will be loaded dynamically!" ) - ADD_DEFINITIONS ( -DGTKTTK_LOAD_GTK_DYNAMICALLY ) + ADD_DEFINITIONS ( -DGTTK_LOAD_GTK_DYNAMICALLY ) ENDIF ( LOAD_GTK_DYNAMICALLY ) IF ( CMAKE_BUILD_TYPE STREQUAL Debug ) - ADD_DEFINITIONS ( -DGTKTTK_SYNCHRONIZE ) - ADD_DEFINITIONS ( -DGTKTTK_VERBOSE_XERROR_HANDLER ) + ADD_DEFINITIONS ( -DGTTK_SYNCHRONIZE ) + ADD_DEFINITIONS ( -DGTTK_VERBOSE_XERROR_HANDLER ) ENDIF ( CMAKE_BUILD_TYPE STREQUAL Debug ) -ADD_DEFINITIONS ( -DGTKTTK_INSTALL_XERROR_HANDLER ) +ADD_DEFINITIONS ( -DGTTK_INSTALL_XERROR_HANDLER ) ADD_DEFINITIONS ( -DUSE_TCL_STUBS ) ADD_DEFINITIONS ( -DUSE_TK_STUBS ) ADD_DEFINITIONS ( -DUSE_TTK_STUBS ) @@ -127,8 +125,21 @@ ADD_DEFINITIONS ( -DPACKAGE_VERSION="${PKG_VERSION}" ) INCLUDE_DIRECTORIES ( ${TCL_INCLUDE_PATH} ) INCLUDE_DIRECTORIES ( ${TK_INCLUDE_PATH} ) INCLUDE_DIRECTORIES ( ${TK_INCLUDE_PATH}/tk-private/generic/ttk ) +IF ( WIN32 ) # Include additional directories for MSYS build + INCLUDE_DIRECTORIES ( ${TK_INCLUDE_PATH}/tk8.6/tk-private/generic ) + INCLUDE_DIRECTORIES ( ${TK_INCLUDE_PATH}/tk8.6/tk-private/generic/ttk ) + INCLUDE_DIRECTORIES ( ${TK_INCLUDE_PATH}/tk8.6/tk-private/win ) +ENDIF ( WIN32 ) INCLUDE_DIRECTORIES ( ${PROJECT_SOURCE_DIR}/generic ) +## =========================================================================== +## Locate X11... +## =========================================================================== +find_package ( X11 REQUIRED ) +if ( X11_FOUND ) + MESSAGE ( STATUS "X11 Found: ${X11_LIBRARIES}" ) +endif () + ## =========================================================================== ## Locate GNOME2... ## =========================================================================== @@ -137,7 +148,7 @@ IF ( USE_GNOME ) INCLUDE ( cmake/Modules/FindGNOME2.cmake OPTIONAL ) IF ( GNOME_FOUND ) MESSAGE ( STATUS " GNOME Found!" ) - ADD_DEFINITIONS ( -DGTKTTK_ENABLE_GNOME ) + ADD_DEFINITIONS ( -DGTTK_ENABLE_GNOME ) INCLUDE_DIRECTORIES ( ${GNOME_INCLUDE_DIR} ) LINK_LIBRARIES ( ${GNOME_LIBRARIES} ) ENDIF ( GNOME_FOUND ) @@ -154,36 +165,37 @@ ENDIF ( USE_GNOME ) ## =========================================================================== ## Locate GTK... ## =========================================================================== -MESSAGE ( STATUS "Searching for GTK2..." ) +MESSAGE(STATUS "Searching for GTK2...") find_package(PkgConfig REQUIRED) pkg_check_modules(GTK "gtk+-2.0") if (GTK_FOUND) - LINK_LIBRARIES( ${GTK_LIBRARIES}) - add_definitions(${GTK_CFLAGS} ${GTK_CFLAGS_OTHER}) + LINK_LIBRARIES(${GTK_LIBRARIES}) + add_definitions(${GTK_CFLAGS} ${GTK_CFLAGS_OTHER}) -MESSAGE ( STATUS " GTK 2.x Found!" ) -endif() + MESSAGE(STATUS " GTK 2.x Found!") +endif () ## =========================================================================== -## Target: gtkTtk_Symbols.[h|cpp] +## Target: gttk_Symbols.[h|cpp] ## =========================================================================== -ADD_CUSTOM_COMMAND ( OUTPUT ${PROJECT_SOURCE_DIR}/generic/gtkTtk_Symbols.cpp - ${PROJECT_SOURCE_DIR}/generic/gtkTtk_Symbols.h - DEPENDS library/GenarateSymbols.tcl - generic/gtkTtk_Init.cpp - generic/gtkTtk_GtkApp.cpp - generic/gtkTtk_Utilities.h - generic/gtkTtk_Utilities.cpp - COMMAND ${TCL_TCLSH} GenarateSymbols.tcl - WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}/library ) -SET_SOURCE_FILES_PROPERTIES ( ${PROJECT_SOURCE_DIR}/generic/gtkTtk_Symbols.cpp - PROPERTIES GENERATED true ) -SET_SOURCE_FILES_PROPERTIES ( ${PROJECT_SOURCE_DIR}/generic/gtkTtk_Symbols.h - PROPERTIES GENERATED true ) - -SET ( PKG_TARGET_LIB_NAME ${PKG_NAME}${PKG_VERSION} ) +# ADD_CUSTOM_COMMAND ( OUTPUT ${PROJECT_SOURCE_DIR}/generic/gttk_Symbols.cpp +# ${PROJECT_SOURCE_DIR}/generic/gttk_Symbols.h +# DEPENDS library/GenerateSymbols.tcl +# generic/gttk_Init.cpp +# generic/gttk_GtkApp.cpp +# generic/gttk_Utilities.h +# generic/gttk_Utilities.cpp +# COMMAND ${TCL_TCLSH} GenerateSymbols.tcl +# WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}/library ) +# SET_SOURCE_FILES_PROPERTIES ( ${PROJECT_SOURCE_DIR}/generic/gttk_Symbols.cpp +# PROPERTIES GENERATED true ) +# SET_SOURCE_FILES_PROPERTIES ( ${PROJECT_SOURCE_DIR}/generic/gttk_Symbols.h +# PROPERTIES GENERATED true ) + +SET ( PKG_TARGET_LIB_NAME ${PKG_NAME} ) + ## =========================================================================== -## Target: gtkTtk shared library +## Target: gttk shared library ## =========================================================================== MESSAGE ( STATUS "===========================================================" ) MESSAGE ( STATUS " ++++ Shared Library: ${PKG_TARGET_LIB_NAME} ++++" ) @@ -191,6 +203,7 @@ MESSAGE ( STATUS "===========================================================" ) ADD_LIBRARY ( ${PKG_TARGET_LIB_NAME} SHARED ${PKG_SOURCES} ) TARGET_LINK_LIBRARIES ( ${PKG_TARGET_LIB_NAME} ${TCL_STUB_LIBRARY} ) TARGET_LINK_LIBRARIES ( ${PKG_TARGET_LIB_NAME} ${TK_STUB_LIBRARY} ) +TARGET_LINK_LIBRARIES ( ${PKG_TARGET_LIB_NAME} ${X11_LIBRARIES} ) IF ( TTK_STUB_LIBRARY ) TARGET_LINK_LIBRARIES ( ${PKG_TARGET_LIB_NAME} ${TTK_STUB_LIBRARY} ) ENDIF ( TTK_STUB_LIBRARY ) @@ -222,17 +235,13 @@ ELSE ( LOAD_GTK_DYNAMICALLY ) ENDIF ( UNIX ) ENDIF ( LOAD_GTK_DYNAMICALLY ) -FILE ( WRITE library/pkgIndex.tcl -"package ifneeded ttk::theme::gtkTtk ${PKG_VERSION} \\ - [list load [file join $dir lib${PKG_NAME}${PKG_VERSION}[info sharedlibextension]] gtkTtk]" ) +FILE ( WRITE gttk/pkgIndex.tcl +"package ifneeded ttk::theme::gttk ${PKG_VERSION} \\ + [list load [file join $dir lib${PKG_NAME}[info sharedlibextension]] gttk]" ) INSTALL ( TARGETS ${PKG_TARGET_LIB_NAME} RUNTIME DESTINATION ${PKG_TARGET_LIB_NAME} LIBRARY DESTINATION ${PKG_TARGET_LIB_NAME} ARCHIVE DESTINATION ${PKG_TARGET_LIB_NAME} ) -INSTALL ( FILES library/pkgIndex.tcl library/gtkTtk.tcl +INSTALL ( FILES gttk/pkgIndex.tcl gttk/gttk.tcl DESTINATION ${PKG_TARGET_LIB_NAME} ) - -ENABLE_TESTING ( ) -ADD_TEST ( demo ${TK_WISH} ${PROJECT_SOURCE_DIR}/demos/demo.tcl ) -ADD_TEST ( styles ${TK_WISH} ${PROJECT_SOURCE_DIR}/demos/WidgetStates.tcl ) diff --git a/ChangeLog b/ChangeLog deleted file mode 100644 index b30a32e..0000000 --- a/ChangeLog +++ /dev/null @@ -1,73 +0,0 @@ -22 Jul 2012 Georgios Petasis - * library/tilegtk.tcl: Added support for Linux 64. - - * generic/tileGtk_Init.cpp: - * library/GenarateSymbols.tcl: Switched dynamic library loading from GLib, - to Tcl (Tcl_LoadFile, Tcl_FindSymbol). - - * CMakeLists.txt: CMake (2.8.8) can now find GTK2, reverted our module to - the official one. - -30 Sep 2010 Georgios Petasis - * demos/WidgetStates.tcl: - * demos/demo.tcl: - * demos/dirbrowser.tcl: - * demos/dlgtest.tcl: Minor updates for supporting Tk 8.6. - -08 Aug 2009 Georgios Petasis - * generic/tileGtk_ToolButton.cpp: Fixes in tool button drawing code. - -01 Jul 2009 Georgios Petasis - * generic/tileGtk_Combobox.cpp: - * generic/tileGtk_Menubutton.cpp: - * generic/tileGtk_Scrollbar.cpp: Applied the scaling required by GTK+ - arrows. - -20 Aug 2008 Georgios Petasis - * generic/tileGtk_Button.cpp: - * generic/tileGtk_CheckButton.cpp: - * generic/tileGtk_RadioButton.cpp: Reworked button drawing to be identical - to the drawing done by GTK+. - -13 Aug 2008 Georgios Petasis - * generic/tileGtk_Utilities.h: - * generic/tileGtk_Utilities.cpp: - * generic/*.cpp: Added the ability to adapt to style changes! - - * generic/tileGtk_GtkApp.cpp: Added support for installing an XError - handler, overidiing the one installed by GTK+. - -11 Aug 2008 Georgios Petasis - * demos/StyleInstrospection.tcl: Updated. - - * cmake/Modules/FindGTK2.cmake: Make the module more easy to adapt to - new GTK+ paths. - - * library/GenerateSymbols.tcl: - * library/tilegtk.tcl: - * generic/tileGtk_Init.cpp: Completed the ability to dynamically - load GTK+ libraries under windows. - -07 Aug 2008 Georgios Petasis - * library/GenerateSymbols.tcl: - * library/tilegtk.tcl: - * generic/tileGtk_Init.cpp: Completed the ability to dynamically - load GTK+ libraries under linux. - -07 Aug 2008 Georgios Petasis - * library/GenarateSymbols.tcl: Added a new script that generates - generic/tileGtk_Symbols.h, generic/tileGtk_Symbols.h from GTK/Glib/GDK - functions used in code. The generated files map all glib/gdk/gtk - functions to pointers, if symbol TILEGTK_LOAD_GTK_DYNAMICALLY is - defined. In general, to enable this feature, LOAD_GTK_DYNAMICALLY must - be set to ON in CMakeLists.txt. - Note that this support is still incomplete. - -06 Aug 2008 Georgios Petasis - * New widgets: SizeGrip, Paned, ToolButton, Notebook & Combobox. - -05 Aug 2008 Georgios Petasis - * Updates: Scrollbars, Scales & ProgressBar widgets added. - -03 Aug 2008 Georgios Petasis - * Started the tile-gtk theme. diff --git a/LICENSE.md b/LICENSE.md new file mode 100644 index 0000000..51bbbe9 --- /dev/null +++ b/LICENSE.md @@ -0,0 +1,619 @@ +### GNU GENERAL PUBLIC LICENSE + +Version 3, 29 June 2007 + +Copyright (C) 2007 Free Software Foundation, Inc. + + +Everyone is permitted to copy and distribute verbatim copies of this +license document, but changing it is not allowed. + +### Preamble + +The GNU General Public License is a free, copyleft license for +software and other kinds of works. + +The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom +to share and change all versions of a program--to make sure it remains +free software for all its users. We, the Free Software Foundation, use +the GNU General Public License for most of our software; it applies +also to any other work released this way by its authors. You can apply +it to your programs, too. + +When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + +To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you +have certain responsibilities if you distribute copies of the +software, or if you modify it: responsibilities to respect the freedom +of others. + +For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + +Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + +For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + +Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the +manufacturer can do so. This is fundamentally incompatible with the +aim of protecting users' freedom to change the software. The +systematic pattern of such abuse occurs in the area of products for +individuals to use, which is precisely where it is most unacceptable. +Therefore, we have designed this version of the GPL to prohibit the +practice for those products. If such problems arise substantially in +other domains, we stand ready to extend this provision to those +domains in future versions of the GPL, as needed to protect the +freedom of users. + +Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish +to avoid the special danger that patents applied to a free program +could make it effectively proprietary. To prevent this, the GPL +assures that patents cannot be used to render the program non-free. + +The precise terms and conditions for copying, distribution and +modification follow. + +### TERMS AND CONDITIONS + +#### 0. Definitions. + +"This License" refers to version 3 of the GNU General Public License. + +"Copyright" also means copyright-like laws that apply to other kinds +of works, such as semiconductor masks. + +"The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + +To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of +an exact copy. The resulting work is called a "modified version" of +the earlier work or a work "based on" the earlier work. + +A "covered work" means either the unmodified Program or a work based +on the Program. + +To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + +To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user +through a computer network, with no transfer of a copy, is not +conveying. + +An interactive user interface displays "Appropriate Legal Notices" to +the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + +#### 1. Source Code. + +The "source code" for a work means the preferred form of the work for +making modifications to it. "Object code" means any non-source form of +a work. + +A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + +The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + +The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + +The Corresponding Source need not include anything that users can +regenerate automatically from other parts of the Corresponding Source. + +The Corresponding Source for a work in source code form is that same +work. + +#### 2. Basic Permissions. + +All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + +You may make, run and propagate covered works that you do not convey, +without conditions so long as your license otherwise remains in force. +You may convey covered works to others for the sole purpose of having +them make modifications exclusively for you, or provide you with +facilities for running those works, provided that you comply with the +terms of this License in conveying all material for which you do not +control copyright. Those thus making or running the covered works for +you must do so exclusively on your behalf, under your direction and +control, on terms that prohibit them from making any copies of your +copyrighted material outside their relationship with you. + +Conveying under any other circumstances is permitted solely under the +conditions stated below. Sublicensing is not allowed; section 10 makes +it unnecessary. + +#### 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + +No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + +When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such +circumvention is effected by exercising rights under this License with +respect to the covered work, and you disclaim any intention to limit +operation or modification of the work as a means of enforcing, against +the work's users, your or third parties' legal rights to forbid +circumvention of technological measures. + +#### 4. Conveying Verbatim Copies. + +You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + +You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + +#### 5. Conveying Modified Source Versions. + +You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these +conditions: + +- a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. +- b) The work must carry prominent notices stating that it is + released under this License and any conditions added under + section 7. This requirement modifies the requirement in section 4 + to "keep intact all notices". +- c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. +- d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + +A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + +#### 6. Conveying Non-Source Forms. + +You may convey a covered work in object code form under the terms of +sections 4 and 5, provided that you also convey the machine-readable +Corresponding Source under the terms of this License, in one of these +ways: + +- a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. +- b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the Corresponding + Source from a network server at no charge. +- c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. +- d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. +- e) Convey the object code using peer-to-peer transmission, + provided you inform other peers where the object code and + Corresponding Source of the work are being offered to the general + public at no charge under subsection 6d. + +A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + +A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, +family, or household purposes, or (2) anything designed or sold for +incorporation into a dwelling. In determining whether a product is a +consumer product, doubtful cases shall be resolved in favor of +coverage. For a particular product received by a particular user, +"normally used" refers to a typical or common use of that class of +product, regardless of the status of the particular user or of the way +in which the particular user actually uses, or expects or is expected +to use, the product. A product is a consumer product regardless of +whether the product has substantial commercial, industrial or +non-consumer uses, unless such uses represent the only significant +mode of use of the product. + +"Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to +install and execute modified versions of a covered work in that User +Product from a modified version of its Corresponding Source. The +information must suffice to ensure that the continued functioning of +the modified object code is in no case prevented or interfered with +solely because modification has been made. + +If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + +The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or +updates for a work that has been modified or installed by the +recipient, or for the User Product in which it has been modified or +installed. Access to a network may be denied when the modification +itself materially and adversely affects the operation of the network +or violates the rules and protocols for communication across the +network. + +Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + +#### 7. Additional Terms. + +"Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + +When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + +Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders +of that material) supplement the terms of this License with terms: + +- a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or +- b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or +- c) Prohibiting misrepresentation of the origin of that material, + or requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or +- d) Limiting the use for publicity purposes of names of licensors + or authors of the material; or +- e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or +- f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions + of it) with contractual assumptions of liability to the recipient, + for any liability that these contractual assumptions directly + impose on those licensors and authors. + +All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + +If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + +Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; the +above requirements apply either way. + +#### 8. Termination. + +You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + +However, if you cease all violation of this License, then your license +from a particular copyright holder is reinstated (a) provisionally, +unless and until the copyright holder explicitly and finally +terminates your license, and (b) permanently, if the copyright holder +fails to notify you of the violation by some reasonable means prior to +60 days after the cessation. + +Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + +Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + +#### 9. Acceptance Not Required for Having Copies. + +You are not required to accept this License in order to receive or run +a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + +#### 10. Automatic Licensing of Downstream Recipients. + +Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + +An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + +You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + +#### 11. Patents. + +A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + +A contributor's "essential patent claims" are all patent claims owned +or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + +Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + +In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + +If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + +If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + +A patent license is "discriminatory" if it does not include within the +scope of its coverage, prohibits the exercise of, or is conditioned on +the non-exercise of one or more of the rights that are specifically +granted under this License. You may not convey a covered work if you +are a party to an arrangement with a third party that is in the +business of distributing software, under which you make payment to the +third party based on the extent of your activity of conveying the +work, and under which the third party grants, to any of the parties +who would receive the covered work from you, a discriminatory patent +license (a) in connection with copies of the covered work conveyed by +you (or copies made from those copies), or (b) primarily for and in +connection with specific products or compilations that contain the +covered work, unless you entered into that arrangement, or that patent +license was granted, prior to 28 March 2007. + +Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + +#### 12. No Surrender of Others' Freedom. + +If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under +this License and any other pertinent obligations, then as a +consequence you may not convey it at all. For example, if you agree to +terms that obligate you to collect a royalty for further conveying +from those to whom you convey the Program, the only way you could +satisfy both those terms and this License would be to refrain entirely +from conveying the Program. + +#### 13. Use with the GNU Affero General Public License. + +Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + +#### 14. Revised Versions of this License. + +The Free Software Foundation may publish revised and/or new versions +of the GNU General Public License from time to time. Such new versions +will be similar in spirit to the present version, but may differ in +detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies that a certain numbered version of the GNU General Public +License "or any later version" applies to it, you have the option of +following the terms and conditions either of that numbered version or +of any later version published by the Free Software Foundation. If the +Program does not specify a version number of the GNU General Public +License, you may choose any version ever published by the Free +Software Foundation. + +If the Program specifies that a proxy can decide which future versions +of the GNU General Public License can be used, that proxy's public +statement of acceptance of a version permanently authorizes you to +choose that version for the Program. + +Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + +#### 15. Disclaimer of Warranty. + +THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT +WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND +PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE +DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR +CORRECTION. + +#### 16. Limitation of Liability. + +IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR +CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES +ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT +NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR +LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM +TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER +PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + +#### 17. Interpretation of Sections 15 and 16. + +If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + +END OF TERMS AND CONDITIONS diff --git a/README.md b/README.md index d393006..1521f30 100644 --- a/README.md +++ b/README.md @@ -1,29 +1,188 @@ -gtkTtk -======== +# GTK Theme for Python's tkinter/ttk +![Build Status](https://api.travis-ci.com/TkinterEP/python-gttk.svg?branch=master) +[![Build status](https://ci.appveyor.com/api/projects/status/80y25364onq2anmw/branch/master?svg=true)](https://ci.appveyor.com/project/RedFantom/python-gttk/branch/master) +[![PyPI version](https://badge.fury.io/py/gttk.svg)](https://pypi.python.org/pypi/gttk) -gtkTtk is a [ttk](http://wiki.tcl.tk/14796) theme that gives to your [Tk](http://wiki.tcl.tk/477) applications a native [GTK+](http://www.gtk.org/) look and feel. -So applications made using TCL/Tk, Perl/TK or Python/Tkinter can now look as good as if they were written in C/GTK+ and integrate perfectly in Gnome or XFCE desktops. -**gitk, git gui and other popular TK applications will no more looks like comming from the 90's !** +Would you like to have a more native look for your Tkinter application? +Are the themes provided in [ttkthemes](https://github.com/TkinterEP/ttkthemes) +not to your liking? -gtkTtk is a fork of tile-gtk. -Since [according to the author][1] tilegtk as well as tileqt is -undermaintained, I created this fork to integrate my improvements and bugfixes and finishing the work to have a complete GTK+ look on ttk applications. - -![screenshot](gtkTtk.gif "screenshot of git gui and gitk used with gtkTtk") +This package provides a version of [`gtkTtk`](https://github.com/Geballin/gtkTtk), +formerly [`tilegtk`](https://github.com/xiaq/tile-gtk) packaged for +usage with Python. Simply follow the installation instructions and all +required files are installed to the site package directory. ## Installation +Currently, a build process for Linux and Windows is available. If you +would like to use the package on OS X, please let me know so we can +work on a build system. + +### Wheels +Currently, wheels are provided for Windows. The Linux wheels are built +with Travis-CI and are thus not `manylinux` wheels. Therefore, building +yourself is recommended when using Linux (either from the source dist +from PyPI or this repository). Feel free to open an issue if you +encounter any problems building! + +### Linux +These instructions are for Ubuntu, Python 3.5 or higher. Any lower +version may work, but is not supported. On other distributions, package +names may be different. +```bash +# Build Tools +sudo apt install build-essential cmake +# Required Libraries +sudo apt install libgtk2.0-dev libglib2.0-dev tcl-dev tk-dev +# Required Python packages +python -m pip install scikit-build + +python setup.py install +``` + +### Windows (64-bit only) +These instructions assume you have [MSYS2](https://www.msys2.org/) +installed, with the MinGW toolchain. The `setup.py` script will check +the additional build dependencies and install them when required. + +Both the MSYS `bin` directory as well as the MinGW `bin` directory must +be on the `PATH` to run the `setup.py` script. Usually, these folders +are `C:\msys64\usr\bin` and `C:\msys64\mingw64\bin`, but they may differ +for your installation. + +In addition to this, the `setup.py` script expects the `Dependencies` +program found [here](https://github.com/lucasg/Dependencies) to be +installed under `deps/Dependencies.exe` by default. This tool is used +to find all DLL-files necessary to run `gttk` without any external files. + +If you have satisfied all requirements, assuming you want to install +the package *outside* of your MSYS installation: +```bash +# Replace C:\Python with the path to your Python setup +# The MSYS version of Python is on PATH and thus you should use an abspath! +C:\Python\python.exe setup.py install +``` + +The binary distribution of `gttk` will come with all DLL-files known to +be required to run it. These DLL-files are generally available under +their own specific licenses, as covered in the files that are found in +the MSYS directory `/share/licenses`. + +## Usage +Simply import the package and instantiate the `GTTK` class. Then the +theme will become available for usage in a `ttk.Style`. +```python +import tkinter as tk +from tkinter import ttk +from gttk import GTTK + +window = tk.Tk() +gttk = GTTK(window) +style = ttk.Style() +style.theme_use("gttk") +print(gttk.get_current_theme()) # Prints the active GTK theme +gttk.set_gtk_theme("Yaru") # Sets GTK theme, provided by developer +ttk.Button(window, text="Destroy", command=window.destroy).pack() + +window.mainloop() +``` + +If you encounter an error because you are running in the repository, +directory, make sure to disallow imports from the working directory +before importing `gttk`: +```python +import sys +sys.path = sys.path[2:] +import gttk +``` + +## Setting the GTK Theme +So, now that you've installed `gttk` and loaded it into your application, +you want to specify what GTK should be loaded. Due to the nature of GTK, +this may seem a bit complicated, but it's not too hard. + +### Default theme directories +The default theme directory on **Linux** are specified by the XDG +standard and generally `/usr/share/themes` is used. This folder contains +Gnome themes, which can be applied to `gttk` if it includes a GTK+-2.0 +theme variant. + +On **Windows** the default directory is given by +`${dirname(GetModuleFileName())}\\share\\themes`, where `GetModuleFileName()` +is a `win32` function that returns the path to the current executable, +so usually `%PYTHONDIR%\\python.exe`. + +These folders are not really convenient, as users do not generally +have write permissions for them. + +### Setting a different theme directory +A different theme directory may be specified by passing the +`theme_dir_prefix` kwarg to `GTTK.__init__`, or by setting the +environment variable `GTK_DATA_PREFIX`. This value only serves as a +prefix, so then the theme directory becomes +`${GTK_DATA_PREFIX}/share/themes`. Check the absolute path with +`GTTK().get_themes_directory()`. + +### Loading a different theme +To load a theme from the theme directory, first make sure that you have +copied a proper GTK+-2.0 theme into the theme directory, in its own +sub-folder. Then, set the theme using the GTTK class +```python +gttk = GTTK(window, theme="THEME_NAME_HERE") +# OR +gttk.set_theme("THEME_NAME_HERE") +``` +or you can create a `~/.gtkrc` file (the specific paths of the files +that are parsed are found with `GTTK().get_default_files()`) and having +at least the line +```python +gtk-theme-name = "THEME_NAME_HERE" +``` + +This will then be applied to all GTK applications that read the resource +file. + +## Screenshots +`gttk` should work with any GTK theme you can throw at it, but below +are the themes Yaru and Adwaita as examples. + +![Yaru Example](https://raw.githubusercontent.com/RedFantom/python-gttk/master/screenshots/yaru.png) +![Adapta Example](https://raw.githubusercontent.com/RedFantom/python-gttk/master/screenshots/adwaita.png) + +## License and Copyright +This repository provides a wrapper around `gttk`, which is a renamed +version of `gtkTtk`, which in turn is a renamed version of `tile-gtk`. +The original `tile-gtk` is available under hte MIT License. This version +is available only under GNU GPLv3. + +``` +python-gttk +Copyright (c) 2008-2012 Georgios Petasis +Copyright (c) 2012 Cheer Xiao +Copyright (c) 2019-2020 Géballin +Copyright (c) 2020 RedFantom - cmake -DCMAKE_INSTALL_PREFIX=`tclsh <<< 'puts [lindex $auto_path end]'` - make - make install -(sudo make install if you're not root) +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. -## Selecting gtkTtk as default ttk theme +You should have received a copy of the GNU General Public License +along with this program. If not, see . +``` -The easiest way is to install [ttk-theme-chooser](https://github.com/Geballin/TTK-Theme-chooser) -And select gtkTtk as your ttk theme : -![screenshot](ttk-theme-chooser.png "ttk-theme-chooser") +## Project State +`tile-gtk`, `gtkTtk` and hence also `gttk` are far from perfect. You may +encounter various graphical artifacts when using particular themes, +while others work without flaws. -[1]: http://www.tclcommunityassociation.org/wub/proceedings/Proceedings-2010/GeorgePetasis/TileQtAndTileGTK.pdf +You are welcome to report any issues, and pull requests are even better. +Currently the package can only be built for Linux-based systems and +attempts to create a process for building on Windows using MSYS and +CMake have proven unfruitful. If you would like to give it a go, +feel free to contact me. diff --git a/clean.sh b/clean.sh new file mode 100755 index 0000000..4c46227 --- /dev/null +++ b/clean.sh @@ -0,0 +1,9 @@ +#!/bin/bash +rm libgttk.so +rm libgttk.dll +rm CMakeCache.txt +rm cmake_install.cmake +rm -rf cmake-build-debug +rm -rf CMakeFiles +rm -rf _skbuild +rm -rf gttk.egg-info diff --git a/cmake/Modules/FindGNOME2.cmake b/cmake/Modules/FindGNOME2.cmake deleted file mode 100644 index 0014737..0000000 --- a/cmake/Modules/FindGNOME2.cmake +++ /dev/null @@ -1,161 +0,0 @@ -# - try to find GNOME library -# GNOME_INCLUDE_DIR - Directories to include to use GNOME -# GNOME_LIBRARIES - Files to link against to use GNOME -# GNOME_FOUND - GNOME was found - -SET ( GNOME_ADDITIONAL_INCLUDE_PATHS - "$ENV{ProgramFiles}/gtk+-bundle-2.12.11/include" - "$ENV{ProgramFiles}/gtk+/include" - "$ENV{ProgramFiles}/gtk/include" -) - -SET ( GNOME_ADDITIONAL_LIBRARY_PATHS - "$ENV{ProgramFiles}/gtk+-bundle-2.12.11/lib" - "$ENV{ProgramFiles}/gtk+/lib" - "$ENV{ProgramFiles}/gtk/lib" -) - -FIND_PATH ( GNOME_libgnome_INCLUDE_PATH NAMES libgnome/libgnome.h - PATH_SUFFIXES libgnome-2.0 libgnome-20 libgnome20 libgnome2 - gnome-2.0 gnome-20 gnome20 gnome2 - PATHS - /usr/include - /usr/openwin/share/include - /usr/openwin/include - /opt/gnome/include - ${GNOME_ADDITIONAL_INCLUDE_PATHS} -) - -FIND_PATH ( GNOME_libgnomeui_INCLUDE_PATH NAMES libgnomeui/libgnomeui.h - PATH_SUFFIXES libgnomeui-2.0 libgnomeui-20 libgnomeui20 libgnomeui2 - gnomeui-2.0 gnomeui-20 gnomeui20 gnomeui2 - PATHS - /usr/include - /usr/openwin/share/include - /usr/openwin/include - /opt/gnome/include - ${GNOME_ADDITIONAL_INCLUDE_PATHS} -) - -FIND_PATH ( GNOME_libgnomecanvas_INCLUDE_PATH - NAMES libgnomecanvas/libgnomecanvas.h - PATH_SUFFIXES libgnomecanvas-2.0 libgnomecanvas-20 - libgnomecanvas20 libgnomecanvas2 - gnomecanvas-2.0 gnomecanvas-20 - gnomecanvas20 gnomecanvas2 - PATHS - /usr/include - /usr/openwin/share/include - /usr/openwin/include - /opt/gnome/include - ${GNOME_ADDITIONAL_INCLUDE_PATHS} -) - -FIND_PATH ( GNOME_libgnomevfs_INCLUDE_PATH - NAMES libgnomevfs/gnome-vfs.h - PATH_SUFFIXES libgnome-vfs-2.0 libgnome-vfs-20 - libgnome-vfs20 libgnome-vfs2 - gnome-vfs-2.0 gnome-vfs-20 - gnome-vfs20 gnome-vfs2 - PATHS - /usr/include - /usr/openwin/share/include - /usr/openwin/include - /opt/gnome/include - ${GNOME_ADDITIONAL_INCLUDE_PATHS} -) - -FIND_PATH ( GNOME_libart_INCLUDE_PATH NAMES libart_lgpl/libart.h - PATH_SUFFIXES libart-2.0 libart-20 libart20 libart2 - art-2.0 art-20 art20 art2 - PATHS - /usr/include - /usr/openwin/share/include - /usr/openwin/include - /opt/gnome/include - ${GNOME_ADDITIONAL_INCLUDE_PATHS} -) - -FIND_PATH ( GNOME_bonobo_INCLUDE_PATH NAMES bonobo/bonobo-i18n.h - PATH_SUFFIXES libbonobo-2.0 libbonobo-20 libbonobo20 libbonobo2 - bonobo-2.0 bonobo-20 bonobo20 bonobo2 - PATHS - /usr/include - /usr/openwin/share/include - /usr/openwin/include - /opt/gnome/include - ${GNOME_ADDITIONAL_INCLUDE_PATHS} -) - -FIND_PATH ( GNOME_bonoboui_INCLUDE_PATH NAMES bonobo/bonobo-dock.h - PATH_SUFFIXES libbonoboui-2.0 libbonoboui-20 libbonoboui20 libbonoboui2 - bonoboui-2.0 bonoboui-20 bonoboui20 bonoboui2 - PATHS - /usr/include - /usr/openwin/share/include - /usr/openwin/include - /opt/gnome/include - ${GNOME_ADDITIONAL_INCLUDE_PATHS} -) - -FIND_LIBRARY ( GNOME_gnome_LIBRARY - NAMES gnome-2 gnome - PATHS - /usr/openwin/lib - /opt/gnome/lib - /usr/lib - ${GNOME_ADDITIONAL_LIBRARY_PATHS} -) - -FIND_LIBRARY ( GNOME_gnomeui_LIBRARY - NAMES gnomeui-2 gnomeui - PATHS - /usr/openwin/lib - /opt/gnome/lib - /usr/lib - ${GNOME_ADDITIONAL_LIBRARY_PATHS} -) - -IF ( GNOME_libgnome_INCLUDE_PATH AND GNOME_gnome_LIBRARY ) - SET ( GNOME_FOUND "YES" ) - SET ( GNOME_INCLUDE_DIR ${GNOME_libgnome_INCLUDE_PATH} ) - IF ( GNOME_libgnomeui_INCLUDE_PATH ) - SET ( GNOME_INCLUDE_DIR ${GNOME_INCLUDE_DIR} - ${GNOME_libgnomeui_INCLUDE_PATH} ) - ENDIF ( GNOME_libgnomeui_INCLUDE_PATH ) - IF ( GNOME_libgnomecanvas_INCLUDE_PATH ) - SET ( GNOME_INCLUDE_DIR ${GNOME_INCLUDE_DIR} - ${GNOME_libgnomecanvas_INCLUDE_PATH} ) - ENDIF ( GNOME_libgnomecanvas_INCLUDE_PATH ) - IF ( GNOME_libgnomevfs_INCLUDE_PATH ) - SET ( GNOME_INCLUDE_DIR ${GNOME_INCLUDE_DIR} - ${GNOME_libgnomevfs_INCLUDE_PATH} ) - ENDIF ( GNOME_libgnomevfs_INCLUDE_PATH ) - IF ( GNOME_libart_INCLUDE_PATH ) - SET ( GNOME_INCLUDE_DIR ${GNOME_INCLUDE_DIR} ${GNOME_libart_INCLUDE_PATH} ) - ENDIF ( GNOME_libart_INCLUDE_PATH ) - IF ( GNOME_bonobo_INCLUDE_PATH ) - SET ( GNOME_INCLUDE_DIR ${GNOME_INCLUDE_DIR} ${GNOME_bonobo_INCLUDE_PATH} ) - ENDIF ( GNOME_bonobo_INCLUDE_PATH ) - IF ( GNOME_bonoboui_INCLUDE_PATH ) - SET ( GNOME_INCLUDE_DIR ${GNOME_INCLUDE_DIR} ${GNOME_bonoboui_INCLUDE_PATH}) - ENDIF ( GNOME_bonoboui_INCLUDE_PATH ) - - - SET ( GNOME_LIBRARIES ${GNOME_gnome_LIBRARY} ) - IF ( GNOME_gnomeui_LIBRARY ) - SET ( GNOME_LIBRARIES ${GNOME_LIBRARIES} ${GNOME_gnomeui_LIBRARY} ) - ENDIF ( GNOME_gnomeui_LIBRARY ) - - MARK_AS_ADVANCED ( - GNOME_libgnome_INCLUDE_PATH - GNOME_libgnomeui_INCLUDE_PATH - GNOME_libgnomecanvas_INCLUDE_PATH - GNOME_libgnomevfs_INCLUDE_PATH - GNOME_libart_INCLUDE_PATH - GNOME_bonobo_INCLUDE_PATH - GNOME_bonoboui_INCLUDE_PATH - GNOME_gnome_LIBRARY - GNOME_gnomeui_LIBRARY - ) -ENDIF ( GNOME_libgnome_INCLUDE_PATH AND GNOME_gnome_LIBRARY ) diff --git a/cmake/Modules/FindGTK2.cmake b/cmake/Modules/FindGTK2.cmake deleted file mode 100644 index c20aeda..0000000 --- a/cmake/Modules/FindGTK2.cmake +++ /dev/null @@ -1,185 +0,0 @@ -## -## Author: George Petasis -## - -# - try to find GTK (and glib) and GTKGLArea -# GTK2_INCLUDE_DIR - Directories to include to use GTK -# GTK2_LIBRARIES - Files to link against to use GTK -# GTK2_FOUND - GTK was found -# -# - Other advanced variables: -# GTK2_gtk_INCLUDE_PATH -# GTK2_gdk_INCLUDE_PATH -# GTK2_glibconfig_INCLUDE_PATH -# GTK2_glib_INCLUDE_PATH -# GTK2_cairo_INCLUDE_PATH -# GTK2_pango_INCLUDE_PATH -# GTK2_atk_INCLUDE_PATH -# -# GTK2_gtk_LIBRARY -# GTK2_glib_LIBRARY -# GTK2_gdk_LIBRARY -# GTK2_gmodule_LIBRARY -# GTK2_gobject_LIBRARY -# GTK2_gthread_LIBRARY -# GTK2_gio_LIBRARY -# GTK2_cairo_LIBRARY -# GTK2_pango_LIBRARY -# GTK2_atk_LIBRARY - -# - Usage: -# The behaviour of the module can be altered through variables, defined -# before the module is loaded. These (optional) variables are: -# -# GTK2_ADDITIONAL_PATHS: A list of paths to search for GTK+ -# GTK2_LIBRARY_NAMES: A list of names to be used when searching for -# libraries/include directories. -# If not initialised, defaults to: -# "-x11-2.0 -win32-2.0 -2.0 20 -win32 -x11 -# -x11-1.0 -win32-1.0 -1.0 10" -# GTK2_SEARCH_LIBRARIES: A list of additional libraries to be searched. -# If not initialised, defaults to: -# "gdk gmodule gobject gthread gio cairo pango atk" -# GTK2_LOGGING_ENABLED: If true, include/library paths will be printed. -# Defaults to "undefined". -# - -############################################################################## -## Configuration section -############################################################################## - -SET ( GTK2_PATHS /usr /opt/gnome /usr/openwin /usr/local ) - -## GTK2_ADDITIONAL_PATHS: Additional paths to look for GTK+ 2.x -SET ( GTK2_ADDITIONAL_PATHS ${GTK2_ADDITIONAL_PATHS} - "$ENV{ProgramFiles}/gtk+-bundle-2.12.11" ) - -## GTK2_SEARCH_LIBRARIES_DEFAULT: This variable holds the names of libraries -## that will always be searched by this module. -SET ( GTK2_SEARCH_LIBRARIES_DEFAULT gtk glib ) - -## GTK2_LIBRARY_NAMES: A set of names under which libraries will be searched. -SET ( GTK2_LIBRARY_NAMES ${GTK2_LIBRARY_NAMES} - -x11-2.0 -win32-2.0 -2.0 20 -win32 -x11 - -x11-1.0 -win32-1.0 -1.0 10 ) - -## GTK2_SEARCH_LIBRARIES: This variable holds the names of libraries that can -## be optionally searched by the module. If not specified by the caller, it is -## set to a large number of libraries. -IF ( NOT GTK2_SEARCH_LIBRARIES ) - SET ( GTK2_SEARCH_LIBRARIES gdk gmodule gobject gthread - gio cairo pango atk ) -ENDIF ( NOT GTK2_SEARCH_LIBRARIES ) - -SET ( GTK2_INCLUDE_FILES_INFO - gtk gtk/gtk.h - gdk gdkconfig.h - glibconfig glibconfig.h - glib glib.h - cairo cairo.h - pango pango/pango.h - atk atk/atkobject.h -) - -############################################################################## -## End of Configuration section -############################################################################## - -## Convert GTK2_ADDITIONAL_PATHS to -## GTK2_ADDITIONAL_INCLUDE_PATHS & GTK2_ADDITIONAL_LIBRARY_PATHS -FOREACH ( gtk2_path ${GTK2_ADDITIONAL_PATHS} ) - FILE ( TO_CMAKE_PATH ${gtk2_path} gtk2_path_cmake ) - SET ( GTK2_ADDITIONAL_INCLUDE_PATHS ${GTK2_ADDITIONAL_INCLUDE_PATHS} - ${gtk2_path_cmake}/include - ${gtk2_path_cmake}/share/include - ${gtk2_path_cmake}/include/gtk-2.0 - ${gtk2_path_cmake}/lib/gtk-2.0/include - ${gtk2_path_cmake}/lib64/gtk-2.0/include - ${gtk2_path_cmake}/lib/glib-2.0/include - ${gtk2_path_cmake}/lib64/glib-2.0/include - ) - SET ( GTK2_ADDITIONAL_LIBRARY_PATHS ${GTK2_ADDITIONAL_LIBRARY_PATHS} - ${gtk2_path_cmake}/lib ${gtk2_path_cmake}/lib64 ) -ENDFOREACH ( gtk2_path ) -MESSAGE ( STATUS ${GTK2_ADDITIONAL_LIBRARY_PATHS} ) - -## Convert GTK2_PATHS to -## GTK2_INCLUDE_PATHS & GTK2_LIBRARY_PATHS -FOREACH ( gtk2_path ${GTK2_PATHS} ) - FILE ( TO_CMAKE_PATH ${gtk2_path} gtk2_path_cmake ) - SET ( GTK2_INCLUDE_PATHS ${GTK2_INCLUDE_PATHS} - ${gtk2_path_cmake}/include - ${gtk2_path_cmake}/share/include - ${gtk2_path_cmake}/include/gtk-2.0 - ${gtk2_path_cmake}/lib/gtk-2.0/include - ${gtk2_path_cmake}/lib64/gtk-2.0/include - ${gtk2_path_cmake}/lib/glib-2.0/include - ${gtk2_path_cmake}/lib64/glib-2.0/include - ) - SET ( GTK2_LIBRARY_PATHS ${GTK2_LIBRARY_PATHS} - ${gtk2_path_cmake}/lib ${gtk2_path_cmake}/lib64 ) -ENDFOREACH ( gtk2_path ) - -## -## Function: GTK2_GET_NAMES -## -FUNCTION ( GTK2_GET_NAMES library variable ) - FOREACH ( name ${GTK2_LIBRARY_NAMES} ) - SET ( ${variable} ${${variable}} ${library}${name} ) - ENDFOREACH ( name ) - SET ( ${variable} ${${variable}} ${library} ) - SET ( ${variable} ${${variable}} PARENT_SCOPE ) -ENDFUNCTION ( GTK2_GET_NAMES ) - -LIST ( LENGTH GTK2_INCLUDE_FILES_INFO GTK2_INCLUDE_FILES_INFO_LEN ) -MATH ( EXPR GTK2_INCLUDE_FILES_INFO_LEN - "${GTK2_INCLUDE_FILES_INFO_LEN}-1" ) -FOREACH ( gtk2_i RANGE 0 ${GTK2_INCLUDE_FILES_INFO_LEN} 2 ) - LIST ( GET GTK2_INCLUDE_FILES_INFO ${gtk2_i} gtk2_library ) - MATH ( EXPR gtk2_i ${gtk2_i}+1 ) - LIST ( GET GTK2_INCLUDE_FILES_INFO ${gtk2_i} gtk2_header ) - GTK2_GET_NAMES ( ${gtk2_library} GTK2_${gtk2_library}_PATH_SUFFIXES ) - FIND_PATH ( GTK2_${gtk2_library}_INCLUDE_PATH - PATH_SUFFIXES ${GTK2_${gtk2_library}_PATH_SUFFIXES} - NAMES ${gtk2_header} - PATHS ${GTK2_INCLUDE_PATHS} - ${GTK2_ADDITIONAL_INCLUDE_PATHS} - ) - IF ( GTK2_LOGGING_ENABLED ) - MESSAGE ( STATUS " + ${gtk2_header}: \t${GTK2_${gtk2_library}_INCLUDE_PATH}" ) - ENDIF ( GTK2_LOGGING_ENABLED ) - MARK_AS_ADVANCED ( GTK2_${gtk2_library}_INCLUDE_PATH ) - IF ( GTK2_${gtk2_library}_INCLUDE_PATH ) - SET (GTK2_INCLUDE_DIR ${GTK2_INCLUDE_DIR} ${GTK2_${gtk2_library}_INCLUDE_PATH} ) - ENDIF ( GTK2_${gtk2_library}_INCLUDE_PATH ) -ENDFOREACH ( gtk2_i ) - -## -## Locate GTK+ 2.0 libraries... -## - -FOREACH ( gtk2_library ${GTK2_SEARCH_LIBRARIES_DEFAULT} ${GTK2_SEARCH_LIBRARIES} ) - GTK2_GET_NAMES ( ${gtk2_library} GTK2_${gtk2_library}_LIBRARY_NAMES ) - FIND_LIBRARY ( GTK2_${gtk2_library}_LIBRARY - NAMES ${GTK2_${gtk2_library}_LIBRARY_NAMES} - PATHS ${GTK2_LIBRARY_PATHS} - ${GTK2_ADDITIONAL_LIBRARY_PATHS} - ) - IF ( GTK2_LOGGING_ENABLED ) - MESSAGE ( STATUS " + ${gtk2_library}: \t${GTK2_${gtk2_library}_LIBRARY}" ) - ENDIF ( GTK2_LOGGING_ENABLED ) - MARK_AS_ADVANCED ( GTK2_${gtk2_library}_LIBRARY ) -ENDFOREACH ( gtk2_library ) - -INCLUDE(FindPackageHandleStandardArgs) -FIND_PACKAGE_HANDLE_STANDARD_ARGS ( GTK2 DEFAULT_MSG - GTK2_gtk_LIBRARY GTK2_glib_LIBRARY - GTK2_gtk_INCLUDE_PATH GTK2_glib_INCLUDE_PATH -) - -IF ( GTK2_FOUND ) - FOREACH ( gtk2_library ${GTK2_SEARCH_LIBRARIES_DEFAULT} ) - SET ( GTK2_LIBRARIES ${GTK2_LIBRARIES} - ${GTK2_${gtk2_library}_LIBRARY} ) - ENDFOREACH ( gtk2_library ) -ENDIF ( GTK2_FOUND ) diff --git a/cmake/build.bat b/cmake/build.bat deleted file mode 100644 index c70c993..0000000 --- a/cmake/build.bat +++ /dev/null @@ -1,42 +0,0 @@ -@echo off -REM ========================================================================== -REM Run cmake with a suitable (i.e. installed) generator! -REM ========================================================================== -REM The following generators are available on this platform: -REM Borland Makefiles = Generates Borland makefiles. -REM MSYS Makefiles = Generates MSYS makefiles. -REM MinGW Makefiles = Generates a make file for use with mingw32-make. -REM NMake Makefiles = Generates NMake makefiles. -REM Unix Makefiles = Generates standard UNIX makefiles. -REM Visual Studio 6 = Generates Visual Studio 6 project files. -REM Visual Studio 7 = Generates Visual Studio .NET 2002 project files. -REM Visual Studio 7 .NET 2003 = Generates Visual Studio .NET 2003 project files. -REM Visual Studio 8 2005 = Generates Visual Studio .NET 2005 project files. -REM Visual Studio 8 2005 Win64 = Generates Visual Studio .NET 2005 Win64 project files. -REM Visual Studio 9 2008 = Generates Visual Studio 9 2008 project files. -REM Visual Studio 9 2008 Win64 = Generates Visual Studio 9 2008 Win64 project files. -REM Watcom WMake = Generates Watcom WMake makefiles. -REM CodeBlocks - MinGW Makefiles = Generates CodeBlocks project files. -REM CodeBlocks - Unix Makefiles = Generates CodeBlocks project files. -REM Eclipse CDT4 - MinGW Makefiles = Generates Eclipse CDT 4.0 project files. -REM Eclipse CDT4 - NMake Makefiles = Generates Eclipse CDT 4.0 project files. -REM Eclipse CDT4 - Unix Makefiles = Generates Eclipse CDT 4.0 project files. - -mkdir build-win32-vs -cd build-win32-vs -cmake -G "Visual Studio 9 2008" -D CMAKE_INSTALL_PREFIX=../runtime ..\.. -cd .. - -mkdir build-win32-nmake-debug -cd build-win32-nmake-debug -cmake -G "NMake Makefiles" -D CMAKE_BUILD_TYPE=Debug -D CMAKE_INSTALL_PREFIX=../runtime ..\.. -cd .. -mkdir build-win32-nmake-release -cd build-win32-nmake-release -cmake -G "NMake Makefiles" -D CMAKE_BUILD_TYPE=Release -D CMAKE_INSTALL_PREFIX=../runtime ..\.. -cd .. - -REM mkdir build-win64 -REM cd build-win64 -REM cmake -G "Visual Studio 9 2008 Win64" -D CMAKE_INSTALL_PREFIX=../runtime ..\.. -REM cd .. diff --git a/cmake/build.sh b/cmake/build.sh deleted file mode 100644 index 7435a9a..0000000 --- a/cmake/build.sh +++ /dev/null @@ -1,21 +0,0 @@ -#!/bin/sh -# ========================================================================== -# Run cmake with a suitable (i.e. installed) generator! -# ========================================================================== -# The following generators are available on this platform: -# Unix Makefiles = Generates standard UNIX makefiles. -# CodeBlocks - Unix Makefiles = Generates CodeBlocks project files. -# Eclipse CDT4 - Unix Makefiles -# = Generates Eclipse CDT 4.0 project files. -# KDevelop3 = Generates KDevelop 3 project files. -# KDevelop3 - Unix Makefiles = Generates KDevelop 3 project files. - -mkdir -p debug-build-unix64-make -cd debug-build-unix64-make -cmake -G "Unix Makefiles" -D CMAKE_BUILD_TYPE=Debug -D CMAKE_INSTALL_PREFIX=../runtime ../.. -cd .. - -mkdir -p release-build-unix64-make -cd release-build-unix64-make -cmake -G "Unix Makefiles" -D CMAKE_BUILD_TYPE=Release -D CMAKE_INSTALL_PREFIX=../runtime ../.. -cd .. diff --git a/cmake/build_64.sh b/cmake/build_64.sh deleted file mode 100644 index 05525f7..0000000 --- a/cmake/build_64.sh +++ /dev/null @@ -1,21 +0,0 @@ -#!/bin/sh -# ========================================================================== -# Run cmake with a suitable (i.e. installed) generator! -# ========================================================================== -# The following generators are available on this platform: -# Unix Makefiles = Generates standard UNIX makefiles. -# CodeBlocks - Unix Makefiles = Generates CodeBlocks project files. -# Eclipse CDT4 - Unix Makefiles -# = Generates Eclipse CDT 4.0 project files. -# KDevelop3 = Generates KDevelop 3 project files. -# KDevelop3 - Unix Makefiles = Generates KDevelop 3 project files. - -mkdir -p debug-build-unix64-make -cd debug-build-unix64-make -cmake -G "Unix Makefiles" -D CMAKE_BUILD_TYPE=Debug -D PKG_OS_ARCH=x86_64 -D CMAKE_INSTALL_PREFIX=../runtime ../.. -cd .. - -mkdir -p release-build-unix64-make -cd release-build-unix64-make -cmake -G "Unix Makefiles" -D CMAKE_BUILD_TYPE=Release -D PKG_OS_ARCH=x86_64 -D CMAKE_INSTALL_PREFIX=../runtime ../.. -cd .. diff --git a/demos/StyleIntrospection.tcl b/demos/StyleIntrospection.tcl deleted file mode 100644 index ca78a88..0000000 --- a/demos/StyleIntrospection.tcl +++ /dev/null @@ -1,36 +0,0 @@ -############################################################################### -## StyleIntrospection.tcl: -## This demo shows information about the Gtk/GNOME style currently in use. -## -############################################################################### -if {[catch {package require Ttk}]} { - package require tile -} -ttk::setTheme tilegtk - -set win {} -label $win.lbl_option -text Option: -label $win.lbl_1 -text NORMAL -label $win.lbl_2 -text PRELIGHT -label $win.lbl_3 -text ACTIVE -label $win.lbl_4 -text SELECTED -label $win.lbl_5 -text INSENSITIVE -grid $win.lbl_option $win.lbl_1 $win.lbl_2 $win.lbl_3 $win.lbl_4 $win.lbl_5 \ - -sticky snew -padx 2 -pady 2 -set row 1 -foreach base {fg bg base text light mid dark text_aa} { - set col 0 - label $win.$base -text "$base:" -anchor w - grid $win.$base -row $row -column $col - foreach state {NORMAL PRELIGHT ACTIVE SELECTED INSENSITIVE} { - set colour [ttk::theme::tilegtk::currentThemeColour ${base}($state)] - label $win.${base}_$state -background $colour \ - -relief raised -borderwidth 1 - label $win.${base}_${state}_value -text $colour - grid $win.${base}_$state -row $row -column [incr col] \ - -sticky snew -padx 2 -pady 2 - grid $win.${base}_${state}_value -row [expr {$row+1}] -column $col \ - -sticky snew -padx 2 -pady 2 - } - incr row 2 -} diff --git a/demos/WidgetStates.tcl b/demos/WidgetStates.tcl deleted file mode 100644 index 60cb8c9..0000000 --- a/demos/WidgetStates.tcl +++ /dev/null @@ -1,136 +0,0 @@ -############################################################################### -## WidgetStates.tcl: -## This demo shows information about the Gtk/GNOME style currently in use. -## -############################################################################### -if {[catch {package require Ttk}]} { - package require tile -} -ttk::setTheme tilegtk -foreach {arg val} $argv { - switch -glob -- $arg { - -st* {ttk::theme::tilegtk::applyStyle $val} - } -} - -set exit_image_data { -R0lGODlhEAAQAOepAI0LC5ANDZMODpsTE58WFqIYGKUbG6gdHbAcHKwgIK0i -IrQfH64iIrEjI7MlJboiIrYnJ7coKLgpKb8mJroqKr0qKsQqKsktLcguLrk2 -NsovL780NM0wMMQ2NtEzM9IzM8g5Oa5FRdU1Nc84ONY2NtM4ONo5OdU+PsNG -Rt07O948PN8+PuI/P9VFRdtDQ9xDQ+FBQeBDQ+BEROZCQulEROpERMRVVdVO -TsdWVuZJSe1GRulISOpISOlKSu5ISOtKSuxLS+1LS8ZcXMdcXPBLS9RYWOdQ -UOVTU8dgYPZNTddbW8phYflPT/pQUM5kZPxRUc1mZtFnZ79yctVpaexgYORk -ZNlsbM5xccV1ddlubtZwcNxubutoaOhqas91dct3d+Bubt5wcN9yculvb+Zy -ctp4eOV2dtl+ftuDg+GDg9eOjs+Tk+mJidmUlNGdneOcnNqhocmqqtikpO6e -nt+lpcyxsd6srOWrq9iysuGwsNuzs92zs+yurvOrq9m3t9i4uPSsrO6vr9y4 -uPCwsOG3t+S3t+C7u9+9vee7u+i7u+jAwN3Hx97Hx9/IyOLOzurNzezOzu/P -z+bU1PDQ0PLQ0OvU1OPY2OnW1uXZ2e/a2u/b2+3c3O3d3fHq6vPr6/j09Pr1 -9fv19fn29vv29vn39/v39/v5+fz5+f7+/v////////////////////////// -//////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////// -/////////////////////yH+FUNyZWF0ZWQgd2l0aCBUaGUgR0lNUAAh+QQB -CgD/ACwAAAAAEAAQAAAI/gD/KaBAsKBBggoElhiCpOESJ1GmWNkSBgwPBRKE -0Nmo6JKnTpIM8Qk0iIyECDbUtKmUipQlTKRSOXozZ0wECBm8PEJVR8qZNGgO -oVrEhgsEBwiupIoDJcsdOWLMIEq1hoqDBgvsfApRREkpUTiqdBn150cDBg8y -MaowosUpUyiOGJm0KQaDBBM0NcLggcTbDjNoUOL0IsEBC3k+bSBh4i0IGkBC -4SFywMAFLancmFCRyM8JHYBSYWFioACHD4VQwZExA0aQPqgE5WhSgMAHEi4I -pQIFKVKoVIJuNHlCYICIzSzK7OHESc+XHsOfDAigIQWLGTV0+NiRhEn0FQH+ -CwEQQL68efIA/gUEADs=} - -set help_image_data { -R0lGODlhEAAQAMZxABpk+htl/CJo+CJr/yVt/yZt/yht+ypw/ytw/S5z/zF1 -/zJ2/zV4/jZ4/zt8/zx8/z58+j1+/0B//0GA/0iA8EuC80iD/kmE/EqF/U6F -9U6H/E+I/lSK91OL/laM+1aM/FmM9FSN/1WO/1aO/lqQ/lyQ+l2Q+l+Q9lqR -/1uR/VuR/1yR/l2S/16T/16U/l+U/WCU/2OW/mma/G2c/Gyd/22d/26e/3Cf -/3eg9Hmj+X6n+Xyo/4as94es+Iet+oSu/4eu/Yiw/4yy/5S3/pq5+Zq8/6C/ -/qbD/6nF/arF/arG/qzH/7DK/7bN/LfN+rXO/7vQ+b/Q9LzS/r7S+8XU8sLW -/sfX+MjY+sra+c/e/NDf/tTg+Nji+Nfj/dbk/trk+Nzk9tnl/dzm+N3m993n -+97p/97q/+Lr/uLs/+vv+Orx/+3y++7y/PD1//j6//z9//3+//////////// -/////////////////////////////////////////////////yH+FUNyZWF0 -ZWQgd2l0aCBUaGUgR0lNUAAh+QQBCgB/ACwAAAAAEAAQAAAHuYB/goOEhYYP -EyUmDwuGgg4dSGdfXGRQHgeFDjJaWGJxcWxbXjgFhBtSU2txamhvcVlVGoMP -QExOcW1MTFZxZUo6A4ISQ0VGZk9FRGBxSSMhCYIYP9TUPGNxYSkhIQ2CFjTh -NDVUcV0vIukMghEtLi0sKmluMSj2KAiCCisw/TBNS/zBIBFg0AUbCGdEuXID -oQ0IhA6c2LEjB5w4QSiCAFCIAAcfQo4sEdIjA0dHBip88EBBgKOXhgIBADs= -====} - -image create photo exit_image -data $exit_image_data -image create photo help_image -data $help_image_data - -grid [ttk::label .themel -text {Current Qt Theme:}] \ - [ttk::label .theme -textvariable ttk::theme::tilegtk::theme] \ - -sticky snew -set win [ttk::frame .frame] -grid $win - -sticky snew -grid columnconfigure . 1 -weight 1 -set row 0; set column 0 -set widgets {button checkbutton radiobutton entry menubutton combobox rcombobox - scrollbar scale progressbar notebook panedwindow labelframe} -set states {active disabled focus pressed selected readonly background - alternate} -foreach widget $widgets { - foreach state $states { - switch $widget { - labelframe { - set w [ttk::$widget $win.${widget}_$state -class Toolbar] - ttk::menubutton $w.mb -text Toolbar -width 8 - pack $w.mb -fill both - } - rcombobox { - set w [ttk::combobox $win.${widget}_$state -state readonly] - } - default { - set w [ttk::$widget $win.${widget}_$state] - } - } - catch { $w configure -from 0 -to 100 } - catch { $w configure -value 35 } - catch { $w configure -text $state } - catch { $w configure -image help_image -compound left } - catch { $w configure -orient horizontal } - catch { $w configure -exportselection 0} - catch { $w delete 0 end } - catch { $w insert end "$state" } - catch { $w selection range 0 5 } - if {$widget == "notebook"} { - set pw [ttk::panedwindow $w.client -orient horizontal] - $w add $pw -text "Demo 1" - $pw state $state - ttk::label $pw.l -text "Notebook Page" - pack $pw.l -fill both - if {$state != "pressed"} { - set pw [ttk::panedwindow $w.client2 -orient horizontal] - $w add $pw -text "Demo 2" - } - } else { - $w state $state - } - switch -glob $widget { - *combobox - menubutton - entry { - $w configure -width 8 - } - } - grid $w -row $row -column $column -sticky snw -padx 1 -pady 1 - incr column - #if {$column > 4} {incr row; set column 0} - } - incr row - set column 0 -} -ttk::labelframe $win.themes -text Themes: - set col -1; set row 0 - foreach style [lsort [ttk::theme::tilegtk::availableStyles]] { - if {$col > 6} {incr row; set col -1} - grid [ttk::button $win.themes.[string tolower $style] -text $style \ - -command "ttk::theme::tilegtk::applyStyle \{$style\}"] \ - -column [incr col] -row $row -sticky snew -padx 1 -pady 1 - } - ttk::button $win.themes.exit -text Exit -image exit_image \ - -compound left -command exit - grid $win.themes.exit -columnspan 8 -padx 5 -pady 10 -grid $win.themes -columnspan [llength $states] -padx 2 -pady 2 -grab set $win.themes -focus $win.themes.exit diff --git a/demos/autocomplete.tcl b/demos/autocomplete.tcl deleted file mode 100644 index c4bf8b7..0000000 --- a/demos/autocomplete.tcl +++ /dev/null @@ -1,58 +0,0 @@ -# -# $Id: autocomplete.tcl,v 1.1 2008/08/03 14:52:09 petasis Exp $ -# -# Demonstration of inline auto-completion for Tile combobox widgets. -# -# Usage: -# -# enableAutoComplete path ?presorted? -# -# path may be an individual window to enable auto-completion for only -# that window, or TCombobox to enable it for all comboboxes. -# -# By default, the values list is assumed to be pre-sorted to optimize -# the search. If it is not presorted, pass 0 in for the second arg, -# and the list will be sorted before the search at the cost of some -# overhead. -# - -namespace eval tile::combobox { - namespace export enableAutocomplete -} - -## enableAutocomplete -# -# Enable inline auto-completion for the specified combobox widget. -# -proc tile::combobox::enableAutocomplete { w {presorted 1} } { - bind $w [namespace code [list DoAutoComplete %W %A $presorted]] -} - -## DoAutoComplete -# -# Perform inline auto-completion of typed text in the combobox. -# -proc tile::combobox::DoAutoComplete { w s presorted } { - set old [$w get] - tile::entry::Insert $w $s - set new [$w get] - - # Only auto-complete if the string length has changed due to insertion. - - if {[string length $old] != [string length $new]} { - set values [$w cget -values] - - if {!$presorted} { - set values [lsort -dictionary $values] - } - - set match [lsearch -inline $values $new*] - - if {[string length $match]} { - $w delete 0 end - $w insert end $match - $w selection range [string length $new] end - $w icursor [string length $new] - } - } -} diff --git a/demos/demo.tcl b/demos/demo.tcl deleted file mode 100644 index f1ae8ce..0000000 --- a/demos/demo.tcl +++ /dev/null @@ -1,890 +0,0 @@ -# -# $Id: demo.tcl,v 1.3 2010/09/30 13:44:44 petasis Exp $ -# -# Tile widget set -- widget demo -# -package require Tk -package require Ttk - -eval destroy [winfo children .] ;# in case script is re-sourced - -### Load auxilliary scripts. -# -variable demodir [file dirname [info script]] - -source [file join $demodir iconlib.tcl] -# source [file join $demodir toolbutton.tcl] -source [file join $demodir repeater.tcl] - -### Global options and bindings. -# -option add *Button.default normal -option add *Text.background white -option add *Entry.background white -option add *tearOff false - -# See toolbutton.tcl. -# -option add *Toolbar.relief groove -option add *Toolbar.borderWidth 2 -option add *Toolbar.Button.Pad 2 -option add *Toolbar.Button.default disabled -option add *Toolbar*takeFocus 0 - -# ... for debugging: -bind all { set ::W %W } -bind all { focus %W } - -# Stealth feature: -# -if {![catch {package require Img 1.3}]} { - bind all screenshot - proc screenshot {} { - image create photo ScreenShot -format window -data . - bell - # Gamma looks off if we use PNG ... - # Looks even worse if we use GIF ... - ScreenShot write screenshot.png -format png - image delete ScreenShot - bell - } -} - -### Global data. -# - -# The descriptive names of the builtin themes: -# -set ::THEMELIST { - default "Default" - classic "Classic" - alt "Revitalized" - winnative "Windows native" - xpnative "XP Native" - aqua "Aqua" -} -array set ::THEMES $THEMELIST; - -# Add in any available loadable themes: -# -foreach name [ttk::themes] { - if {![info exists ::THEMES($name)]} { - lappend THEMELIST $name [set ::THEMES($name) [string totitle $name]] - } -} - -# Generate icons (see also: iconlib.tcl): -# -foreach {icon data} [array get ::ImgData] { - set ::ICON($icon) [image create photo -data $data] -} - -variable ROOT "." -variable BASE [ttk::frame .base] -pack $BASE -side top -expand true -fill both - -array set ::V { - COMPOUND top - CONSOLE 0 - MENURADIO1 One - PBMODE determinate - SELECTED 1 - CHOICE 2 - SCALE 50 - VSCALE 0 -} - -### Utilities. -# - -## foreachWidget varname widget script -- -# Execute $script with $varname set to each widget in the hierarchy. -# -proc foreachWidget {varname Q script} { - upvar 1 $varname w - while {[llength $Q]} { - set QN [list] - foreach w $Q { - uplevel 1 $script - foreach child [winfo children $w] { - lappend QN $child - } - } - set Q $QN - } -} - -## sbstub $sb -- stub -command option for a scrollbar. -# Updates the scrollbar's position. -# -proc sbstub {sb cmd number {units units}} { sbstub.$cmd $sb $number $units } -proc sbstub.moveto {sb number _} { $sb set $number [expr {$number + 0.5}] } -proc sbstub.scroll {sb number units} { - if {$units eq "pages"} { - set delta 0.2 - } else { - set delta 0.05 - } - set current [$sb get] - set new0 [expr {[lindex $current 0] + $delta*$number}] - set new1 [expr {[lindex $current 1] + $delta*$number}] - $sb set $new0 $new1 -} - -## sbset $sb -- auto-hide scrollbar -# Scrollable widget -[xy]scrollcommand prefix. -# Sets the scrollbar, auto-hides/shows. -# Scrollbar must be controlled by the grid geometry manager. -# -proc sbset {sb first last} { - if {$first <= 0 && $last >= 1} { - grid remove $sb - } else { - grid $sb - } - $sb set $first $last -} - -## scrolled -- create a widget with attached scrollbars. -# -proc scrolled {class w args} { - set sf "${w}_sf" - - frame $sf - eval [linsert $args 0 $class $w] - scrollbar $sf.hsb -orient horizontal -command [list $w xview] - scrollbar $sf.vsb -orient vertical -command [list $w yview] - - configure.scrolled $sf $w - return $sf -} - -## ttk::scrolled -- create a widget with attached Tile scrollbars. -# -proc ttk::scrolled {class w args} { - set sf "${w}_sf" - - ttk::frame $sf - eval [linsert $args 0 $class $w] - ttk::scrollbar $sf.hsb -orient horizontal -command [list $w xview] - ttk::scrollbar $sf.vsb -orient vertical -command [list $w yview] - - configure.scrolled $sf $w - return $sf -} - -## configure.scrolled -- common factor of [scrolled] and [ttk::scrolled] -# -proc configure.scrolled {sf w} { - $w configure -xscrollcommand [list $sf.hsb set] - $w configure -yscrollcommand [list $sf.vsb set] - - grid $w -in $sf -row 0 -column 0 -sticky nwse - grid $sf.hsb -row 1 -column 0 -sticky we - grid $sf.vsb -row 0 -column 1 -sticky ns - - grid columnconfigure $sf 0 -weight 1 - grid rowconfigure $sf 0 -weight 1 -} - -### Toolbars. -# -proc makeToolbars {} { - set buttons [list open new save] - set checkboxes [list bold italic] - - # - # Tile toolbar: - # - set tb [ttk::frame $::BASE.tbar_styled -class Toolbar] - set i 0 - foreach icon $buttons { - set b [ttk::button $tb.tb[incr i] \ - -text $icon -image $::ICON($icon) -compound $::V(COMPOUND) \ - -style Toolbutton] - grid $b -row 0 -column $i -sticky news - } - ttk::separator $tb.sep -orient vertical - grid $tb.sep -row 0 -column [incr i] -sticky news -padx 2 -pady 2 - foreach icon $checkboxes { - set b [ttk::checkbutton $tb.cb[incr i] \ - -variable ::V($icon) \ - -text $icon -image $::ICON($icon) -compound $::V(COMPOUND) \ - -style Toolbutton] - grid $b -row 0 -column $i -sticky news - } - - ttk::menubutton $tb.compound \ - -text "toolbar" -image $::ICON(file) -compound $::V(COMPOUND) - $tb.compound configure -menu [makeCompoundMenu $tb.compound.menu] - grid $tb.compound -row 0 -column [incr i] -sticky news - - grid columnconfigure $tb [incr i] -weight 1 - - # - # Standard toolbar: - # - set tb [frame $::BASE.tbar_orig -class Toolbar] - set i 0 - foreach icon $buttons { - set b [button $tb.tb[incr i] \ - -text $icon -image $::ICON($icon) -compound $::V(COMPOUND) \ - -relief flat -overrelief raised] - grid $b -row 0 -column $i -sticky news - } - frame $tb.sep -borderwidth 1 -width 2 -relief sunken - grid $tb.sep -row 0 -column [incr i] -sticky news -padx 2 -pady 2 - foreach icon $checkboxes { - set b [checkbutton $tb.cb[incr i] -variable ::V($icon) \ - -text $icon -image $::ICON($icon) -compound $::V(COMPOUND) \ - -indicatoron false \ - -selectcolor {} \ - -relief flat \ - -overrelief raised \ - -offrelief flat] - grid $b -row 0 -column $i -sticky news - } - - menubutton $tb.compound \ - -text "toolbar" -image $::ICON(file) -compound $::V(COMPOUND) \ - -indicatoron true - $tb.compound configure -menu [makeCompoundMenu $tb.compound.menu] - grid $tb.compound -row 0 -column [incr i] -sticky news - - grid columnconfigure $tb [incr i] -weight 1 -} - -# -# Toolbar -compound control: -# -proc makeCompoundMenu {menu} { - variable compoundStrings {text image none top bottom left right center} - menu $menu - foreach string $compoundStrings { - $menu add radiobutton \ - -label [string totitle $string] \ - -variable ::V(COMPOUND) -value $string \ - -command changeToolbars ; - } - return $menu -} - -proc changeToolbars {} { - foreachWidget w [list $::BASE.tbar_styled $::BASE.tbar_orig] { - catch { $w configure -compound $::V(COMPOUND) } - } -} - -makeToolbars - -### Theme control panel. -# -proc makeThemeControl {c} { - ttk::labelframe $c -text "Theme" - foreach {theme name} $::THEMELIST { - set b [ttk::radiobutton $c.s$theme -text $name \ - -variable ::ttk::currentTheme -value $theme \ - -command [list ttk::setTheme $theme]] - pack $b -side top -expand false -fill x - if {[lsearch -exact [package names] ttk::theme::$theme] == -1} { - $c.s$theme state disabled - } - } - return $c -} -makeThemeControl $::BASE.control - -### Notebook widget. -# -set nb [ttk::notebook $::BASE.nb] -ttk::notebook::enableTraversal $nb - -### Main demo pane. -# -# Side-by comparison of Tile vs. core widgets. -# - - -set pw [ttk::panedwindow $nb.client -orient horizontal] -$nb add $pw -text "Demo" -underline 0 -padding 6 -set l [ttk::labelframe $pw.l -text "Themed" -padding 6 -underline 1] -set r [labelframe $pw.r -text "Standard" -padx 6 -pady 6] -$pw add $l -weight 1; $pw add $r -weight 1 - -## menubuttonMenu -- demo menu for menubutton widgets. -# -proc menubuttonMenu {menu} { - menu $menu - foreach dir {above below left right flush} { - $menu add command -label [string totitle $dir] \ - -command [list [winfo parent $menu] configure -direction $dir] - } - $menu add cascade -label "Submenu" -menu [set submenu [menu $menu.submenu]] - $submenu add command -label "Subcommand 1" - $submenu add command -label "Subcommand 2" - $submenu add command -label "Subcommand 3" - $menu add separator - $menu add command -label "Quit" -command [list destroy .] - - return $menu -} - -## Main demo pane - themed widgets. -# -ttk::checkbutton $l.cb -text "Checkbutton" -variable ::V(SELECTED) -underline 2 -ttk::radiobutton $l.rb1 -text "One" -variable ::V(CHOICE) -value 1 -underline 0 -ttk::radiobutton $l.rb2 -text "Two" -variable ::V(CHOICE) -value 2 -ttk::radiobutton $l.rb3 -text "Three" -variable ::V(CHOICE) -value 3 -under 0 -ttk::button $l.button -text "Button" -underline 0 - -ttk::menubutton $l.mb -text "Menubutton" -underline 2 -$l.mb configure -menu [menubuttonMenu $l.mb.menu] - -set ::entryText "Entry widget" -ttk::entry $l.e -textvariable ::entryText -$l.e selection range 6 end - -set ltext [ttk::scrolled text $l.t -width 12 -height 5 -wrap none] - -grid $l.cb -sticky ew -grid $l.rb1 -sticky ew -grid $l.rb2 -sticky ew -grid $l.rb3 -sticky ew -grid $l.button -sticky ew -padx 2 -pady 2 -grid $l.mb -sticky ew -padx 2 -pady 2 -grid $l.e -sticky ew -padx 2 -pady 2 -grid $ltext -sticky news - -grid columnconfigure $l 0 -weight 1 -grid rowconfigure $l 7 -weight 1 ; # text widget (grid is a PITA) - -## Main demo pane - core widgets. -# -checkbutton $r.cb -text "Checkbutton" -variable ::V(SELECTED) -radiobutton $r.rb1 -text "One" -variable ::V(CHOICE) -value 1 -radiobutton $r.rb2 -text "Two" -variable ::V(CHOICE) -value 2 -underline 1 -radiobutton $r.rb3 -text "Three" -variable ::V(CHOICE) -value 3 -button $r.button -text "Button" -menubutton $r.mb -text "Menubutton" -underline 3 -takefocus 1 -$r.mb configure -menu [menubuttonMenu $r.mb.menu] -# Add -indicatoron control: -set ::V(rmbIndicatoron) [$r.mb cget -indicatoron] -$r.mb.menu insert 0 checkbutton -label "Indicator?" \ - -variable ::V(rmbIndicatoron) \ - -command "$r.mb configure -indicatoron \$::V(rmbIndicatoron)" ; -$r.mb.menu insert 1 separator - -entry $r.e -textvariable ::entryText - -set rtext [scrolled text $r.t -width 12 -height 5 -wrap none] - -grid $r.cb -sticky ew -grid $r.rb1 -sticky ew -grid $r.rb2 -sticky ew -grid $r.rb3 -sticky ew -grid $r.button -sticky ew -padx 2 -pady 2 -grid $r.mb -sticky ew -padx 2 -pady 2 -grid $r.e -sticky ew -padx 2 -pady 2 -grid $rtext -sticky news - -grid columnconfigure $r 0 -weight 1 -grid rowconfigure $r 7 -weight 1 ; # text widget - -# -# Add some text to the text boxes: -# - -set cb $::BASE.tbar_orig.cb5 -set txt "checkbutton $cb \\\n" -foreach copt [$cb configure] { - if {[llength $copt] == 5} { - append txt " [lindex $copt 0] [lindex $copt 4] \\\n" - } -} -append txt " ;\n" - -$l.t insert end $txt -$r.t insert end $txt - -### Scales and sliders pane. -# -proc scales.pane {scales} { - ttk::frame $scales - - ttk::panedwindow $scales.pw -orient horizontal - set l [ttk::labelframe $scales.styled -text "Themed" -padding 6] - set r [labelframe $scales.orig -text "Standard" -padx 6 -pady 6] - - ttk::scale $l.scale -orient horizontal -from 0 -to 100 -variable ::V(SCALE) - ttk::scale $l.vscale -orient vertical -from 100 -to 0 -variable ::V(VSCALE) - ttk::progressbar $l.progress -orient horizontal -maximum 100 - ttk::progressbar $l.vprogress -orient vertical -maximum 100 - if {1} { - $l.scale configure -command [list $l.progress configure -value] - $l.vscale configure -command [list $l.vprogress configure -value] - } else { - # This would also work, but the Tk scale widgets - # in the right hand pane cause some interference when - # in autoincrement/indeterminate mode. - # - $l.progress configure -variable ::V(SCALE) - $l.vprogress configure -variable ::V(VSCALE) - } - - $l.scale set 50 - $l.vscale set 50 - - ttk::label $l.lmode -text "Progress bar mode:" - ttk::radiobutton $l.pbmode0 -variable ::V(PBMODE) \ - -text determinate -value determinate -command [list pbMode $l] - ttk::radiobutton $l.pbmode1 -variable ::V(PBMODE) \ - -text indeterminate -value indeterminate -command [list pbMode $l] - proc pbMode {l} { - variable V - $l.progress configure -mode $V(PBMODE) - $l.vprogress configure -mode $V(PBMODE) - } - - ttk::button $l.start -text "Start" -command [list pbStart $l] - proc pbStart {l} { - set ::V(PBMODE) indeterminate; pbMode $l - $l.progress start 10 - $l.vprogress start - } - - ttk::button $l.stop -text "Stop" -command [list pbStop $l] - proc pbStop {l} { - $l.progress stop - $l.vprogress stop - } - - grid $l.scale -columnspan 2 -sticky ew - grid $l.progress -columnspan 2 -sticky ew - grid $l.vscale $l.vprogress -sticky nws - - grid $l.lmode -sticky we -columnspan 2 - grid $l.pbmode0 -sticky we -columnspan 2 - grid $l.pbmode1 -sticky we -columnspan 2 - grid $l.start -sticky we -columnspan 2 - grid $l.stop -sticky we -columnspan 2 - - grid columnconfigure $l 0 -weight 1 - grid columnconfigure $l 1 -weight 1 - - grid rowconfigure $l 99 -weight 1 - - scale $r.scale -orient horizontal -from 0 -to 100 -variable ::V(SCALE) - scale $r.vscale -orient vertical -from 100 -to 0 -variable ::V(VSCALE) - grid $r.scale -sticky news - grid $r.vscale -sticky nws - - grid rowconfigure $r 99 -weight 1 - grid columnconfigure $r 0 -weight 1 - - ## - $scales.pw add $l -weight 1 - $scales.pw add $r -weight 1 - pack $scales.pw -expand true -fill both - - return $scales -} -$nb add [scales.pane $nb.scales] -text Scales -sticky nwes -padding 6 - -### Combobox demo pane. -# -proc combobox.pane {cbf} { - ttk::frame $cbf - set values [list abc def ghi jkl mno pqr stu vwx yz] - pack \ - [ttk::combobox $cbf.cb1 -values $values -textvariable ::COMBO] \ - [ttk::combobox $cbf.cb2 -values $values -textvariable ::COMBO ] \ - -side top -padx 2 -pady 2 -expand false -fill x; - $cbf.cb2 configure -state readonly - $cbf.cb1 current 3 - return $cbf -} -$nb add [combobox.pane $nb.combos] -text "Combobox" -underline 7 - -### Treeview widget demo pane. -# -proc tree.pane {w} { - ttk::frame $w - ttk::scrollbar $w.vsb -command [list $w.t yview] - ttk::treeview $w.t -columns [list Class] \ - -padding 4 \ - -yscrollcommand [list sbset $w.vsb] - - grid $w.t $w.vsb -sticky nwse - grid columnconfigure $w 0 -weight 1 - grid rowconfigure $w 0 -weight 1 - grid propagate $w 0 - - # - # Add initial tree node: - # Later nodes will be added in <> binding. - # - $w.t insert {} 0 -id . -text "Main Window" -open 0 \ - -values [list [winfo class .]] - $w.t heading \#0 -text "Widget" - $w.t heading Class -text "Class" - bind $w.t <> [list fillTree $w.t] - - return $w -} - -# fillTree -- <> binding for tree widget. -# -proc fillTree {tv} { - set id [$tv focus] - if {![winfo exists $id]} { - $tv delete $id - return - } - - # - # Replace tree item children with current list of child windows. - # - $tv delete [$tv children $id] - set children [winfo children $id] - foreach child $children { - $tv insert $id end -id $child -text [winfo name $child] -open 0 \ - -values [list [winfo class $child]] - if {[llength [winfo children $child]]} { - # insert dummy child to show [+] indicator - $tv insert $child end - } - } -} - -$nb add [tree.pane $nb.tree] -text "Tree" -sticky news - -### Other demos. -# -$nb add [ttk::frame $nb.others] -text "Others" -underline 4 - -set Timers(StateMonitor) {} -set Timers(FocusMonitor) {} - -set others $::BASE.nb.others - -ttk::label $others.m -justify left -wraplength 300 -bind ShowDescription { $BASE.nb.others.m configure -text $Desc(%W) } -bind ShowDescription { $BASE.nb.others.m configure -text "" } - -foreach {command label description} { - trackStates "Widget states..." - "Display/modify widget state bits" - - scrollbarResizeDemo "Scrollbar resize behavior..." - "Shows how Tile and standard scrollbars differ when they're sized too large" - - trackFocus "Track keyboard focus..." - "Display the name of the widget that currently has focus" - - repeatDemo "Repeating buttons" - "Demonstrates custom classes (see demos/repeater.tcl)" - -} { - set b [ttk::button $others.$command -text $label -command $command] - set Desc($b) $description - bindtags $b [lreplace [bindtags $b] end 0 ShowDescription] - - pack $b -side top -expand false -fill x -padx 6 -pady 6 -} - -pack $others.m -side bottom -expand true -fill both - - -### Scrollbar resize demo. -# -proc scrollbarResizeDemo {} { - set t .scrollbars - destroy $t - toplevel $t ; wm geometry $t 200x200 - frame $t.f -height 200 - grid \ - [ttk::scrollbar $t.f.tsb -command [list sbstub $t.f.tsb]] \ - [scrollbar $t.f.sb -command [list sbstub $t.f.sb]] \ - -sticky news - - $t.f.sb set 0 0.5 ;# prevent backwards-compatibility mode for old SB - - grid columnconfigure $t.f 0 -weight 1 - grid columnconfigure $t.f 1 -weight 1 - grid rowconfigure $t.f 0 -weight 1 - pack $t.f -expand true -fill both -} - -### Track focus demo. -# -proc trackFocus {} { - global Focus - set t .focus - destroy $t - toplevel $t - wm title $t "Keyboard focus" - set i 0 - foreach {label variable} { - "Focus widget:" Focus(Widget) - "Class:" Focus(WidgetClass) - "Next:" Focus(WidgetNext) - "Grab:" Focus(Grab) - "Status:" Focus(GrabStatus) - } { - grid [ttk::label $t.l$i -text $label -anchor e] \ - [ttk::label $t.v$i -textvariable $variable \ - -width 40 -anchor w -relief groove] \ - -sticky ew; - incr i - } - grid columnconfigure $t 1 -weight 1 - grid rowconfigure $t $i -weight 1 - - bind $t {after cancel $Timers(FocusMonitor)} - FocusMonitor -} - -proc FocusMonitor {} { - global Focus - - set Focus(Widget) [focus] - if {$::Focus(Widget) ne ""} { - set Focus(WidgetClass) [winfo class $Focus(Widget)] - set Focus(WidgetNext) [tk_focusNext $Focus(Widget)] - } else { - set Focus(WidgetClass) [set Focus(WidgetNext) ""] - } - - set Focus(Grab) [grab current] - if {$Focus(Grab) ne ""} { - set Focus(GrabStatus) [grab status $Focus(Grab)] - } else { - set Focus(GrabStatus) "" - } - - set ::Timers(FocusMonitor) [after 200 FocusMonitor] -} - -### Widget states demo. -# -variable Widget .tbar_styled.tb1 - -bind all { TrackWidget %W ; break } - -proc TrackWidget {w} { - set ::Widget $w ; - if {[winfo exists .states]} { - UpdateStates - } else { - trackStates - } -} - -variable states [list \ - active disabled focus pressed selected readonly \ - background alternate invalid] - -proc trackStates {} { - variable states - set t .states - destroy $t; toplevel $t ; wm title $t "Widget states" - - set tf [ttk::frame $t.f] ; pack $tf -expand true -fill both - - ttk::label $tf.info -text "Press Control-Shift-Button-1 on any widget" - - ttk::label $tf.lw -text "Widget:" -anchor e -relief groove - ttk::label $tf.w -textvariable ::Widget -anchor w -relief groove - - grid $tf.info - -sticky ew -padx 6 -pady 6 - grid $tf.lw $tf.w -sticky ew - - foreach state $states { - ttk::checkbutton $tf.s$state \ - -text $state \ - -variable ::State($state) \ - -command [list ChangeState $state] ; - grid x $tf.s$state -sticky nsew - } - - grid columnconfigure $tf 1 -weight 1 - - grid x [ttk::frame $tf.cmd] -sticky nse - grid x \ - [ttk::button $tf.cmd.close -text Close -command [list destroy $t]] \ - -padx 4 -pady {6 4}; - grid columnconfigure $tf.cmd 0 -weight 1 - - bind $t [list event generate $tf.cmd.close <>] - bind $t { after cancel $::Timers(StateMonitor) } - StateMonitor -} - -proc StateMonitor {} { - if {$::Widget ne ""} { UpdateStates } - set ::Timers(StateMonitor) [after 200 StateMonitor] -} - -proc UpdateStates {} { - variable states - variable State - variable Widget - - foreach state $states { - if {[catch {set State($state) [$Widget instate $state]}]} { - # Not a Tile widget: - .states.f.s$state state disabled - } else { - .states.f.s$state state !disabled - } - } -} - -proc ChangeState {state} { - variable State - variable Widget - if {$Widget ne ""} { - if {$State($state)} { - $Widget state $state - } else { - $Widget state !$state - } - } -} - -### Repeating button demo. -# - -proc repeatDemo {} { - set top .repeatDemo - if {![catch { wm deiconify $top ; raise $top }]} { return } - toplevel $top - wm title $top "Repeating button" - #keynav::enableMnemonics $top - - set f [ttk::frame .repeatDemo.f] - ttk::button $f.b -class Repeater -text "Press and hold" \ - -command [list $f.p step] - ttk::progressbar $f.p -orient horizontal -maximum 10 - - ttk::separator $f.sep -orient horizontal - set cmd [ttk::frame $f.cmd] - pack \ - [ttk::button $cmd.close -text Close -command [list destroy $top]] \ - -side right -padx 6; - - pack $f.cmd -side bottom -expand false -fill x -padx 6 -pady 6 - pack $f.sep -side bottom -expand false -fill x -padx 6 -pady 6 - pack $f.b -side left -expand false -fill none -padx 6 -pady 6 - pack $f.p -side right -expand true -fill x -padx 6 -pady 6 - - $f.b configure -underline 0 - $cmd.close configure -underline 0 - bind $top [list event generate $cmd.close <>] - - pack $f -expand true -fill both -} - - -### Command box. -# -set cmd [ttk::frame $::BASE.command] -ttk::button $cmd.close -text Close -underline 0 -command [list destroy .] -ttk::button $cmd.help -text Help -command showHelp - -proc showHelp {} { - if {![winfo exists .helpDialog]} { - ttk::dialog .helpDialog -type ok -message "Tile demo" \ - -detail "Tile version [package provide tile]" - } -} - -grid x $cmd.close $cmd.help -pady 6 -padx 6 -grid columnconfigure $cmd 0 -weight 1 - -## Status bar (to demonstrate size grip) -# -set statusbar [ttk::frame $BASE.statusbar] -pack [ttk::sizegrip $statusbar.grip] -side right -anchor se - -## Accelerators: -# -bind $::ROOT [list event generate $cmd.close <>] -bind $::ROOT <> [list event generate $cmd.help <>] -# keynav::enableMnemonics $::ROOT -# keynav::defaultButton $cmd.help - -### Menubar. -# -set menu [menu $::BASE.menu] -$::ROOT configure -menu $menu -$menu add cascade -label "File" -underline 0 -menu [menu $menu.file] -$menu.file add command -label "Open" -underline 0 \ - -compound left -image $::ICON(open) -$menu.file add command -label "Save" -underline 0 \ - -compound left -image $::ICON(save) -$menu.file add separator -$menu.file add checkbutton -label "Checkbox" -underline 0 \ - -variable ::V(SELECTED) -$menu.file add cascade -label "Choices" -underline 1 \ - -menu [menu $menu.file.choices] -foreach {label value} {One 1 Two 2 Three 3} { - $menu.file.choices add radiobutton \ - -label $label -variable ::V(CHOICE) -value $value -} - -$menu.file insert end separator -if {[tk windowingsystem] ne "x11"} { - $menu.file insert end checkbutton -label Console -underline 5 \ - -variable ::V(CONSOLE) -command toggleconsole - proc toggleconsole {} { - if {$::V(CONSOLE)} {console show} else {console hide} - } -} -$menu.file add command -label "Exit" -underline 1 \ - -command [list event generate $cmd.close <>] - -# Add Theme menu. -# -proc makeThemeMenu {menu} { - menu $menu - foreach {theme name} $::THEMELIST { - $menu add radiobutton -label $name \ - -variable ::ttk::currentTheme -value $theme \ - -command [list ttk::setTheme $theme] - if {[lsearch -exact [package names] ttk::theme::$theme] == -1} { - $menu entryconfigure end -state disabled - } - } - return $menu -} - -$menu add cascade -label "Theme" -underline 3 -menu [makeThemeMenu $menu.theme] - -### Main window layout. -# - -pack $BASE.statusbar -side bottom -expand false -fill x -pack $BASE.command -side bottom -expand false -fill x -pack $BASE.tbar_styled -side top -expand false -fill x -pack $BASE.tbar_orig -side top -expand false -fill x -pack $BASE.control -side left -expand false -fill y -padx 6 -pady 6 -pack $BASE.nb -side left -expand true -fill both -padx 6 -pady 6 - -wm title $ROOT "Tile demo" -wm iconname $ROOT "Tile demo" -update; wm deiconify $ROOT - -## Test the theme configuration panel... -namespace eval ttk::theme::tilegtk { - if {0 && ![info exists ::testConfigurationPanel]} { - toplevel .themeConfPanel - wm withdraw .themeConfPanel - wm title .themeConfPanel "TileGtk Configuration Panel..." - frame .themeConfPanel.page - createThemeConfigurationPanel .themeConfPanel.page - update - pack .themeConfPanel.page -fill both -expand 1 - wm deiconify .themeConfPanel - } -} diff --git a/demos/dirbrowser.tcl b/demos/dirbrowser.tcl deleted file mode 100644 index b2fc4af..0000000 --- a/demos/dirbrowser.tcl +++ /dev/null @@ -1,168 +0,0 @@ -# -# $Id: dirbrowser.tcl,v 1.2 2010/09/30 13:44:44 petasis Exp $ -# -# treeview widget demonstration. -# -# - -lappend auto_path ../generic .. -if {[catch {package require Ttk}]} { - package require tile -} - -# Create a treeview widget: -# -set f [ttk::frame .f] -ttk::scrollbar $f.vsb -orient vertical -command [list $f.tv yview] - -set tv [ttk::treeview $f.tv -columns {size mtime} \ - -yscrollcommand [list $f.vsb set] ] - -grid $f.tv $f.vsb -sticky news -grid columnconfigure $f 0 -weight 1 -grid rowconfigure $f 0 -weight 1 - -# -# Set column headings: -# -# Column #0 is the tree colum. -# -$tv heading #0 -text "Name" -command [list sortBy $tv #0] -$tv heading size -text "Size" -command [list sortBy $tv size] -$tv heading mtime -text "Modified" -command [list sortBy $tv mtime] - -$tv column size -anchor e -$tv column mtime -anchor e - -# -# Create some images to use as tree icons: -# (images taken from tkfbox.tcl) -# - -foreach {icon data} { - folder {R0lGODlhEAAMAKEAAAD//wAAAPD/gAAAACH5\ - BAEAAAAALAAAAAAQAAwAAAIghINhyycvVFsB\ - GtkmS3rjaH1Hg141WaT5ouprt2HHcUgAAOw==} - file {R0lGODlhDAAMAKEAALLA3AAAAP//8wAAACH5\ - BAEAAAAALAAAAAAMAAwAAAIgRI4Ha+IfWHsO\ - rSASvJTGhnhcV3EJlo3kh53ltF5nAhQAOw==} -} { - set Icons($icon) [image create photo -data $data] -} - -# scanDirectory -- -# Scan a directory and add items to the treeview widget. -# -# To prevent a long initial delay, subdirectories are -# scanned "on demand" in the <> binding. -# The "Pending" array holds a script to be evaluated -# when an item is first opened. -# -proc scanDirectory {tv parent dir} { - variable Icons - variable Pending - - foreach subdir [glob -nocomplain -type d -directory $dir *] { - set item [$tv insert $parent end \ - -text [file tail $subdir] -image $Icons(folder) \ - -values [list {} [datestamp [file mtime $subdir]] ] ] - set Pending($item) [list scanDirectory $tv $item $subdir] - } - foreach file [glob -nocomplain -type f -directory $dir *] { - - set item [$tv insert $parent end \ - -text [file tail $file] -image $Icons(file)] - - $tv set $item size [file size $file] - $tv set $item mtime [datestamp [file mtime $file]] - } -} - -bind $tv <> { itemOpened %W } - -proc itemOpened {w} { - variable Pending - set item [$w focus] - if {[info exists Pending($item)]} { - uplevel #0 $Pending($item) - unset Pending($item) - } -} - -# scanAll -- -# Force the tree to be fully populated, by repeatedly -# evaluating the contents of the Pending array. -# -proc scanAll {} { - variable Pending - . configure -cursor watch - while {[llength [set pending [array get Pending]]]} { - array unset Pending - foreach {_ script} $pending { uplevel #0 $script } - } - . configure -cursor {} -} - -# openAll -- -# Recursively open all nodes in the tree. -# -proc openAll {tv {item {}}} { - foreach child [$tv children $item] { - $tv item $child -open true - openAll $tv $child - } -} - -# datestamp -- -# Convert clock values to a human-readable format -# -proc datestamp {clockValue} { - variable clockfmt "%Y-%m-%d %H:%M" - clock format $clockValue -format $clockfmt -} - -# sortBy -- -# Sort the children of each item by the specified column, -# or by the -text label if $column is {}. -# -proc sortBy {tv column {parent {}}} { - foreach child [$tv children $parent] { - sortBy $tv $column $child - } - set items [list] - if {$column eq "#0"} { - # Sort by -text label: - foreach child [$tv children $parent] { - lappend items [list $child [$tv item $child -text]] - } - } else { - foreach child [$tv children $parent] { - lappend items [list $child [$tv set $child $column]] - } - } - - set children [list] - foreach item [lsort -dictionary -index 1 $items] { - lappend children [lindex $item 0] - } - $tv children $parent $children -} - -# Rest of GUI. -# -set cmd [ttk::frame .cmd] -grid x \ - [ttk::button $cmd.open -text "Open all" -command [list openAll $tv]] \ - [ttk::button $cmd.scan -text "Scan all" -command {scanAll} ] \ - [ttk::button $cmd.close -text "Close" -command [list destroy .]] \ - -padx 6 ; -grid columnconfigure $cmd 0 -weight 1 - -bind . [list event generate $cmd.close <>] - -pack $cmd -side bottom -expand false -fill x -padx 6 -pady 6 -pack $f -side top -expand true -fill both - -# Load the initial directory: -# -scanDirectory $tv {} ~ diff --git a/demos/dlgtest.tcl b/demos/dlgtest.tcl deleted file mode 100644 index 9714e3d..0000000 --- a/demos/dlgtest.tcl +++ /dev/null @@ -1,101 +0,0 @@ -# -# test/demo script for dialog.tcl -# - -if {[catch {package require Ttk}]} { - package require tile -} - -catch {package require tile::theme::*} - -array set DLG { - icon question - title "Quit..." - message "Are you sure you want to quit?" - detail "Quitting the application will cause it to stop running. \ - You will lose any unsaved data, and make the application \ - feel unloved. Please consider leaving it open." -} - -proc displayDialog {} { - variable DLG - - if {[winfo exists .dlg]} { ttk::dialog::dismiss .dlg } - - ttk::dialog .dlg \ - -icon $DLG(icon) \ - -title $DLG(title) \ - -message $DLG(message) \ - -detail $DLG(detail) \ - -type yesnocancel \ - -default yes \ - -cancel cancel \ - ; - - if {0} { - set f [ttk::dialog::clientframe .dlg] - pack [ttk::progressbar $f.progress -value 50] -expand false -fill x - tile::progressbar::start $f.progress - } -} - -# displayMessageBox -- -# Display standard Tk mesageDialog, for comparison. -# -proc displayMessageBox {} { - variable DLG - tk_messageBox -parent . \ - -type yesnocancel \ - -icon $DLG(icon) \ - -title $DLG(title) \ - -message $DLG(message) \ - -detail $DLG(detail) \ - -default yes \ - ; -} - - -proc dialogDemo {t} { - variable DLG - - ttk::frame $t - set f [ttk::frame $t.f] - foreach field {title message detail} { - grid \ - [ttk::label $f.l$field -text "[string totitle $field]:" -anchor e] \ - [ttk::entry $f.$field -textvariable ::DLG($field) -width 60] \ - -sticky new -padx 3 - } - - grid \ - [ttk::label $f.licon -text "Icon:" -anchor e] \ - [ttk::combobox $f.icon -state readonly -textvariable DLG(icon) \ - -values [list info question warning error]] \ - -sticky new -padx 3 - - grid columnconfigure $f 0 -weight 1 - grid columnconfigure $f 1 -weight 5 - grid rowconfigure $f 99 -weight 1 - - set cmd [ttk::frame $t.cmd] - grid x \ - [ttk::button $cmd.go -text "Display" -command displayDialog] \ - [ttk::button $cmd.alt -text "Message" -command displayMessageBox] \ - [ttk::button $cmd.quit -text "Close" \ - -command [list destroy [winfo toplevel $t]]] \ - -padx [list 6 0] -pady 6 -sticky ew; - grid columnconfigure $cmd 0 -weight 1 - bind . [list event generate $cmd.quit <>] - keynav::defaultButton $cmd.go - - pack $t.cmd -side bottom -expand false -fill x -padx 6 -pady 6 - pack $t.f -side top -expand true -fill both -padx 12 -pady 12 - - return $t -} - -proc dlgtest-main {} { - pack [dialogDemo .t] -expand true -fill both -} - -if {[info exists argv0] && $argv0 eq [info script]} { dlgtest-main } diff --git a/demos/iconlib.tcl b/demos/iconlib.tcl deleted file mode 100644 index 4386a79..0000000 --- a/demos/iconlib.tcl +++ /dev/null @@ -1,110 +0,0 @@ -array set ImgData { -bold {R0lGODlhEAAQAJEAANnZ2QAAAP///////yH5BAEAAAAALAAAAAAQABAAAAI6hI+py60U3wj+ -RYQFJYRvEWFBCeFbRFhQQvhG8YPgX0RYUEL4FhEWlBC+RYQFJYQPFN8IPqYut/8hBQA7} -copy {R0lGODlhEAAQAJEAANnZ2QAAAP///wAAhCH5BAEAAAAALAAAAAAQABAAAAJUhI8JFJ/gY4iI -UEL4FyIiFIXgW0iEUDgfACBI9pzMAAGRiIghWSMDECR7JEKGtkFIRFBG+TIQKDQxtgzcDcmX -IfgwQrFlCD4MyZch+EDzj+Bj6mYBADs=} -cut {R0lGODlhEAAQAJEAANnZ2QAAAAAAhP///yH5BAEAAAAALAAAAAAQABAAAAJFhI+pcUHwEeIi -E0gACIKPEAFBIXy0gMg8EhM+YmQiKSL4eAIiJMI/EQEhQGYGYiQIQAg+iAkIATIzECMBIgT/ -RBARERlSADs=} -dragfile {R0lGODlhGAAYAKIAANnZ2TMzM////wAAAJmZmf///////////yH5BAEAAAAALAAAAAAYABgA -AAPACBi63IqgC4GiyxwogaAbKLrMgSKBoBoousyBogEACIGiyxwoKgGAECI4uiyCExMTOACB -osuNpDoAGCI4uiyCIkREOACBosutSDoAgSI4usyCIjQAGCi63Iw0ACEoOLrMgiI0ABgoutyM -NAAhKDi6zIIiNAAYKLrcjDQAISg4usyCIjQAGCi63Iw0AIGiiqPLIyhCA4CBosvNSAMQKKo4 -ujyCIjQAGCi63Iw0AIGiy81IAxCBpMu9GAMAgKPL3QgJADs=} -dragicon {R0lGODlhGAAYALMAANnZ2TMzM/////8zM8zMzGYAAAAAAJmZmQCZMwAzZgCZzGZmZv////// -/////////yH5BAEAAAAALAAAAAAYABgAAAT/EMAgJ60SAjlBgEJOSoMIEMgZoJCT0iADBFIG -KOSkNMwAAABhwiHnIEKIIIQQAQIZhBBwyDmKEMIEE0yABoAghIBDzlGEENDIaQAIQgg45BwF -CinPOccAECYcUiKEEBFCiHPgMQAEIcQYYyABBUGIQCHlMQCEScZAAhKEEApCECGOARAEIQQp -BRGIpAyCJCGOASBAISdEcqJAVBLiGABggELOAJGUKyiVhDgGABigkJMEhNAKSqkEhTgGgCCl -FCQEGIJSSiUhjgEgQCEnJVBJmYQ4BoAAhZyTQCVnEuIYAAIUckoCk5xSiGMACFDISSs9BoBg -rRXQMQAEKOSklR4DEUAI8MhJ6wwGAACgkZNWCkAEADs=} -error {R0lGODlhIAAgAKIAANnZ2YQAAP8AAISEhP///////////////yH5BAEAAAAALAAAAAAgACAA -AAP/CLoMGLqKoMvtGIqiqxEYCLrcioGiyxwIusyBgaLLLRiBoMsQKLrcjYGgu4Giy+2CAkFX -A0WX2wXFIOgGii7trkCEohsDCACBoktEKLpKhISiGwAIECiqSKooukiqKKoxgACBooukKiIo -SKooujGDECi6iqQqsopEV2MQAkV3kXQZRXdjEAJFl5F0FUWXY3ACRZcFSRdFlyVwJlB0WZB0 -UXRZAmcCRZeRdBVFl2NwAkV3kXQZRXdjcAJFV5FURVaR6GoMDgSKLpKqiKAgqaLoxgwOBIoq -kiqKLpIqimrM4ECg6BIRiq4SIaHoxgyCBoou7a5AhKIbMzgAAIGiy+2CTWJmBhAAAkWX2wXF -zCDoBooud2PMDIKuRqDocgtGzMwg6O4Eii5z4Kgi6DIMhqLoagQGjiqCLvPgYOgqji6CLrfi -6DIj6HI7jq4i6DIkADs=} -file {R0lGODlhCwANAJEAANnZ2QAAAP///////yH5BAEAAAAALAAAAAALAA0AAAIyhI9G8Q0AguSH -AMQdxQgxEyEFQfItICQokYgEBMm3gBCKLRIQJN8CQii2SECQfAug+FgAOw==} -folder {R0lGODlhEAANAKIAANnZ2YSEhMbGxv//AP///wAAAP///////yH5BAEAAAAALAAAAAAQAA0A -AANjCIqhiqDLITgyEgi6GoIjIyMYugCBpMsaWBA0giMjIzgyUYBBMjIoIyODEgVBODIygiMj -E1gQJIMyMjIoI1GAQSMjODIyghMFQSgjI4MyMhJYEDSCIyMjODJRgKHLXAiApcucADs=} -hourglass {R0lGODlhIAAgAKIAANnZ2YAAAAAAAP8AAP///8DAwICAgP///yH5BAEAAAAALAAAAAAgACAA -AAPZCLrc/jDKSau9OGcUuqyCoMvNGENVhaMrCLrcjaLLgqDL7WhFVIVVZoKgy+1oRUSFVWaC -oMvtaEVEhVVmgqDL7WhFRIVVZoKgy+1oVVaCJWaCoMvtgKxISrBMEHS5fZEVSRkKgi63NzIq -EwRdbndkVCYIutzeyIqqDAVBl9sXWRFJYZkg6HI7ICsiKqwyEwRdbkcrIhKsMhMEXW5HKyIp -lDITBF1uRysyEiwxEwRdbkcrIyuUEhMEXW5H0WVB0OVujKGqwtEVBF1uRtHlRdDl9odRTlrt -xRmjBAA7} -info {R0lGODlhIAAgAKIAANnZ2YSEhMbGxv///wAA/wAAAP///////yH5BAEAAAAALAAAAAAgACAA -AAP/CLoMGLqKoMvtGCo4uhKBgaDLDRghOLqsghEIuryBgqPLPSiBoMsQOLojhEQkOLpTCLob -OLqKpIujq4WgC4Gju0i6OLpbCKohOLorhEQkOLorhaAQOLrc3qgCIARHl9sbSQUEji4j6RKO -Lk9hQODosiKp4ujyFIbi6LIiqeLo8hSG4uiyIqni6PIUhuLosiKp4ujyFIYKji4PkiqOLkth -BASOLg+SKo4uV2AEhODoMpIqju5KYShA4Ogqku7i6E4FRgAAYOHocvugiohAUC0cXe7GiohA -0IUSHF3uQamICATdrULB0WUVrIqIQNBlCCwVHF2pwsJQRdDlDYyoKsHRPMLQDQRdbsDQqBmc -wlBF0OV2jJqZwggEXW5vVDMVgaDL7Y5qKgJBl9sfVUUg6HL7AxSKoMvtr1AEgi5DAgA7} -italic {R0lGODlhEAAQAJEAANnZ2QAAAP///////yH5BAEAAAAALAAAAAAQABAAAAIrhI+py+1A4hN8 -hIjINBITPlpEZBqJCR8tIjKNxISPFhGZQOITfExdbv9FCgA7} -new {R0lGODlhEAAQAJEAANnZ2QAAAP///////yH5BAEAAAAALAAAAAAQABAAAAJFhI95FN8IvgXJ -jyD4ECQ/JAh+kPyICIIdJP+CYAfJvyDYQfIvCHaQ/AuCHST/gmAHyb8g2EHyLwh2kPwLgk3x -MQg+pu4WADs=} -open {R0lGODlhEAAQAKIAANnZ2QAAAP//AP///4SEAP///////////yH5BAEAAAAALAAAAAAQABAA -AANZCLrczigUQZc1EDQgEHSZAwMgIhB0NQIDQkYwdANBNUZwZGQEJxBUQwZlZGRQAkE1RnAE -Q5dVcCSQdDcAYySQdDcAISSQdDcAASKQdDcAAQBDlwNBl9sfApQAOw==} -openfold {R0lGODlhEAANAKIAANnZ2YSEhP///8bGxv//AAAAAP///////yH5BAEAAAAALAAAAAAQAA0A -AANgCIqhiqDLgaIaCLoagkNDIxi6AIFCQ0M4KKpRgCFDQzg0NIGTKhaHLSxgVKLochRMVMkhD -Q4M0VBFYEDKEQ0NDOFFRgCE0NEhDQ4MVBRAoNDSEQ0NRWAAYuqyFBQBYurwJADs=} -overstrike {R0lGODlhEAAQAJEAANnZ2QAAAP///////yH5BAEAAAAALAAAAAAQABAAAAI3hI+py80Uh+Aj -RFhQCP8iMILgWwRGEHyLwAiCbxEYQfCB4iPBhwiMIPgXYREEHyEiguBj6nI7FQA7} -palette {R0lGODlhEAAQAKIAANnZ2QAAAP//AP////8A/4QAhP8AAAD//yH5BAEAAAAALAAAAAAQABAA -AANtCLrcjqGBoMsRKCMTgaALMSgDAYMSCKoxgAFBITgSAIAQEhUIARCAEgAQOBAwghMQEwga -MoIjIxAIEgCAEBEyKBAgg4GgGxAIYTGCgaALcRgQIIGgCwEYICODgaALITgyEoGguxiqCLrc -/lChBAA7} -passwd {R0lGODlhIAAgAMQAANnZ2QAAAICAgICAAP///7CwsMDAwMjIAPjIAOjo6Pj4AODg4HBwcMj4 -ANjY2JiYANDQ0MjIyPj4yKCgoMiYAMjImDAwAMjIMJiYmJCQkP////////////////////// -/yH5BAEAAAAALAAAAAAgACAAAAX/ICCOIhiIIgiII1maZSCMQnCeJyAIQiAIAiAMwxCcJwkk -EAQRCIUwGMSBDEEAAuJIlgKRJEEgGAMRBIGiDENQlqNAJAsYCEwgEEEgBAHSIEMAAuJIAgKR -LEsgGEMgCEJgBMqhHENQlgJILMsSCMRABEFgGAESHMcRgIA4kgKxOIsTBAOhKAITKEGDHMhD -kqIAEqAjisJAgIooBkpwNMcTgIA4jgLhOBAkEAOhKIoSKEGDIMcTkKQICgQEQQIxEIqiBEpw -IMdxPAEIiCMJCEQUMUQ0EIqiHIfSIM3xBGUpCiABCUQyEMqhHMiBHMjxBCAgjuQoEAKxRANB -HMqhHM1x/zxDUJajQIACsUTDQBAEIR3IcQRDAALiSIoCYQiEE03gII7HQR3BEICAOJICYRSC -QDjRNE1CAAzVQR3WE5AkAAqEUQiFQEARBAUAAAzHQR3BEICAOI4CUQhFIBAREwXjUFUHdQRD -QJJAABbCFAhEJBgBAADAMAwXdQRDAALiCAhEIRQCYRiCEZDjUFFHMAQkIBAFOAmTQBiFUAQg -II7AUFXUEQwBCQjEJExBkBRCEZCjMIBD9RxDAALiGEzCFBBYIRTBOI7AQB1DMIoCMQkYGAjL -JEwBCIgjOVDDEJCAQGACJiTTJEwBSY5BEJAiSCCwTAiCZBKmAATEkSzNQBCCYCDBJgELTNMk -g0AMEgwTAhAQR7I0zYARgvM8TyAIznMMAQA7} -paste {R0lGODlhEAAQAKIAANnZ2QAAAP//AISEAISEhP///wAAhP///yH5BAEAAAAALAAAAAAQABAA -AANwCLrcjqGBoKsYqiKrCDSGBkMiJJCGAgCDKBB0gwYDIKYwdJUIAyBokIaGBmloAhBiaAgH -TdcCEIKGBsmwVM0AIYaGcAxL1coQgoYGySoisMzMAoeGxrB01QJpaMiwMHTLAEPVsHTVEHTR -dBlBlxswAQA7} -print {R0lGODlhEAAQAKIAANnZ2QAAAP///4SEhP//AP///////////yH5BAEAAAAALAAAAAAQABAA -AANZCLrcjqG7CLqBoquBoBuCoSqBoBsouhoIuiEYqrKBoIGiqwEYEIChyxAIEYGgywEYgKHL -DAgRCLozgwABARgIukSEABEBGLq8gAEQCLobgAEAgKHLgaDLzZgAOw==} -question {R0lGODlhIAAgAKIAANnZ2YSEhMbGxv///wAAAAAA/////////yH5BAEAAAAALAAAAAAgACAA -AAP/CLoMGLqKoMvtGCo4uhKBgaDLDRghOLqsghEIuryBgqPLPSiBoMsQOLrcjYSgu4GjO4Kl -Kzi6Qwi6EDi6I4UyU1VYgqM7hKAagqM7VTg6VYWFoztCCAqBo6tVWDVThVU4ukqBACE4ulqF -VSNVWIWjq0IYEDi6K4UlU1VYOLpMgRA4uryCpTi6PIShOLq8hVU4uqyEoTi6vIUlOLqshKE4 -uryFhaPLSxgqOLrc3kgoAgJHl0ewSnB0eQhDIQRHl6uwCkeXhTAUIHB0uQqrcHSZAiMAAJBw -dFcKS3B0lwIjAkGVcHS5GykiAkEXSHB0uQeFIiIQdJcIBUeXVZAoIgJBT5chkFRwdIUICUMV -QZc3MIKIBEcJQzcQdLkBQ4NmcAhDFUGX2zFoZggjEHS5vRHNUASCLrc7oqEIBF1uf0QUgaDL -7Q9QKIIut79CEQi6DAkAOw==} -redo {R0lGODlhEAAQAJEAANnZ2QAAhP///////yH5BAEAAAAALAAAAAAQABAAAAIvhI+py+1vSByC -jxAYQXDMwsyAggQAQBB8iwgMgg8REQgUwqbYBDsIPqYutz+MgBQAOw==} -save {R0lGODlhEAAQAJEAANnZ2QAAAISEAP///yH5BAEAAAAALAAAAAAQABAAAAJWhI9pFB8RIIRC -+BYQFqQQvkWEBSmEbyFhQQrhW0hYkEL4FhIWpBC+hYQFSYxvIgFAoXy0AAiSGP8kAIIkxgcI -CSBEQvEBQgIIkVB8gJAAAhgfj+BjWgEAOw==} -underline {R0lGODlhEAAQAJEAANnZ2QAAAP///////yH5BAEAAAAALAAAAAAQABAAAAI3hI+py60UBy4I -vkVcBMG/iIsg+BdxEGTK/Ii6C4F/ERRD8i7gIgn8RF0HwkWITfExFin8EH1OXCwA7} -undo {R0lGODlhEAAQAJEAANnZ2QAAhP///////yH5BAEAAAAALAAAAAAQABAAAAIuhI+py+2vSByC -HxdxQCHsCIg7oAAAEUHwLTAiKIQPgRSbYMfd3VEIH1OX2x8mUgA7} -warning {R0lGODlhIAAgAKIAANnZ2YSEAP//AMbGxgAAAISEhP///////yH5BAEAAAAALAAAAAAgACAA -AAP/CLq8gREIutz+KESGEHS5vVGIiAxSIehy+6JAUaUqBF1uBxQoukOFhaDL7RgoukKFhaDL -3RgoujqEVQi63IyBortUWAi63IuBostDWIWgy60YIjKERCMiSFUIutyAISKCpCoiOFSFoMsd -KCpIqiKCQlUIusyBooqkKiIoQ1UIuryBooqkiqJKVQi6rIGii6SKojpUWAi6DIGiG0RIgaJL -VQi6HCi6MoREg6I7VFgIuhsoukqEhKKrVFgIuhoouhuEgaKrQ1iFoAuBortDOCi6S4WFoBso -uiyEostDWIWgGii63K6IqgAAIVB0WQaJBkV3h7AKAAJFl4WQiFB0mQoLRyBQdFkJiQhFl4ew -CgJFl3WQaFB0WQirIFB0ud0RVVWg6HJ7o6GqAgwUXW5fNFRVhQCBpMvti0oVABCwdLndEehi -6XI7I4AEADs=} -} diff --git a/demos/repeater.tcl b/demos/repeater.tcl deleted file mode 100644 index d54248c..0000000 --- a/demos/repeater.tcl +++ /dev/null @@ -1,117 +0,0 @@ -# -# $Id: repeater.tcl,v 1.1 2008/08/03 14:52:09 petasis Exp $ -# -# Demonstration of custom classes. -# -# The Tile button doesn't have built-in support for autorepeat. -# Instead of adding -repeatdelay and -repeatinterval options, -# and all the extra binding scripts required to deal with them, -# we create a custom widget class for autorepeating buttons. -# -# Usage: -# ttk::button .b -class Repeater [... other options ...] -# -# TODO: -# Use system settings for repeat interval and initial delay. -# -# Notes: -# Repeater buttons work more like scrollbar arrows than -# Tk repeating buttons: they fire once immediately when -# first pressed, and $State(delay) specifies the initial -# interval before the button starts autorepeating. -# - -namespace eval tile::Repeater { - variable State - set State(timer) {} ;# [after] id of repeat script - set State(interval) 100 ;# interval between repetitions - set State(delay) 300 ;# delay after initial invocation -} - -### Class bindings. -# - -bind Repeater { %W state active } -bind Repeater { %W state !active } - -bind Repeater { tile::Repeater::Activate %W } -bind Repeater <> { tile::Repeater::Activate %W } - -bind Repeater { tile::Repeater::Press %W } -bind Repeater { tile::Repeater::Release %W } -bind Repeater { tile::Repeater::Pause %W } -bind Repeater { tile::Repeater::Resume %W } ;# @@@ see below - -# @@@ Workaround for metacity-induced bug: -bind Repeater \ - { if {"%d" ne "NotifyUngrab"} { tile::Repeater::Resume %W } } - -### Binding procedures. -# - -## Activate -- Keyboard activation binding. -# Simulate clicking the button, and invoke the command once. -# -proc tile::Repeater::Activate {w} { - $w instate disabled { return } - set oldState [$w state pressed] - update idletasks; after 100 - $w state $oldState - after idle [list $w invoke] -} - -## Press -- ButtonPress-1 binding. -# Invoke the command once and start autorepeating after -# $State(delay) milliseconds. -# -proc tile::Repeater::Press {w} { - variable State - $w instate disabled { return } - $w state pressed - $w invoke - after cancel $State(timer) - set State(timer) [after $State(delay) [list tile::Repeater::Repeat $w]] -} - -## Release -- ButtonRelease binding. -# Stop repeating. -# -proc tile::Repeater::Release {w} { - variable State - $w state !pressed - after cancel $State(timer) -} - -## Pause -- B1-Leave binding -# Temporarily suspend autorepeat. -# -proc tile::Repeater::Pause {w} { - variable State - $w state !pressed - after cancel $State(timer) -} - -## Resume -- B1-Enter binding -# Resume autorepeat. -# -proc tile::Repeater::Resume {w} { - variable State - $w instate disabled { return } - $w state pressed - $w invoke - after cancel $State(timer) - set State(timer) [after $State(interval) [list tile::Repeater::Repeat $w]] -} - -## Repeat -- Timer script -# Invoke the command and reschedule another repetition -# after $State(interval) milliseconds. -# -proc tile::Repeater::Repeat {w} { - variable State - $w instate disabled { return } - $w invoke - set State(timer) [after $State(interval) [list tile::Repeater::Repeat $w]] -} - -#*EOF* diff --git a/demos/toolbutton.tcl b/demos/toolbutton.tcl deleted file mode 100644 index 3f5171f..0000000 --- a/demos/toolbutton.tcl +++ /dev/null @@ -1,101 +0,0 @@ -# -# $Id: toolbutton.tcl,v 1.1 2008/08/03 14:52:09 petasis Exp $ -# -# Demonstration of custom widget styles. -# - -# -# ~ BACKGROUND -# -# Checkbuttons in toolbars have a very different appearance -# than regular checkbuttons: there's no indicator, they -# "pop up" when the mouse is over them, and they appear sunken -# when selected. -# -# Tk added partial support for toolbar-style buttons in 8.4 -# with the "-overrelief" option, and TIP #82 added further -# support with the "-offrelief" option. So to get a toolbar-style -# checkbutton, you can configure it with: -# -# checkbutton .cb \ -# -indicatoron false -selectcolor {} -relief flat -overrelief raised -offrelief flat -# -# Behind the scenes, Tk has a lot of rather complicated logic -# to implement this checkbutton style; see library/button.tcl, -# generic/tkButton.c, and the platform-specific files unix/tkUnixButton.c -# et al. for the full details. -# -# The tile widget set has a better way: custom styles. -# Since the appearance is completely controlled by the theme engine, -# we can define a new "Toolbutton" style and just use: -# -# checkbutton .cb -style Toolbutton -# -# -# ~ DEMONSTRATION -# -# The tile built-in themes (default, "alt", windows, and XP) -# already include Toolbutton styles. This script will add -# them to the "step" theme as a demonstration. -# -# (Note: Pushbuttons and radiobuttons can also use the "Toolbutton" -# style; see demo.tcl.) -# - -ttk::style theme settings "default" { - -# -# First, we use [ttk::style layout] to define what elements to -# use and how they're arranged. Toolbuttons are pretty -# simple, consisting of a border, some internal padding, -# and a label. (See also the TScrollbar layout definition -# in demos/blue.tcl for a more complicated layout spec.) -# - ttk::style layout Toolbutton { - Toolbutton.border -children { - Toolbutton.padding -children { - Toolbutton.label - } - } - } - -# (Actually the above isn't strictly necessary, since the same layout -# is defined in the default theme; we could have inherited it -# instead.) -# -# Next, specify default values for element options. -# For many options (like -background), the defaults -# inherited from the parent style are sufficient. -# - ttk::style configure Toolbutton \ - -width 0 -padding 1 -relief flat -borderwidth 2 - -# -# Finally, use [ttk::style map] to specify state-specific -# resource values. We want a flat relief if the widget is -# disabled, sunken if it's selected (on) or pressed, -# and raised when it's active (the mouse pointer is -# over the widget). Each state-value pair is checked -# in order, and the first matching state takes precedence. -# - ttk::style map Toolbutton -relief { - disabled flat - selected sunken - pressed sunken - active raised - } -} - -# -# ~ A final note: -# -# TIP #82 also says: "When -indicatoron is off and the button itself -# is on, the relief continues to be hard-coded to sunken. For symmetry, -# we might consider adding another -onrelief option to cover this -# case. But it is difficult to imagine ever wanting to change the -# value of -onrelief so it has been omitted from this TIP. -# If there as strong desire to have -onrelief, it can be added later." -# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -# -# The Tile project aims to make sure that this never needs to happen. -# diff --git a/example.py b/example.py new file mode 100644 index 0000000..45178ee --- /dev/null +++ b/example.py @@ -0,0 +1,94 @@ +""" +Author: RedFantom +License: GNU GPLv3 +Copyright (c) 2018-2020 RedFantom +""" +import os +import sys +import tkinter as tk +from tkinter import ttk + + +class Example(tk.Tk): + """Example that is used to create screenshots for new themes""" + def __init__(self): + tk.Tk.__init__(self) + # Create widgets + self.menu = tk.Menu(self, tearoff=False) + self.sub_menu = tk.Menu(self.menu, tearoff=False) + self.sub_menu.add_command(label="Exit", command=self.destroy) + self.menu.add_cascade(menu=self.sub_menu, label="General") + self.config(menu=self.menu) + self.label = ttk.Label(self, text="This is an example label.") + self.dropdown = ttk.OptionMenu(self, tk.StringVar(), "First value", "Second Value") + self.entry = ttk.Entry(self, textvariable=tk.StringVar(value="Default entry value.")) + self.button = ttk.Button(self, text="Button") + self.radio_one = ttk.Radiobutton(self, text="Radio one", value=True) + self.radio_two = ttk.Radiobutton(self, text="Radio two", value=False) + self.scroll = ttk.Scrollbar(self, orient=tk.VERTICAL) + self.checked = ttk.Checkbutton(self, text="Checked", variable=tk.BooleanVar(value=True)) + self.unchecked = ttk.Checkbutton(self, text="Unchecked") + self.tree = ttk.Treeview(self, height=4, show=("tree", "headings")) + self.setup_tree() + self.progress = ttk.Progressbar(self, maximum=100, value=50) + self.bind("", self.screenshot) + # Grid widgets + self.grid_widgets() + + def setup_tree(self): + """Setup an example Treeview""" + self.tree.insert("", tk.END, text="Example 1", iid="1") + self.tree.insert("", tk.END, text="Example 2", iid="2") + self.tree.insert("2", tk.END, text="Example Child") + self.tree.heading("#0", text="Example heading") + + def grid_widgets(self): + """Put widgets in the grid""" + sticky = {"sticky": "nswe"} + self.label.grid(row=1, column=1, columnspan=2, **sticky) + self.dropdown.grid(row=2, column=1, **sticky) + self.entry.grid(row=2, column=2, **sticky) + self.button.grid(row=3, column=1, columnspan=2, **sticky) + self.radio_one.grid(row=4, column=1, **sticky) + self.radio_two.grid(row=4, column=2, **sticky) + self.checked.grid(row=5, column=1, **sticky) + self.unchecked.grid(row=5, column=2, **sticky) + self.scroll.grid(row=1, column=3, rowspan=8, padx=5, **sticky) + self.tree.grid(row=6, column=1, columnspan=2, **sticky) + self.progress.grid(row=9, column=1, columnspan=2, padx=5, pady=5, **sticky) + + def screenshot(self, *args): + """Take a screenshot, crop and save""" + try: + from PIL import Image + from mss import mss + except ImportError: + print("Taking a screenshot requires additional packages: 'pillow' and 'mss'") + raise + if not os.path.exists("screenshots"): + os.makedirs("screenshots") + box = { + "top": self.winfo_y(), + "left": self.winfo_x(), + "width": self.winfo_width(), + "height": self.winfo_height() + } + screenshot = mss().grab(box) + screenshot = Image.frombytes("RGB", screenshot.size, screenshot.rgb) + screenshot.save("screenshots/{}.png".format(ttk.Style(self).theme_use())) + + +if __name__ == '__main__': + sys.path = sys.path[2:] + from gttk import GTTK + + window = Example() + gttk = GTTK(window, theme="Adwaita") + style = ttk.Style(window) + + style.theme_use("gttk") + + gttk.set_gtk_theme("Yaru") + window.after(2000, lambda: gttk.set_gtk_theme("Adwaita")) + + window.mainloop() diff --git a/LICENSE b/generic/LICENSE.md similarity index 98% rename from LICENSE rename to generic/LICENSE.md index cf92aed..b92a080 100644 --- a/LICENSE +++ b/generic/LICENSE.md @@ -1,6 +1,7 @@ -LICENSE ("MIT-style") +# MIT License Copyright 2008-2012 Georgios Petasis + Copyright 2012 Cheer Xiao The following terms apply to all files associated with this software diff --git a/generic/gtkTtk_Elements.h b/generic/gtkTtk_Elements.h deleted file mode 100644 index 14ecdc1..0000000 --- a/generic/gtkTtk_Elements.h +++ /dev/null @@ -1,52 +0,0 @@ -/* - * gtkTtk_Elements.h - * ------------------- - * - * This file is part of the gtkTtk package, a Tk/Tile based theme that uses - * Gtk/GNOME for drawing. - * - * Copyright (C) 2004-2008 by: - * Georgios Petasis, petasis@iit.demokritos.gr, - * Software and Knowledge Engineering Laboratory, - * Institute of Informatics and Telecommunications, - * National Centre for Scientific Research (NCSR) "Demokritos", - * Aghia Paraskevi, 153 10, Athens, Greece. - */ -#include "gtkTtk_TkHeaders.h" - -extern int GtkTtk_Init_Background(Tcl_Interp *interp, - GtkTtk_WidgetCache **, Ttk_Theme themePtr); -extern int GtkTtk_Init_Button(Tcl_Interp *interp, - GtkTtk_WidgetCache **, Ttk_Theme themePtr); -extern int GtkTtk_Init_CheckButton(Tcl_Interp *interp, - GtkTtk_WidgetCache **, Ttk_Theme themePtr); -extern int GtkTtk_Init_RadioButton(Tcl_Interp *interp, - GtkTtk_WidgetCache **, Ttk_Theme themePtr); -extern int GtkTtk_Init_Menubutton(Tcl_Interp *interp, - GtkTtk_WidgetCache **, Ttk_Theme themePtr); -extern int GtkTtk_Init_ToolButton(Tcl_Interp *interp, - GtkTtk_WidgetCache **, Ttk_Theme themePtr); -extern int GtkTtk_Init_Entry(Tcl_Interp *interp, - GtkTtk_WidgetCache **, Ttk_Theme themePtr); -extern int GtkTtk_Init_Combobox(Tcl_Interp *interp, - GtkTtk_WidgetCache **, Ttk_Theme themePtr); -extern int GtkTtk_Init_Labelframe(Tcl_Interp *interp, - GtkTtk_WidgetCache **, Ttk_Theme themePtr); -extern int GtkTtk_Init_Scrollbar(Tcl_Interp *interp, - GtkTtk_WidgetCache **, Ttk_Theme themePtr); -extern int GtkTtk_Init_Notebook(Tcl_Interp *interp, - GtkTtk_WidgetCache **, Ttk_Theme themePtr); -extern int GtkTtk_Init_TreeView(Tcl_Interp *interp, - GtkTtk_WidgetCache **, Ttk_Theme themePtr); -extern int GtkTtk_Init_Progress(Tcl_Interp *interp, - GtkTtk_WidgetCache **, Ttk_Theme themePtr); -extern int GtkTtk_Init_Scale(Tcl_Interp *interp, - GtkTtk_WidgetCache **, Ttk_Theme themePtr); -extern int GtkTtk_Init_Paned(Tcl_Interp *interp, - GtkTtk_WidgetCache **, Ttk_Theme themePtr); -extern int GtkTtk_Init_SizeGrip(Tcl_Interp *interp, - GtkTtk_WidgetCache **, Ttk_Theme themePtr); -extern int GtkTtk_Init_Separator(Tcl_Interp *interp, - GtkTtk_WidgetCache **, Ttk_Theme themePtr); -extern int GtkTtk_Init_Arrows(Tcl_Interp *interp, - GtkTtk_WidgetCache **, Ttk_Theme themePtr); diff --git a/generic/gtkTtk_GtkApp.cpp b/generic/gtkTtk_GtkApp.cpp deleted file mode 100644 index d9e8e3a..0000000 --- a/generic/gtkTtk_GtkApp.cpp +++ /dev/null @@ -1,248 +0,0 @@ -/* - * gtkTtk_GtkApp.c - * --------------- - * - * This file is part of the gtkTtk package, a Tk/Tile based theme that uses - * Gtk/GNOME for drawing. - * - * Copyright (C) 2004-2008 by: - * Georgios Petasis, petasis@iit.demokritos.gr, - * Software and Knowledge Engineering Laboratory, - * Institute of Informatics and Telecommunications, - * National Centre for Scientific Research (NCSR) "Demokritos", - * Aghia Paraskevi, 153 10, Athens, Greece. - */ - -#ifdef GTKTTK_ENABLE_GNOME -#include -GnomeProgram *my_app = NULL; -#endif /* GTKTTK_ENABLE_GNOME */ - -#include "gtkTtk_Utilities.h" -#include "gtkTtk_TkHeaders.h" -#include -gboolean GtkTtk_GtkInitialisedFlag = FALSE; -static int GtkTtk_xlib_rgb_initialised = 0; -GtkWidget *GtkTtk_GtkWindow = NULL; - - - -/* In the following variable we store the XErrorHandler, before we install our - * own, which filters out some XErrors... */ -static int (*GtkTtk_TkXErrorHandler)(Display *displayPtr, - XErrorEvent *errorPtr); -static int (*GtkTtk_GtkXErrorHandler)(Display *displayPtr, - XErrorEvent *errorPtr); -static int GtkTtk_XErrorHandler(Display *displayPtr, XErrorEvent *errorPtr); - -static int GtkTtk_XEventHandler(ClientData clientdata, XEvent *eventPtr); - -/* - * GtkTtk_InterpDeleteProc: - * This function will be called when the interpreter gets deleted. It must free - * all allocated interp-specific memory segments. - */ -static void GtkTtk_InterpDeleteProc(ClientData clientData, Tcl_Interp *interp) { - GtkTtk_WidgetCache **wc_array = (GtkTtk_WidgetCache **) clientData; - GtkTtk_WidgetCache *wc = wc_array[0]; - if (wc && wc->gtkWindow) { - /*This will destroy also ALL children!*/ - GtkTtk_gtk_widget_destroy(wc->gtkWindow); - } - // printf("Tk_DeleteGenericHandler: %p\n", interp); fflush(NULL); - Tk_DeleteGenericHandler(&GtkTtk_XEventHandler, (ClientData) interp); - Tcl_Free((char *) wc_array[0]); - Tcl_Free((char *) wc_array[1]); - Tcl_Free((char *) wc_array); -}; /* GtkTtk_InterpDeleteProc */ - -GtkTtk_WidgetCache **GtkTtk_CreateGtkApp(Tcl_Interp *interp) { - /* - * The first step is to initialise the gtk library. This must be done once - * in the application lifetime. - */ - Tcl_MutexLock(>kTtkMutex); - if (!GtkTtk_GtkInitialisedFlag) { -#ifdef GTKTTK_ENABLE_GNOME - gchar **remaining_args = NULL; - GOptionEntry option_entries[] = { - {G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &remaining_args, - "Special option that collects any remaining arguments for us"}, - { NULL } - }; - GOptionContext *option_context; -#endif /* GTKTTK_ENABLE_GNOME */ - int argc = 1; - char **argv = GtkTtk_g_new0(char*, 2); - argv[0] = (char *) Tcl_GetNameOfExecutable(); - -#ifdef GTKTTK_INSTALL_XERROR_HANDLER - GtkTtk_TkXErrorHandler = XSetErrorHandler(GtkTtk_XErrorHandler); -#endif /* GTKTTK_INSTALL_XERROR_HANDLER */ - -#ifdef GTKTTK_ENABLE_GNOME - option_context = GtkTtk_g_option_context_new("tile-gtk"); - GtkTtk_g_option_context_add_main_entries(option_context, - option_entries, NULL); - /* We assume PACKAGE and VERSION are set to the program name and version - * number respectively. Also, assume that 'option_entries' is a global - * array of GOptionEntry structures. - */ - my_app = gnome_program_init(PACKAGE_NAME, PACKAGE_VERSION, - LIBGNOMEUI_MODULE, argc, argv, - GNOME_PARAM_GOPTION_CONTEXT, option_context, - GNOME_PARAM_NONE); - if (my_app) GtkTtk_GtkInitialisedFlag = TRUE; - if (remaining_args != NULL) { - GtkTtk_g_strfreev(remaining_args); - remaining_args = NULL; - } -#else /* GTKTTK_ENABLE_GNOME */ - GtkTtk_gtk_disable_setlocale(); - GtkTtk_GtkInitialisedFlag = GtkTtk_gtk_init_check(&argc, &argv); -#endif /* GTKTTK_ENABLE_GNOME */ - GtkTtk_g_free(argv); - if (!GtkTtk_GtkInitialisedFlag) { - Tcl_MutexUnlock(>kTtkMutex); - return NULL; - } - /* Initialise GtkTtk_GtkWindow... */ - GtkTtk_GtkWindow = GtkTtk_gtk_window_new(GTK_WINDOW_POPUP); - GtkTtk_gtk_widget_realize(GtkTtk_GtkWindow); -#ifdef GTKTTK_INSTALL_XERROR_HANDLER - /* - * GTK+ xerror handler will terminate the application. - * Just get rid of that... - */ - GtkTtk_GtkXErrorHandler = XSetErrorHandler(GtkTtk_XErrorHandler); -#endif /* GTKTTK_INSTALL_XERROR_HANDLER */ - -#ifdef GTKTTK_SYNCHRONIZE - XSynchronize(Tk_Display(Tk_MainWindow(interp)), true); -#endif /* GTKTTK_SYNCHRONIZE */ - } - Tcl_MutexUnlock(>kTtkMutex); - - /* - * Allocate the widget cache. We keep a widget cache per interpreter. - * Each cache is an array of two elements, one for each orientation. - */ - - GtkTtk_WidgetCache **wc_array = (GtkTtk_WidgetCache **) - Tcl_Alloc(sizeof(GtkTtk_WidgetCache*)*2); - wc_array[0] = (GtkTtk_WidgetCache *) - Tcl_Alloc(sizeof(GtkTtk_WidgetCache)); - wc_array[1] = (GtkTtk_WidgetCache *) - Tcl_Alloc(sizeof(GtkTtk_WidgetCache)); - Tcl_SetAssocData(interp, "gtkTtkTtk_gtk_widget_cache", - &GtkTtk_InterpDeleteProc, (ClientData) wc_array); - GtkTtk_WidgetCache *wc = wc_array[0]; - memset(wc, 0, sizeof(GtkTtk_WidgetCache)); - /* - * Initialise the widget cache. - */ - wc->GtkTtk_MainInterp = interp; - wc->GtkTtk_tkwin = Tk_MainWindow(interp); - if (wc->GtkTtk_tkwin != NULL && wc->GtkTtk_MainDisplay == None) { - Tk_MakeWindowExist(wc->GtkTtk_tkwin); - wc->GtkTtk_MainDisplay = Tk_Display(wc->GtkTtk_tkwin); - } - if (wc->GtkTtk_MainDisplay == None) { - Tcl_MutexUnlock(>kTtkMutex); - Tcl_Free((char *) wc_array[0]); - Tcl_Free((char *) wc_array[1]); - Tcl_Free((char *) wc_array); - return NULL; - } -#ifndef __WIN32__ - wc->gdkDisplay = GtkTtk_gdk_x11_lookup_xdisplay(wc->GtkTtk_MainDisplay); -#endif - if (!wc->gdkDisplay) { - wc->gdkDisplay = GtkTtk_gdk_display_get_default(); - } - wc->gtkWindow = GtkTtk_gtk_window_new(GTK_WINDOW_POPUP); - if (wc->gtkWindow) GtkTtk_gtk_widget_realize(wc->gtkWindow); - wc->protoLayout = GtkTtk_gtk_fixed_new(); - GtkTtk_gtk_container_add((GtkContainer*)(wc->gtkWindow), wc->protoLayout); - memcpy(wc_array[1], wc_array[0], sizeof(GtkTtk_WidgetCache)); - wc_array[0]->orientation = TTK_ORIENT_HORIZONTAL; - wc_array[1]->orientation = TTK_ORIENT_VERTICAL; - wc_array[0]->gtkOrientation = GTK_ORIENTATION_HORIZONTAL; - wc_array[1]->gtkOrientation = GTK_ORIENTATION_VERTICAL; - -#ifndef __WIN32__ - Tcl_MutexLock(>kTtkMutex); - if (!GtkTtk_xlib_rgb_initialised) { - GtkTtk_xlib_rgb_init(wc->GtkTtk_MainDisplay,Tk_Screen(wc->GtkTtk_tkwin)); - GtkTtk_xlib_rgb_initialised = 1; - } - Tcl_MutexUnlock(>kTtkMutex); -#endif - return wc_array; -}; /* GtkTtk_CreateGtkApp */ - -void GtkTtk_DestroyGtkApp(void) { - Tcl_MutexLock(>kTtkMutex); - if (GtkTtk_GtkInitialisedFlag) { - // XSetErrorHandler(GtkTtk_TkXErrorHandler); - GtkTtk_GtkInitialisedFlag = FALSE; - } - Tcl_MutexUnlock(>kTtkMutex); -}; /* GtkTtk_DestroyGtkApp */ - -/* - * GtkTtk_XErrorHandler: - * This XError handler just prints some debug information and then calls - * Tk's XError handler... - */ -static int GtkTtk_XErrorHandler(Display *displayPtr, XErrorEvent *errorPtr) { -#ifdef GTKTTK_VERBOSE_XERROR_HANDLER - char buf[64]; - XGetErrorText (displayPtr, errorPtr->error_code, buf, 63); - printf("===============================================================\n"); - printf(" GtkTtk_XErrorHandler:\n"); - printf(" error_code = %s (%d)\n", buf, errorPtr->error_code); - printf(" request_code = %d\n", errorPtr->request_code); - printf(" minor_code = %d\n", errorPtr->minor_code); - printf("===============================================================\n"); -#endif /* GTKTTK_VERBOSE_XERROR_HANDLER */ - return GtkTtk_TkXErrorHandler(displayPtr, errorPtr); -}; /* GtkTtk_XErrorHandler */ - -static int GtkTtk_XEventHandler(ClientData clientData, XEvent *eventPtr) { - const char *tcl_callback; - int status; - if (eventPtr->type != ClientMessage) return 0; - // Atom GtkTtk_KIPC_COMM_ATOM = XInternAtom(eventPtr->xclient.display, - // "KIPC_COMM_ATOM" , false); - Atom GtkTtk_KIPC_COMM_ATOM = None; - if (eventPtr->xclient.message_type != GtkTtk_KIPC_COMM_ATOM) return 0; - /* The following data variable contains the type of the KIPC message, - * As defined in gnomelibs/gnomecore/kipc.h: - * PaletteChanged = 0 - * StyleChanged = 2 - * ToolbarStyleChanged = 6 - */ - switch (eventPtr->xclient.data.l[0]) { - case 0: /* PaletteChanged */ - tcl_callback = "tile::theme::gtkTtk::gnomePaletteChangeNotification"; - break; - case 2: /* StyleChanged */ - case 6: { /* ToolbarStyleChanged */ - tcl_callback = "tile::theme::gtkTtk::gnomeStyleChangeNotification"; - break; - } - default: { - return 0; - } - } - Tcl_Interp *interp = (Tcl_Interp *) clientData; - if (interp == NULL) return 0; - // printf("GtkTtk_XEventHandler: %p\n", interp); fflush(NULL); - /* Notify the tile engine about the change... */ - status = Tcl_Eval(interp, tcl_callback); - if (status != TCL_OK) Tcl_BackgroundError(interp); - /* Do not remove True: As many interpreters may have registered this event - * handler, allow Tk to call all of them! */ - return True; -} /* GtkTtk_XEventHandler */ diff --git a/generic/gtkTtk_Symbols.cpp b/generic/gtkTtk_Symbols.cpp deleted file mode 100644 index e2dc20d..0000000 --- a/generic/gtkTtk_Symbols.cpp +++ /dev/null @@ -1,804 +0,0 @@ -/* - * gtkTtk_Symbols.cpp - * ------------------------ - * - * This file is part of the GtkTtk package, a ttk based theme that uses - * Gtk/GNOME for drawing. - * - * Copyright (C) 2004-2012 by: - * Georgios Petasis, petasis@iit.demokritos.gr, - * Software and Knowledge Engineering Laboratory, - * Institute of Informatics and Telecommunications, - * National Centre for Scientific Research (NCSR) "Demokritos", - * Aghia Paraskevi, 153 10, Athens, Greece. - */ -/* THIS FILE IS AUTOMATICALLY GENERATED - DO NOT EDIT! */ -#include "gtkTtk_Symbols.h" -#ifdef GTKTTK_LOAD_GTK_DYNAMICALLY -#if (TCL_MAJOR_VERSION >= 8) && (TCL_MINOR_VERSION >= 6) -#define LOAD_SYMBOLS_WITH_TCL -#endif - -#ifndef LOAD_SYMBOLS_WITH_TCL -#include -#endif - -Ptr_g_free GtkTtk_g_free = 0; -Ptr_g_hash_table_get_keys GtkTtk_g_hash_table_get_keys = 0; -Ptr_g_malloc GtkTtk_g_malloc = 0; -Ptr_g_malloc0 GtkTtk_g_malloc0 = 0; -Ptr_g_object_get GtkTtk_g_object_get = 0; -Ptr_g_object_unref GtkTtk_g_object_unref = 0; -Ptr_g_option_context_add_main_entries GtkTtk_g_option_context_add_main_entries = 0; -Ptr_g_option_context_new GtkTtk_g_option_context_new = 0; -Ptr_g_strfreev GtkTtk_g_strfreev = 0; -Ptr_gdk_color_to_string GtkTtk_gdk_color_to_string = 0; -Ptr_gdk_display_get_default GtkTtk_gdk_display_get_default = 0; -Ptr_gdk_display_get_screen GtkTtk_gdk_display_get_screen = 0; -Ptr_gdk_drawable_set_colormap GtkTtk_gdk_drawable_set_colormap = 0; -Ptr_gdk_gc_new GtkTtk_gdk_gc_new = 0; -Ptr_gdk_pixbuf_get_from_drawable GtkTtk_gdk_pixbuf_get_from_drawable = 0; -Ptr_gdk_pixbuf_new GtkTtk_gdk_pixbuf_new = 0; -Ptr_gdk_pixbuf_unref GtkTtk_gdk_pixbuf_unref = 0; -Ptr_gdk_pixbuf_xlib_render_to_drawable GtkTtk_gdk_pixbuf_xlib_render_to_drawable = 0; -Ptr_gdk_pixmap_foreign_new_for_screen GtkTtk_gdk_pixmap_foreign_new_for_screen = 0; -Ptr_gdk_pixmap_new GtkTtk_gdk_pixmap_new = 0; -Ptr_gdk_x11_colormap_foreign_new GtkTtk_gdk_x11_colormap_foreign_new = 0; -Ptr_gdk_x11_lookup_xdisplay GtkTtk_gdk_x11_lookup_xdisplay = 0; -Ptr_gdk_x11_screen_lookup_visual GtkTtk_gdk_x11_screen_lookup_visual = 0; -Ptr_gtk_adjustment_new GtkTtk_gtk_adjustment_new = 0; -Ptr_gtk_adjustment_set_value GtkTtk_gtk_adjustment_set_value = 0; -Ptr_gtk_arrow_new GtkTtk_gtk_arrow_new = 0; -Ptr_gtk_border_free GtkTtk_gtk_border_free = 0; -Ptr_gtk_button_get_relief GtkTtk_gtk_button_get_relief = 0; -Ptr_gtk_button_new GtkTtk_gtk_button_new = 0; -Ptr_gtk_button_set_relief GtkTtk_gtk_button_set_relief = 0; -Ptr_gtk_check_button_new GtkTtk_gtk_check_button_new = 0; -Ptr_gtk_combo_box_entry_new GtkTtk_gtk_combo_box_entry_new = 0; -Ptr_gtk_combo_box_new GtkTtk_gtk_combo_box_new = 0; -Ptr_gtk_container_add GtkTtk_gtk_container_add = 0; -Ptr_gtk_disable_setlocale GtkTtk_gtk_disable_setlocale = 0; -Ptr_gtk_entry_new GtkTtk_gtk_entry_new = 0; -Ptr_gtk_fixed_new GtkTtk_gtk_fixed_new = 0; -Ptr_gtk_frame_new GtkTtk_gtk_frame_new = 0; -Ptr_gtk_hpaned_new GtkTtk_gtk_hpaned_new = 0; -Ptr_gtk_hscale_new_with_range GtkTtk_gtk_hscale_new_with_range = 0; -Ptr_gtk_hscrollbar_new GtkTtk_gtk_hscrollbar_new = 0; -Ptr_gtk_init_check GtkTtk_gtk_init_check = 0; -Ptr_gtk_notebook_new GtkTtk_gtk_notebook_new = 0; -Ptr_gtk_object_get GtkTtk_gtk_object_get = 0; -Ptr_gtk_paint_arrow GtkTtk_gtk_paint_arrow = 0; -Ptr_gtk_paint_box GtkTtk_gtk_paint_box = 0; -Ptr_gtk_paint_box_gap GtkTtk_gtk_paint_box_gap = 0; -Ptr_gtk_paint_check GtkTtk_gtk_paint_check = 0; -Ptr_gtk_paint_extension GtkTtk_gtk_paint_extension = 0; -Ptr_gtk_paint_flat_box GtkTtk_gtk_paint_flat_box = 0; -Ptr_gtk_paint_focus GtkTtk_gtk_paint_focus = 0; -Ptr_gtk_paint_handle GtkTtk_gtk_paint_handle = 0; -Ptr_gtk_paint_option GtkTtk_gtk_paint_option = 0; -Ptr_gtk_paint_resize_grip GtkTtk_gtk_paint_resize_grip = 0; -Ptr_gtk_paint_shadow GtkTtk_gtk_paint_shadow = 0; -Ptr_gtk_paint_slider GtkTtk_gtk_paint_slider = 0; -Ptr_gtk_progress_bar_new GtkTtk_gtk_progress_bar_new = 0; -Ptr_gtk_progress_bar_set_bar_style GtkTtk_gtk_progress_bar_set_bar_style = 0; -Ptr_gtk_progress_bar_set_fraction GtkTtk_gtk_progress_bar_set_fraction = 0; -Ptr_gtk_progress_bar_set_orientation GtkTtk_gtk_progress_bar_set_orientation = 0; -Ptr_gtk_range_get_adjustment GtkTtk_gtk_range_get_adjustment = 0; -Ptr_gtk_rc_get_default_files GtkTtk_gtk_rc_get_default_files = 0; -Ptr_gtk_rc_get_style GtkTtk_gtk_rc_get_style = 0; -Ptr_gtk_rc_get_theme_dir GtkTtk_gtk_rc_get_theme_dir = 0; -Ptr_gtk_rc_reparse_all_for_settings GtkTtk_gtk_rc_reparse_all_for_settings = 0; -Ptr_gtk_rc_reset_styles GtkTtk_gtk_rc_reset_styles = 0; -Ptr_gtk_rc_set_default_files GtkTtk_gtk_rc_set_default_files = 0; -Ptr_gtk_settings_get_default GtkTtk_gtk_settings_get_default = 0; -Ptr_gtk_statusbar_new GtkTtk_gtk_statusbar_new = 0; -Ptr_gtk_style_apply_default_background GtkTtk_gtk_style_apply_default_background = 0; -Ptr_gtk_style_attach GtkTtk_gtk_style_attach = 0; -Ptr_gtk_style_lookup_color GtkTtk_gtk_style_lookup_color = 0; -Ptr_gtk_toolbar_new GtkTtk_gtk_toolbar_new = 0; -Ptr_gtk_vpaned_new GtkTtk_gtk_vpaned_new = 0; -Ptr_gtk_vscale_new_with_range GtkTtk_gtk_vscale_new_with_range = 0; -Ptr_gtk_vscrollbar_new GtkTtk_gtk_vscrollbar_new = 0; -Ptr_gtk_widget_destroy GtkTtk_gtk_widget_destroy = 0; -Ptr_gtk_widget_realize GtkTtk_gtk_widget_realize = 0; -Ptr_gtk_widget_set_size_request GtkTtk_gtk_widget_set_size_request = 0; -Ptr_gtk_widget_size_request GtkTtk_gtk_widget_size_request = 0; -Ptr_gtk_widget_style_get GtkTtk_gtk_widget_style_get = 0; -Ptr_gtk_window_new GtkTtk_gtk_window_new = 0; -Ptr_xlib_rgb_init GtkTtk_xlib_rgb_init = 0; - -int GtkTtk_InitialiseSymbols_gdk(Tcl_Interp *interp, Tcl_Obj *file_name) { -#ifdef LOAD_SYMBOLS_WITH_TCL - Tcl_LoadHandle loadHandle; - int status; - status = Tcl_LoadFile(interp, file_name, NULL, 0, NULL, &loadHandle); - if (status != TCL_OK) return status; - GtkTtk_gdk_color_to_string = (Ptr_gdk_color_to_string) Tcl_FindSymbol(interp, loadHandle, "gdk_color_to_string"); - if (GtkTtk_gdk_color_to_string == NULL) return TCL_ERROR; - GtkTtk_gdk_display_get_default = (Ptr_gdk_display_get_default) Tcl_FindSymbol(interp, loadHandle, "gdk_display_get_default"); - if (GtkTtk_gdk_display_get_default == NULL) return TCL_ERROR; - GtkTtk_gdk_display_get_screen = (Ptr_gdk_display_get_screen) Tcl_FindSymbol(interp, loadHandle, "gdk_display_get_screen"); - if (GtkTtk_gdk_display_get_screen == NULL) return TCL_ERROR; - GtkTtk_gdk_drawable_set_colormap = (Ptr_gdk_drawable_set_colormap) Tcl_FindSymbol(interp, loadHandle, "gdk_drawable_set_colormap"); - if (GtkTtk_gdk_drawable_set_colormap == NULL) return TCL_ERROR; - GtkTtk_gdk_gc_new = (Ptr_gdk_gc_new) Tcl_FindSymbol(interp, loadHandle, "gdk_gc_new"); - if (GtkTtk_gdk_gc_new == NULL) return TCL_ERROR; - GtkTtk_gdk_pixbuf_get_from_drawable = (Ptr_gdk_pixbuf_get_from_drawable) Tcl_FindSymbol(interp, loadHandle, "gdk_pixbuf_get_from_drawable"); - if (GtkTtk_gdk_pixbuf_get_from_drawable == NULL) return TCL_ERROR; - GtkTtk_gdk_pixmap_foreign_new_for_screen = (Ptr_gdk_pixmap_foreign_new_for_screen) Tcl_FindSymbol(interp, loadHandle, "gdk_pixmap_foreign_new_for_screen"); - if (GtkTtk_gdk_pixmap_foreign_new_for_screen == NULL) return TCL_ERROR; - GtkTtk_gdk_pixmap_new = (Ptr_gdk_pixmap_new) Tcl_FindSymbol(interp, loadHandle, "gdk_pixmap_new"); - if (GtkTtk_gdk_pixmap_new == NULL) return TCL_ERROR; - GtkTtk_gdk_x11_colormap_foreign_new = (Ptr_gdk_x11_colormap_foreign_new) Tcl_FindSymbol(interp, loadHandle, "gdk_x11_colormap_foreign_new"); - if (GtkTtk_gdk_x11_colormap_foreign_new == NULL) return TCL_ERROR; - GtkTtk_gdk_x11_lookup_xdisplay = (Ptr_gdk_x11_lookup_xdisplay) Tcl_FindSymbol(interp, loadHandle, "gdk_x11_lookup_xdisplay"); - if (GtkTtk_gdk_x11_lookup_xdisplay == NULL) return TCL_ERROR; - GtkTtk_gdk_x11_screen_lookup_visual = (Ptr_gdk_x11_screen_lookup_visual) Tcl_FindSymbol(interp, loadHandle, "gdk_x11_screen_lookup_visual"); - if (GtkTtk_gdk_x11_screen_lookup_visual == NULL) return TCL_ERROR; -#else - const char *fname = Tcl_GetString(file_name); - GModule *m = g_module_open(fname, G_MODULE_BIND_LAZY); - if (!m) { - Tcl_SetResult(interp, (char *) "cannot open module: ", TCL_STATIC); - Tcl_AppendResult(interp, fname, (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gdk_color_to_string", (gpointer *) &GtkTtk_gdk_color_to_string)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gdk_color_to_string", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gdk_display_get_default", (gpointer *) &GtkTtk_gdk_display_get_default)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gdk_display_get_default", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gdk_display_get_screen", (gpointer *) &GtkTtk_gdk_display_get_screen)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gdk_display_get_screen", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gdk_drawable_set_colormap", (gpointer *) &GtkTtk_gdk_drawable_set_colormap)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gdk_drawable_set_colormap", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gdk_gc_new", (gpointer *) &GtkTtk_gdk_gc_new)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gdk_gc_new", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gdk_pixbuf_get_from_drawable", (gpointer *) &GtkTtk_gdk_pixbuf_get_from_drawable)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gdk_pixbuf_get_from_drawable", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gdk_pixmap_foreign_new_for_screen", (gpointer *) &GtkTtk_gdk_pixmap_foreign_new_for_screen)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gdk_pixmap_foreign_new_for_screen", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gdk_pixmap_new", (gpointer *) &GtkTtk_gdk_pixmap_new)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gdk_pixmap_new", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gdk_x11_colormap_foreign_new", (gpointer *) &GtkTtk_gdk_x11_colormap_foreign_new)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gdk_x11_colormap_foreign_new", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gdk_x11_lookup_xdisplay", (gpointer *) &GtkTtk_gdk_x11_lookup_xdisplay)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gdk_x11_lookup_xdisplay", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gdk_x11_screen_lookup_visual", (gpointer *) &GtkTtk_gdk_x11_screen_lookup_visual)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gdk_x11_screen_lookup_visual", (char *) NULL); - return TCL_ERROR; - } -#endif - return TCL_OK; -}; /* GtkTtk_InitialiseSymbols_gdk */ - - -int GtkTtk_InitialiseSymbols_gdk_pixbuf(Tcl_Interp *interp, Tcl_Obj *file_name) { -#ifdef LOAD_SYMBOLS_WITH_TCL - Tcl_LoadHandle loadHandle; - int status; - status = Tcl_LoadFile(interp, file_name, NULL, 0, NULL, &loadHandle); - if (status != TCL_OK) return status; - GtkTtk_gdk_pixbuf_new = (Ptr_gdk_pixbuf_new) Tcl_FindSymbol(interp, loadHandle, "gdk_pixbuf_new"); - if (GtkTtk_gdk_pixbuf_new == NULL) return TCL_ERROR; - GtkTtk_gdk_pixbuf_unref = (Ptr_gdk_pixbuf_unref) Tcl_FindSymbol(interp, loadHandle, "gdk_pixbuf_unref"); - if (GtkTtk_gdk_pixbuf_unref == NULL) return TCL_ERROR; -#else - const char *fname = Tcl_GetString(file_name); - GModule *m = g_module_open(fname, G_MODULE_BIND_LAZY); - if (!m) { - Tcl_SetResult(interp, (char *) "cannot open module: ", TCL_STATIC); - Tcl_AppendResult(interp, fname, (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gdk_pixbuf_new", (gpointer *) &GtkTtk_gdk_pixbuf_new)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gdk_pixbuf_new", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gdk_pixbuf_unref", (gpointer *) &GtkTtk_gdk_pixbuf_unref)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gdk_pixbuf_unref", (char *) NULL); - return TCL_ERROR; - } -#endif - return TCL_OK; -}; /* GtkTtk_InitialiseSymbols_gdk_pixbuf */ - - -int GtkTtk_InitialiseSymbols_gdk_pixbuf_xlib(Tcl_Interp *interp, Tcl_Obj *file_name) { -#ifdef LOAD_SYMBOLS_WITH_TCL - Tcl_LoadHandle loadHandle; - int status; - status = Tcl_LoadFile(interp, file_name, NULL, 0, NULL, &loadHandle); - if (status != TCL_OK) return status; - GtkTtk_gdk_pixbuf_xlib_render_to_drawable = (Ptr_gdk_pixbuf_xlib_render_to_drawable) Tcl_FindSymbol(interp, loadHandle, "gdk_pixbuf_xlib_render_to_drawable"); - if (GtkTtk_gdk_pixbuf_xlib_render_to_drawable == NULL) return TCL_ERROR; - GtkTtk_xlib_rgb_init = (Ptr_xlib_rgb_init) Tcl_FindSymbol(interp, loadHandle, "xlib_rgb_init"); - if (GtkTtk_xlib_rgb_init == NULL) return TCL_ERROR; -#else - const char *fname = Tcl_GetString(file_name); - GModule *m = g_module_open(fname, G_MODULE_BIND_LAZY); - if (!m) { - Tcl_SetResult(interp, (char *) "cannot open module: ", TCL_STATIC); - Tcl_AppendResult(interp, fname, (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gdk_pixbuf_xlib_render_to_drawable", (gpointer *) &GtkTtk_gdk_pixbuf_xlib_render_to_drawable)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gdk_pixbuf_xlib_render_to_drawable", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "xlib_rgb_init", (gpointer *) &GtkTtk_xlib_rgb_init)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "xlib_rgb_init", (char *) NULL); - return TCL_ERROR; - } -#endif - return TCL_OK; -}; /* GtkTtk_InitialiseSymbols_gdk_pixbuf_xlib */ - - -int GtkTtk_InitialiseSymbols_glib(Tcl_Interp *interp, Tcl_Obj *file_name) { -#ifdef LOAD_SYMBOLS_WITH_TCL - Tcl_LoadHandle loadHandle; - int status; - status = Tcl_LoadFile(interp, file_name, NULL, 0, NULL, &loadHandle); - if (status != TCL_OK) return status; - GtkTtk_g_free = (Ptr_g_free) Tcl_FindSymbol(interp, loadHandle, "g_free"); - if (GtkTtk_g_free == NULL) return TCL_ERROR; - GtkTtk_g_hash_table_get_keys = (Ptr_g_hash_table_get_keys) Tcl_FindSymbol(interp, loadHandle, "g_hash_table_get_keys"); - if (GtkTtk_g_hash_table_get_keys == NULL) return TCL_ERROR; - GtkTtk_g_malloc = (Ptr_g_malloc) Tcl_FindSymbol(interp, loadHandle, "g_malloc"); - if (GtkTtk_g_malloc == NULL) return TCL_ERROR; - GtkTtk_g_malloc0 = (Ptr_g_malloc0) Tcl_FindSymbol(interp, loadHandle, "g_malloc0"); - if (GtkTtk_g_malloc0 == NULL) return TCL_ERROR; - GtkTtk_g_option_context_add_main_entries = (Ptr_g_option_context_add_main_entries) Tcl_FindSymbol(interp, loadHandle, "g_option_context_add_main_entries"); - if (GtkTtk_g_option_context_add_main_entries == NULL) return TCL_ERROR; - GtkTtk_g_option_context_new = (Ptr_g_option_context_new) Tcl_FindSymbol(interp, loadHandle, "g_option_context_new"); - if (GtkTtk_g_option_context_new == NULL) return TCL_ERROR; - GtkTtk_g_strfreev = (Ptr_g_strfreev) Tcl_FindSymbol(interp, loadHandle, "g_strfreev"); - if (GtkTtk_g_strfreev == NULL) return TCL_ERROR; -#else - const char *fname = Tcl_GetString(file_name); - GModule *m = g_module_open(fname, G_MODULE_BIND_LAZY); - if (!m) { - Tcl_SetResult(interp, (char *) "cannot open module: ", TCL_STATIC); - Tcl_AppendResult(interp, fname, (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "g_free", (gpointer *) &GtkTtk_g_free)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "g_free", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "g_hash_table_get_keys", (gpointer *) &GtkTtk_g_hash_table_get_keys)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "g_hash_table_get_keys", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "g_malloc", (gpointer *) &GtkTtk_g_malloc)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "g_malloc", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "g_malloc0", (gpointer *) &GtkTtk_g_malloc0)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "g_malloc0", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "g_option_context_add_main_entries", (gpointer *) &GtkTtk_g_option_context_add_main_entries)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "g_option_context_add_main_entries", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "g_option_context_new", (gpointer *) &GtkTtk_g_option_context_new)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "g_option_context_new", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "g_strfreev", (gpointer *) &GtkTtk_g_strfreev)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "g_strfreev", (char *) NULL); - return TCL_ERROR; - } -#endif - return TCL_OK; -}; /* GtkTtk_InitialiseSymbols_glib */ - - -int GtkTtk_InitialiseSymbols_gobject(Tcl_Interp *interp, Tcl_Obj *file_name) { -#ifdef LOAD_SYMBOLS_WITH_TCL - Tcl_LoadHandle loadHandle; - int status; - status = Tcl_LoadFile(interp, file_name, NULL, 0, NULL, &loadHandle); - if (status != TCL_OK) return status; - GtkTtk_g_object_get = (Ptr_g_object_get) Tcl_FindSymbol(interp, loadHandle, "g_object_get"); - if (GtkTtk_g_object_get == NULL) return TCL_ERROR; - GtkTtk_g_object_unref = (Ptr_g_object_unref) Tcl_FindSymbol(interp, loadHandle, "g_object_unref"); - if (GtkTtk_g_object_unref == NULL) return TCL_ERROR; -#else - const char *fname = Tcl_GetString(file_name); - GModule *m = g_module_open(fname, G_MODULE_BIND_LAZY); - if (!m) { - Tcl_SetResult(interp, (char *) "cannot open module: ", TCL_STATIC); - Tcl_AppendResult(interp, fname, (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "g_object_get", (gpointer *) &GtkTtk_g_object_get)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "g_object_get", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "g_object_unref", (gpointer *) &GtkTtk_g_object_unref)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "g_object_unref", (char *) NULL); - return TCL_ERROR; - } -#endif - return TCL_OK; -}; /* GtkTtk_InitialiseSymbols_gobject */ - - -int GtkTtk_InitialiseSymbols_gtk(Tcl_Interp *interp, Tcl_Obj *file_name) { -#ifdef LOAD_SYMBOLS_WITH_TCL - Tcl_LoadHandle loadHandle; - int status; - status = Tcl_LoadFile(interp, file_name, NULL, 0, NULL, &loadHandle); - if (status != TCL_OK) return status; - GtkTtk_gtk_adjustment_new = (Ptr_gtk_adjustment_new) Tcl_FindSymbol(interp, loadHandle, "gtk_adjustment_new"); - if (GtkTtk_gtk_adjustment_new == NULL) return TCL_ERROR; - GtkTtk_gtk_adjustment_set_value = (Ptr_gtk_adjustment_set_value) Tcl_FindSymbol(interp, loadHandle, "gtk_adjustment_set_value"); - if (GtkTtk_gtk_adjustment_set_value == NULL) return TCL_ERROR; - GtkTtk_gtk_arrow_new = (Ptr_gtk_arrow_new) Tcl_FindSymbol(interp, loadHandle, "gtk_arrow_new"); - if (GtkTtk_gtk_arrow_new == NULL) return TCL_ERROR; - GtkTtk_gtk_border_free = (Ptr_gtk_border_free) Tcl_FindSymbol(interp, loadHandle, "gtk_border_free"); - if (GtkTtk_gtk_border_free == NULL) return TCL_ERROR; - GtkTtk_gtk_button_get_relief = (Ptr_gtk_button_get_relief) Tcl_FindSymbol(interp, loadHandle, "gtk_button_get_relief"); - if (GtkTtk_gtk_button_get_relief == NULL) return TCL_ERROR; - GtkTtk_gtk_button_new = (Ptr_gtk_button_new) Tcl_FindSymbol(interp, loadHandle, "gtk_button_new"); - if (GtkTtk_gtk_button_new == NULL) return TCL_ERROR; - GtkTtk_gtk_button_set_relief = (Ptr_gtk_button_set_relief) Tcl_FindSymbol(interp, loadHandle, "gtk_button_set_relief"); - if (GtkTtk_gtk_button_set_relief == NULL) return TCL_ERROR; - GtkTtk_gtk_check_button_new = (Ptr_gtk_check_button_new) Tcl_FindSymbol(interp, loadHandle, "gtk_check_button_new"); - if (GtkTtk_gtk_check_button_new == NULL) return TCL_ERROR; - GtkTtk_gtk_combo_box_entry_new = (Ptr_gtk_combo_box_entry_new) Tcl_FindSymbol(interp, loadHandle, "gtk_combo_box_entry_new"); - if (GtkTtk_gtk_combo_box_entry_new == NULL) return TCL_ERROR; - GtkTtk_gtk_combo_box_new = (Ptr_gtk_combo_box_new) Tcl_FindSymbol(interp, loadHandle, "gtk_combo_box_new"); - if (GtkTtk_gtk_combo_box_new == NULL) return TCL_ERROR; - GtkTtk_gtk_container_add = (Ptr_gtk_container_add) Tcl_FindSymbol(interp, loadHandle, "gtk_container_add"); - if (GtkTtk_gtk_container_add == NULL) return TCL_ERROR; - GtkTtk_gtk_disable_setlocale = (Ptr_gtk_disable_setlocale) Tcl_FindSymbol(interp, loadHandle, "gtk_disable_setlocale"); - if (GtkTtk_gtk_disable_setlocale == NULL) return TCL_ERROR; - GtkTtk_gtk_entry_new = (Ptr_gtk_entry_new) Tcl_FindSymbol(interp, loadHandle, "gtk_entry_new"); - if (GtkTtk_gtk_entry_new == NULL) return TCL_ERROR; - GtkTtk_gtk_fixed_new = (Ptr_gtk_fixed_new) Tcl_FindSymbol(interp, loadHandle, "gtk_fixed_new"); - if (GtkTtk_gtk_fixed_new == NULL) return TCL_ERROR; - GtkTtk_gtk_frame_new = (Ptr_gtk_frame_new) Tcl_FindSymbol(interp, loadHandle, "gtk_frame_new"); - if (GtkTtk_gtk_frame_new == NULL) return TCL_ERROR; - GtkTtk_gtk_hpaned_new = (Ptr_gtk_hpaned_new) Tcl_FindSymbol(interp, loadHandle, "gtk_hpaned_new"); - if (GtkTtk_gtk_hpaned_new == NULL) return TCL_ERROR; - GtkTtk_gtk_hscale_new_with_range = (Ptr_gtk_hscale_new_with_range) Tcl_FindSymbol(interp, loadHandle, "gtk_hscale_new_with_range"); - if (GtkTtk_gtk_hscale_new_with_range == NULL) return TCL_ERROR; - GtkTtk_gtk_hscrollbar_new = (Ptr_gtk_hscrollbar_new) Tcl_FindSymbol(interp, loadHandle, "gtk_hscrollbar_new"); - if (GtkTtk_gtk_hscrollbar_new == NULL) return TCL_ERROR; - GtkTtk_gtk_init_check = (Ptr_gtk_init_check) Tcl_FindSymbol(interp, loadHandle, "gtk_init_check"); - if (GtkTtk_gtk_init_check == NULL) return TCL_ERROR; - GtkTtk_gtk_notebook_new = (Ptr_gtk_notebook_new) Tcl_FindSymbol(interp, loadHandle, "gtk_notebook_new"); - if (GtkTtk_gtk_notebook_new == NULL) return TCL_ERROR; - GtkTtk_gtk_object_get = (Ptr_gtk_object_get) Tcl_FindSymbol(interp, loadHandle, "gtk_object_get"); - if (GtkTtk_gtk_object_get == NULL) return TCL_ERROR; - GtkTtk_gtk_paint_arrow = (Ptr_gtk_paint_arrow) Tcl_FindSymbol(interp, loadHandle, "gtk_paint_arrow"); - if (GtkTtk_gtk_paint_arrow == NULL) return TCL_ERROR; - GtkTtk_gtk_paint_box = (Ptr_gtk_paint_box) Tcl_FindSymbol(interp, loadHandle, "gtk_paint_box"); - if (GtkTtk_gtk_paint_box == NULL) return TCL_ERROR; - GtkTtk_gtk_paint_box_gap = (Ptr_gtk_paint_box_gap) Tcl_FindSymbol(interp, loadHandle, "gtk_paint_box_gap"); - if (GtkTtk_gtk_paint_box_gap == NULL) return TCL_ERROR; - GtkTtk_gtk_paint_check = (Ptr_gtk_paint_check) Tcl_FindSymbol(interp, loadHandle, "gtk_paint_check"); - if (GtkTtk_gtk_paint_check == NULL) return TCL_ERROR; - GtkTtk_gtk_paint_extension = (Ptr_gtk_paint_extension) Tcl_FindSymbol(interp, loadHandle, "gtk_paint_extension"); - if (GtkTtk_gtk_paint_extension == NULL) return TCL_ERROR; - GtkTtk_gtk_paint_flat_box = (Ptr_gtk_paint_flat_box) Tcl_FindSymbol(interp, loadHandle, "gtk_paint_flat_box"); - if (GtkTtk_gtk_paint_flat_box == NULL) return TCL_ERROR; - GtkTtk_gtk_paint_focus = (Ptr_gtk_paint_focus) Tcl_FindSymbol(interp, loadHandle, "gtk_paint_focus"); - if (GtkTtk_gtk_paint_focus == NULL) return TCL_ERROR; - GtkTtk_gtk_paint_handle = (Ptr_gtk_paint_handle) Tcl_FindSymbol(interp, loadHandle, "gtk_paint_handle"); - if (GtkTtk_gtk_paint_handle == NULL) return TCL_ERROR; - GtkTtk_gtk_paint_option = (Ptr_gtk_paint_option) Tcl_FindSymbol(interp, loadHandle, "gtk_paint_option"); - if (GtkTtk_gtk_paint_option == NULL) return TCL_ERROR; - GtkTtk_gtk_paint_resize_grip = (Ptr_gtk_paint_resize_grip) Tcl_FindSymbol(interp, loadHandle, "gtk_paint_resize_grip"); - if (GtkTtk_gtk_paint_resize_grip == NULL) return TCL_ERROR; - GtkTtk_gtk_paint_shadow = (Ptr_gtk_paint_shadow) Tcl_FindSymbol(interp, loadHandle, "gtk_paint_shadow"); - if (GtkTtk_gtk_paint_shadow == NULL) return TCL_ERROR; - GtkTtk_gtk_paint_slider = (Ptr_gtk_paint_slider) Tcl_FindSymbol(interp, loadHandle, "gtk_paint_slider"); - if (GtkTtk_gtk_paint_slider == NULL) return TCL_ERROR; - GtkTtk_gtk_progress_bar_new = (Ptr_gtk_progress_bar_new) Tcl_FindSymbol(interp, loadHandle, "gtk_progress_bar_new"); - if (GtkTtk_gtk_progress_bar_new == NULL) return TCL_ERROR; - GtkTtk_gtk_progress_bar_set_bar_style = (Ptr_gtk_progress_bar_set_bar_style) Tcl_FindSymbol(interp, loadHandle, "gtk_progress_bar_set_bar_style"); - if (GtkTtk_gtk_progress_bar_set_bar_style == NULL) return TCL_ERROR; - GtkTtk_gtk_progress_bar_set_fraction = (Ptr_gtk_progress_bar_set_fraction) Tcl_FindSymbol(interp, loadHandle, "gtk_progress_bar_set_fraction"); - if (GtkTtk_gtk_progress_bar_set_fraction == NULL) return TCL_ERROR; - GtkTtk_gtk_progress_bar_set_orientation = (Ptr_gtk_progress_bar_set_orientation) Tcl_FindSymbol(interp, loadHandle, "gtk_progress_bar_set_orientation"); - if (GtkTtk_gtk_progress_bar_set_orientation == NULL) return TCL_ERROR; - GtkTtk_gtk_range_get_adjustment = (Ptr_gtk_range_get_adjustment) Tcl_FindSymbol(interp, loadHandle, "gtk_range_get_adjustment"); - if (GtkTtk_gtk_range_get_adjustment == NULL) return TCL_ERROR; - GtkTtk_gtk_rc_get_default_files = (Ptr_gtk_rc_get_default_files) Tcl_FindSymbol(interp, loadHandle, "gtk_rc_get_default_files"); - if (GtkTtk_gtk_rc_get_default_files == NULL) return TCL_ERROR; - GtkTtk_gtk_rc_get_style = (Ptr_gtk_rc_get_style) Tcl_FindSymbol(interp, loadHandle, "gtk_rc_get_style"); - if (GtkTtk_gtk_rc_get_style == NULL) return TCL_ERROR; - GtkTtk_gtk_rc_get_theme_dir = (Ptr_gtk_rc_get_theme_dir) Tcl_FindSymbol(interp, loadHandle, "gtk_rc_get_theme_dir"); - if (GtkTtk_gtk_rc_get_theme_dir == NULL) return TCL_ERROR; - GtkTtk_gtk_rc_reparse_all_for_settings = (Ptr_gtk_rc_reparse_all_for_settings) Tcl_FindSymbol(interp, loadHandle, "gtk_rc_reparse_all_for_settings"); - if (GtkTtk_gtk_rc_reparse_all_for_settings == NULL) return TCL_ERROR; - GtkTtk_gtk_rc_reset_styles = (Ptr_gtk_rc_reset_styles) Tcl_FindSymbol(interp, loadHandle, "gtk_rc_reset_styles"); - if (GtkTtk_gtk_rc_reset_styles == NULL) return TCL_ERROR; - GtkTtk_gtk_rc_set_default_files = (Ptr_gtk_rc_set_default_files) Tcl_FindSymbol(interp, loadHandle, "gtk_rc_set_default_files"); - if (GtkTtk_gtk_rc_set_default_files == NULL) return TCL_ERROR; - GtkTtk_gtk_settings_get_default = (Ptr_gtk_settings_get_default) Tcl_FindSymbol(interp, loadHandle, "gtk_settings_get_default"); - if (GtkTtk_gtk_settings_get_default == NULL) return TCL_ERROR; - GtkTtk_gtk_statusbar_new = (Ptr_gtk_statusbar_new) Tcl_FindSymbol(interp, loadHandle, "gtk_statusbar_new"); - if (GtkTtk_gtk_statusbar_new == NULL) return TCL_ERROR; - GtkTtk_gtk_style_apply_default_background = (Ptr_gtk_style_apply_default_background) Tcl_FindSymbol(interp, loadHandle, "gtk_style_apply_default_background"); - if (GtkTtk_gtk_style_apply_default_background == NULL) return TCL_ERROR; - GtkTtk_gtk_style_attach = (Ptr_gtk_style_attach) Tcl_FindSymbol(interp, loadHandle, "gtk_style_attach"); - if (GtkTtk_gtk_style_attach == NULL) return TCL_ERROR; - GtkTtk_gtk_style_lookup_color = (Ptr_gtk_style_lookup_color) Tcl_FindSymbol(interp, loadHandle, "gtk_style_lookup_color"); - if (GtkTtk_gtk_style_lookup_color == NULL) return TCL_ERROR; - GtkTtk_gtk_toolbar_new = (Ptr_gtk_toolbar_new) Tcl_FindSymbol(interp, loadHandle, "gtk_toolbar_new"); - if (GtkTtk_gtk_toolbar_new == NULL) return TCL_ERROR; - GtkTtk_gtk_vpaned_new = (Ptr_gtk_vpaned_new) Tcl_FindSymbol(interp, loadHandle, "gtk_vpaned_new"); - if (GtkTtk_gtk_vpaned_new == NULL) return TCL_ERROR; - GtkTtk_gtk_vscale_new_with_range = (Ptr_gtk_vscale_new_with_range) Tcl_FindSymbol(interp, loadHandle, "gtk_vscale_new_with_range"); - if (GtkTtk_gtk_vscale_new_with_range == NULL) return TCL_ERROR; - GtkTtk_gtk_vscrollbar_new = (Ptr_gtk_vscrollbar_new) Tcl_FindSymbol(interp, loadHandle, "gtk_vscrollbar_new"); - if (GtkTtk_gtk_vscrollbar_new == NULL) return TCL_ERROR; - GtkTtk_gtk_widget_destroy = (Ptr_gtk_widget_destroy) Tcl_FindSymbol(interp, loadHandle, "gtk_widget_destroy"); - if (GtkTtk_gtk_widget_destroy == NULL) return TCL_ERROR; - GtkTtk_gtk_widget_realize = (Ptr_gtk_widget_realize) Tcl_FindSymbol(interp, loadHandle, "gtk_widget_realize"); - if (GtkTtk_gtk_widget_realize == NULL) return TCL_ERROR; - GtkTtk_gtk_widget_set_size_request = (Ptr_gtk_widget_set_size_request) Tcl_FindSymbol(interp, loadHandle, "gtk_widget_set_size_request"); - if (GtkTtk_gtk_widget_set_size_request == NULL) return TCL_ERROR; - GtkTtk_gtk_widget_size_request = (Ptr_gtk_widget_size_request) Tcl_FindSymbol(interp, loadHandle, "gtk_widget_size_request"); - if (GtkTtk_gtk_widget_size_request == NULL) return TCL_ERROR; - GtkTtk_gtk_widget_style_get = (Ptr_gtk_widget_style_get) Tcl_FindSymbol(interp, loadHandle, "gtk_widget_style_get"); - if (GtkTtk_gtk_widget_style_get == NULL) return TCL_ERROR; - GtkTtk_gtk_window_new = (Ptr_gtk_window_new) Tcl_FindSymbol(interp, loadHandle, "gtk_window_new"); - if (GtkTtk_gtk_window_new == NULL) return TCL_ERROR; -#else - const char *fname = Tcl_GetString(file_name); - GModule *m = g_module_open(fname, G_MODULE_BIND_LAZY); - if (!m) { - Tcl_SetResult(interp, (char *) "cannot open module: ", TCL_STATIC); - Tcl_AppendResult(interp, fname, (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_adjustment_new", (gpointer *) &GtkTtk_gtk_adjustment_new)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_adjustment_new", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_adjustment_set_value", (gpointer *) &GtkTtk_gtk_adjustment_set_value)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_adjustment_set_value", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_arrow_new", (gpointer *) &GtkTtk_gtk_arrow_new)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_arrow_new", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_border_free", (gpointer *) &GtkTtk_gtk_border_free)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_border_free", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_button_get_relief", (gpointer *) &GtkTtk_gtk_button_get_relief)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_button_get_relief", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_button_new", (gpointer *) &GtkTtk_gtk_button_new)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_button_new", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_button_set_relief", (gpointer *) &GtkTtk_gtk_button_set_relief)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_button_set_relief", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_check_button_new", (gpointer *) &GtkTtk_gtk_check_button_new)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_check_button_new", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_combo_box_entry_new", (gpointer *) &GtkTtk_gtk_combo_box_entry_new)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_combo_box_entry_new", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_combo_box_new", (gpointer *) &GtkTtk_gtk_combo_box_new)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_combo_box_new", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_container_add", (gpointer *) &GtkTtk_gtk_container_add)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_container_add", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_disable_setlocale", (gpointer *) &GtkTtk_gtk_disable_setlocale)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_disable_setlocale", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_entry_new", (gpointer *) &GtkTtk_gtk_entry_new)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_entry_new", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_fixed_new", (gpointer *) &GtkTtk_gtk_fixed_new)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_fixed_new", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_frame_new", (gpointer *) &GtkTtk_gtk_frame_new)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_frame_new", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_hpaned_new", (gpointer *) &GtkTtk_gtk_hpaned_new)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_hpaned_new", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_hscale_new_with_range", (gpointer *) &GtkTtk_gtk_hscale_new_with_range)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_hscale_new_with_range", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_hscrollbar_new", (gpointer *) &GtkTtk_gtk_hscrollbar_new)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_hscrollbar_new", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_init_check", (gpointer *) &GtkTtk_gtk_init_check)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_init_check", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_notebook_new", (gpointer *) &GtkTtk_gtk_notebook_new)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_notebook_new", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_object_get", (gpointer *) &GtkTtk_gtk_object_get)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_object_get", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_paint_arrow", (gpointer *) &GtkTtk_gtk_paint_arrow)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_paint_arrow", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_paint_box", (gpointer *) &GtkTtk_gtk_paint_box)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_paint_box", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_paint_box_gap", (gpointer *) &GtkTtk_gtk_paint_box_gap)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_paint_box_gap", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_paint_check", (gpointer *) &GtkTtk_gtk_paint_check)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_paint_check", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_paint_extension", (gpointer *) &GtkTtk_gtk_paint_extension)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_paint_extension", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_paint_flat_box", (gpointer *) &GtkTtk_gtk_paint_flat_box)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_paint_flat_box", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_paint_focus", (gpointer *) &GtkTtk_gtk_paint_focus)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_paint_focus", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_paint_handle", (gpointer *) &GtkTtk_gtk_paint_handle)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_paint_handle", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_paint_option", (gpointer *) &GtkTtk_gtk_paint_option)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_paint_option", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_paint_resize_grip", (gpointer *) &GtkTtk_gtk_paint_resize_grip)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_paint_resize_grip", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_paint_shadow", (gpointer *) &GtkTtk_gtk_paint_shadow)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_paint_shadow", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_paint_slider", (gpointer *) &GtkTtk_gtk_paint_slider)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_paint_slider", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_progress_bar_new", (gpointer *) &GtkTtk_gtk_progress_bar_new)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_progress_bar_new", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_progress_bar_set_bar_style", (gpointer *) &GtkTtk_gtk_progress_bar_set_bar_style)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_progress_bar_set_bar_style", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_progress_bar_set_fraction", (gpointer *) &GtkTtk_gtk_progress_bar_set_fraction)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_progress_bar_set_fraction", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_progress_bar_set_orientation", (gpointer *) &GtkTtk_gtk_progress_bar_set_orientation)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_progress_bar_set_orientation", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_range_get_adjustment", (gpointer *) &GtkTtk_gtk_range_get_adjustment)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_range_get_adjustment", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_rc_get_default_files", (gpointer *) &GtkTtk_gtk_rc_get_default_files)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_rc_get_default_files", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_rc_get_style", (gpointer *) &GtkTtk_gtk_rc_get_style)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_rc_get_style", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_rc_get_theme_dir", (gpointer *) &GtkTtk_gtk_rc_get_theme_dir)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_rc_get_theme_dir", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_rc_reparse_all_for_settings", (gpointer *) &GtkTtk_gtk_rc_reparse_all_for_settings)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_rc_reparse_all_for_settings", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_rc_reset_styles", (gpointer *) &GtkTtk_gtk_rc_reset_styles)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_rc_reset_styles", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_rc_set_default_files", (gpointer *) &GtkTtk_gtk_rc_set_default_files)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_rc_set_default_files", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_settings_get_default", (gpointer *) &GtkTtk_gtk_settings_get_default)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_settings_get_default", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_statusbar_new", (gpointer *) &GtkTtk_gtk_statusbar_new)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_statusbar_new", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_style_apply_default_background", (gpointer *) &GtkTtk_gtk_style_apply_default_background)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_style_apply_default_background", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_style_attach", (gpointer *) &GtkTtk_gtk_style_attach)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_style_attach", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_style_lookup_color", (gpointer *) &GtkTtk_gtk_style_lookup_color)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_style_lookup_color", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_toolbar_new", (gpointer *) &GtkTtk_gtk_toolbar_new)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_toolbar_new", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_vpaned_new", (gpointer *) &GtkTtk_gtk_vpaned_new)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_vpaned_new", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_vscale_new_with_range", (gpointer *) &GtkTtk_gtk_vscale_new_with_range)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_vscale_new_with_range", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_vscrollbar_new", (gpointer *) &GtkTtk_gtk_vscrollbar_new)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_vscrollbar_new", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_widget_destroy", (gpointer *) &GtkTtk_gtk_widget_destroy)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_widget_destroy", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_widget_realize", (gpointer *) &GtkTtk_gtk_widget_realize)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_widget_realize", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_widget_set_size_request", (gpointer *) &GtkTtk_gtk_widget_set_size_request)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_widget_set_size_request", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_widget_size_request", (gpointer *) &GtkTtk_gtk_widget_size_request)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_widget_size_request", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_widget_style_get", (gpointer *) &GtkTtk_gtk_widget_style_get)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_widget_style_get", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "gtk_window_new", (gpointer *) &GtkTtk_gtk_window_new)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "gtk_window_new", (char *) NULL); - return TCL_ERROR; - } -#endif - return TCL_OK; -}; /* GtkTtk_InitialiseSymbols_gtk */ - -#endif /* GTKTTK_LOAD_GTK_DYNAMICALLY */ diff --git a/generic/gtkTtk_Utilities.h b/generic/gtkTtk_Utilities.h deleted file mode 100644 index 3828b54..0000000 --- a/generic/gtkTtk_Utilities.h +++ /dev/null @@ -1,193 +0,0 @@ -/* - * gtkTtk_Utilities.h - * ---------------------- - * - * This file is part of the gtkTtk package, a Tk/Tile based theme that uses - * Gtk/GNOME for drawing. - * - * Copyright (C) 2004-2008 by: - * Georgios Petasis, petasis@iit.demokritos.gr, - * Software and Knowledge Engineering Laboratory, - * Institute of Informatics and Telecommunications, - * National Centre for Scientific Research (NCSR) "Demokritos", - * Aghia Paraskevi, 153 10, Athens, Greece. - */ - -#include "gtkTtk_GtkHeaders.h" -#include "gtkTtk_Elements.h" -#include - -#define NO_GTK_STYLE_ENGINE {/*printf("NULL qApp\n");fflush(NULL);*/return;} - -#define GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE \ - if (!GtkTtk_GtkInitialised()) return; - -#define GTKTTK_ENSURE_WIDGET_OK \ - if (!widget) return; - -#define GTKTTK_ATTACH_STYLE_TO_WIDGET \ - style = GtkTtk_gtk_style_attach(style, widget->window); - -#define GTKTTK_WIDGET_CACHE_DEFINITION \ - GtkTtk_WidgetCache *wc = (GtkTtk_WidgetCache *) clientData; - -#define GTKTTK_ORIENTATION_DEFINITION \ - int orientation = wc->orientation; - -#define GTKTTK_GTK_DRAWABLE_DEFINITIONS \ - GtkTtk_WidgetCache *wc = (GtkTtk_WidgetCache *) clientData; \ - GdkPixmap *gdkDrawable = NULL; \ - GtkStyle *style = NULL; \ - GtkStateType gtkState = GTK_STATE_NORMAL; \ - GtkShadowType gtkShadow = GTK_SHADOW_NONE; - -#define GTKTTK_SETUP_GTK_DRAWABLE \ - GTKTTK_SETUP_GTK_DRAWABLE_PIXMAP_SIZE(b.width, b.height) - -#define GTKTTK_SETUP_GTK_DRAWABLE_PIXMAP_SIZE(pw, ph) \ - if (!wc) return; \ - style = GtkTtk_GetGtkWindowStyle(wc->gtkWindow); \ - if (!style) return; \ - gdkDrawable = GtkTtk_gdk_pixmap_new(wc->gtkWindow->window, pw, ph, -1); \ - style = GtkTtk_GetGtkWindowStyle(wc->gtkWindow); - -#define GTKTTK_STYLE_BACKGROUND_DEFAULT \ - if (wc && wc->gtkWindow) style = GtkTtk_GetGtkWindowStyle(wc->gtkWindow); \ - if (!style) return; - -#define GTKTTK_STYLE_FROM_WIDGET \ - style = GtkTtk_GetGtkWindowStyle(widget); \ - if (!style) style = GtkTtk_GetGtkWindowStyle(wc->gtkWindow); \ - if (!style) return; - -#define GTKTTK_DRAWABLE_FROM_WIDGET_SIZE(pw, ph) \ - gdkDrawable = GtkTtk_gdk_pixmap_new(widget->window, pw, ph, -1); - -#define GTKTTK_DRAWABLE_FROM_WIDGET \ - GTKTTK_DRAWABLE_FROM_WIDGET_SIZE(b.width, b.height) - -// #define GTKTTK_DRAWABLE_FROM_WIDGET \ -// gdkDrawable = gdk_pixmap_foreign_new(Tk_WindowId(tkwin)); \ -// GdkColormap gdkColormap = gdk_x11_colormap_foreign_new(gdkx_visual_get(Tk_Visual(tkwin)), Tk_Colormap(tkwin)); \ -// gdk_drawable_set_colormap(gdkDrawable, gdkColormap); - -#define GTKTTK_DEFAULT_BACKGROUND_SIZE(pw, ph) \ - GtkTtk_gtk_style_apply_default_background(style, gdkDrawable, TRUE, \ - gtkState, NULL, 0, 0, pw, ph); - -#define GTKTTK_DEFAULT_BACKGROUND \ - GTKTTK_DEFAULT_BACKGROUND_SIZE(b.width, b.height) - -#define GTKTTK_CLEANUP_GTK_DRAWABLE \ - if (gdkDrawable) GtkTtk_g_object_unref(gdkDrawable); - -#define GTKTTK_SETUP_STATE_SHADOW(statemap, shadowmap) \ - gtkState = (GtkStateType) \ - GtkTtk_StateTableLookup(statemap, state); \ - gtkShadow = (GtkShadowType) \ - GtkTtk_StateTableLookup(shadowmap, state); - -#define GTKTTK_SETUP_WIDGET_SIZE(width, height) \ - GtkTtk_gtk_widget_set_size_request(widget, width, height); - -#define GTKTTK_GET_WIDGET_SIZE(widthPtr, heightPtr) \ - if (widget) { \ - GtkRequisition size; \ - GtkTtk_gtk_widget_size_request(widget, &size); \ - widthPtr = size.width; \ - heightPtr = size.height; \ - } - -#define GTKTTK_WIDGET_SETUP_DEFAULT(obj) \ - int defaultState = TTK_BUTTON_DEFAULT_DISABLED; \ - int has_default = (defaultState == TTK_BUTTON_DEFAULT_ACTIVE); \ - /*Ttk_GetButtonDefaultStateFromObj(NULL, obj, &defaultState);*/ - -#ifdef GTKTTK_LOAD_GTK_DYNAMICALLY - -#define GTKTTK_WIDGET_SET_FOCUS(widget) - -#define GTKTTK_WIDGET_SET_DEFAULT(widget, obj) \ - int defaultState = TTK_BUTTON_DEFAULT_DISABLED; \ - int has_default = (defaultState == TTK_BUTTON_DEFAULT_ACTIVE); - -#else /* GTKTTK_LOAD_GTK_DYNAMICALLY */ - -#define GTKTTK_WIDGET_SET_FOCUS(widget) \ - if (state & TTK_STATE_FOCUS) { \ - GTK_WIDGET_SET_FLAGS(widget, GTK_HAS_FOCUS); \ - } else { \ - GTK_WIDGET_UNSET_FLAGS(widget, GTK_HAS_FOCUS); \ - } - -#define GTKTTK_WIDGET_SET_DEFAULT(widget, obj) \ - int defaultState = TTK_BUTTON_DEFAULT_DISABLED; \ - int has_default = (defaultState == TTK_BUTTON_DEFAULT_ACTIVE); \ - /*Ttk_GetButtonDefaultStateFromObj(NULL, obj, &defaultState);*/ \ - if (has_default) { \ - GTK_WIDGET_SET_FLAGS(widget, GTK_HAS_DEFAULT); \ - } else { \ - GTK_WIDGET_UNSET_FLAGS(widget, GTK_HAS_DEFAULT); \ - } -#endif /* GTKTTK_LOAD_GTK_DYNAMICALLY */ - -#define GTKTTK_DEBUG_PRINT_BOX \ - printf("x=%d, y=%d, w=%d, h=%d\n", b.x, b.y, b.width, b.height); \ - fflush(0); - -#define GTKTTK_DEBUG_PRINT_TK_WIDGET \ - printf("Widget: %s,p=%p\n", Tk_PathName(tkwin), tkwin); \ - fflush(0); - -#define GTKTTK_GTKBORDER_TO_PADDING(border) \ - Ttk_MakePadding(border.left, border.top, border.right, border.bottom) - -TCL_DECLARE_MUTEX(gtkTtkMutex); - -/* Global Symbols */ - -/* Helper Functions */ -extern int GtkTtk_GtkInitialised(void); -extern GtkWidget *GtkTtk_GetGtkWindow(void); -extern GtkStyle *GtkTtk_GetGtkWindowStyle(GtkWidget *gtkWindow); -extern GtkStyle *GtkTtk_GetGtkStyle(void); - -extern unsigned int GtkTtk_StateTableLookup(Ttk_StateTable *, unsigned int); -extern void GtkTtk_CopyGtkPixmapOnToDrawable(GdkPixmap *, Drawable, Tk_Window, - int, int, int, int, int, int); -extern void GtkTtk_StateInfo(int, GtkStateType, - GtkShadowType, Tk_Window, GtkWidget *widget = NULL); - -extern GtkWidget *GtkTtk_GetArrow(GtkTtk_WidgetCache* wc); -extern GtkWidget *GtkTtk_GetButton(GtkTtk_WidgetCache* wc); -extern GtkWidget *GtkTtk_GetCheckButton(GtkTtk_WidgetCache* wc); -extern GtkWidget *GtkTtk_GetRadioButton(GtkTtk_WidgetCache* wc); -extern GtkWidget *GtkTtk_GetToolBar(GtkTtk_WidgetCache* wc); -extern GtkWidget *GtkTtk_GetToolButton(GtkTtk_WidgetCache* wc); -extern GtkWidget *GtkTtk_GetFrame(GtkTtk_WidgetCache* wc); -extern GtkWidget *GtkTtk_GetEntry(GtkTtk_WidgetCache* wc); -extern GtkWidget *GtkTtk_GetCombobox(GtkTtk_WidgetCache* wc); -extern GtkWidget *GtkTtk_GetComboboxEntry(GtkTtk_WidgetCache* wc); -extern GtkWidget *GtkTtk_GetHScrollBar(GtkTtk_WidgetCache* wc); -extern GtkWidget *GtkTtk_GetVScrollBar(GtkTtk_WidgetCache* wc); -extern GtkWidget *GtkTtk_GetScrollBar(GtkTtk_WidgetCache* wc); -extern GtkWidget *GtkTtk_GetHScale(GtkTtk_WidgetCache* wc); -extern GtkWidget *GtkTtk_GetVScale(GtkTtk_WidgetCache* wc); -extern GtkWidget *GtkTtk_GetScale(GtkTtk_WidgetCache* wc); -extern GtkWidget *GtkTtk_GetHProgressBar(GtkTtk_WidgetCache* wc); -extern GtkWidget *GtkTtk_GetVProgressBar(GtkTtk_WidgetCache* wc); -extern GtkWidget *GtkTtk_GetProgressBar(GtkTtk_WidgetCache* wc); -extern GtkWidget *GtkTtk_GetStatusBar(GtkTtk_WidgetCache* wc); -extern GtkWidget *GtkTtk_GetPaned(GtkTtk_WidgetCache* wc); -extern GtkWidget *GtkTtk_GetNotebook(GtkTtk_WidgetCache* wc); -#if 0 -extern void GtkTtk_StoreStyleNameLowers(GtkTtk_WidgetCache *wc); -extern bool GtkTtk_ThemeIs(GtkTtk_WidgetCache *wc, const char* name); -extern void GtkTtk_SetFocus(bool focus); -#endif - -extern unsigned int GtkTtk_StateShadowTableLookup(GtkTtk_StateTable*, - unsigned int, GtkStateType&, GtkShadowType&, - unsigned int section = GTKTTK_SECTION_ALL); -extern double GtkTtk_ValueFromSlider(GtkTtk_WidgetCache *wc, Tk_Window tkwin, - Ttk_Box b); diff --git a/generic/gtkTtk_Arrows.cpp b/generic/gttk_Arrows.cpp similarity index 84% rename from generic/gtkTtk_Arrows.cpp rename to generic/gttk_Arrows.cpp index 59c77f0..008dda0 100644 --- a/generic/gtkTtk_Arrows.cpp +++ b/generic/gttk_Arrows.cpp @@ -1,8 +1,8 @@ /* - * gtkTtk_Arrows.cpp + * gttk_Arrows.cpp * ------------------- * - * This file is part of the gtkTtk package, a Tk/Tile based theme that uses + * This file is part of the gttk package, a Tk/Tile based theme that uses * Gtk/GNOME for drawing. * * Copyright (C) 2004-2008 by: @@ -13,9 +13,9 @@ * Aghia Paraskevi, 153 10, Athens, Greece. */ -#include "gtkTtk_Utilities.h" -#include "gtkTtk_TkHeaders.h" -#include "gtkTtk_WidgetDefaults.h" +#include "gttk_Utilities.h" +#include "gttk_TkHeaders.h" +#include "gttk_WidgetDefaults.h" #if 0 /* @@ -56,7 +56,7 @@ ArrowElementGeometry( void *clientData, void *elementRecord, Tk_Window tkwin, int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr) { - if (!GtkTtk_GtkInitialised()) NO_GTK_STYLE_ENGINE; + if (!gttk_GtkInitialised()) NO_GTK_STYLE_ENGINE; ArrowElement *arrow = (ArrowElement *) elementRecord; int size = 12; @@ -68,10 +68,10 @@ static void ArrowElementDraw(void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned int state) { - if (!GtkTtk_GtkInitialised()) NO_GTK_STYLE_ENGINE; + if (!gttk_GtkInitialised()) NO_GTK_STYLE_ENGINE; //ArrowElement *arrow = (ArrowElement *) elementRecord; int direction = *(int *)clientData; - QStyle::SFlags sflags = GtkTtk_StateTableLookup(arrow_statemap ,state); + QStyle::SFlags sflags = gttk_StateTableLookup(arrow_statemap ,state); QStyle::PrimitiveElement element = QStyle::PE_ArrowUp; //if (state == GTK_STATE_INSENSITIVE) // sflags |= QStyle::Style_Off; @@ -85,22 +85,22 @@ ArrowElementDraw(void *clientData, void *elementRecord, case ARROW_LEFT: element = QStyle::PE_ArrowLeft; break; case ARROW_RIGHT: element = QStyle::PE_ArrowRight; break; } - Tcl_MutexLock(>kTtkMutex); + Tcl_MutexLock(>tkMutex); QPixmap pixmap(b.width, b.height); QPainter painter(&pixmap); - if ((GtkTtk_QPixmap_BackgroundTile) && - (!GtkTtk_QPixmap_BackgroundTile->isNull())) { + if ((gttk_QPixmap_BackgroundTile) && + (!gttk_QPixmap_BackgroundTile->isNull())) { painter.fillRect(0, 0, b.width, b.height, QBrush(QColor(255,255,255), - *GtkTtk_QPixmap_BackgroundTile)); + *gttk_QPixmap_BackgroundTile)); } else { painter.fillRect(0, 0, b.width, b.height, qApp->palette().active().brush(QColorGroup::Background)); } qApp->style().drawPrimitive(element, &painter, QRect(0, 0, b.width, b.height), qApp->palette().active(), sflags); - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height, b.x, b.y); - Tcl_MutexUnlock(>kTtkMutex); + Tcl_MutexUnlock(>tkMutex); } static Ttk_ElementSpec ArrowElementSpec = @@ -117,7 +117,7 @@ static Ttk_ElementSpec ArrowElementSpec = */ -int GtkTtk_Init_Arrows(Tcl_Interp *interp, Ttk_Theme themePtr) +int gttk_Init_Arrows(Tcl_Interp *interp, Ttk_Theme themePtr) { /* * Register elements: diff --git a/generic/gtkTtk_Background.cpp b/generic/gttk_Background.cpp similarity index 72% rename from generic/gtkTtk_Background.cpp rename to generic/gttk_Background.cpp index 0a9e136..63fa812 100644 --- a/generic/gtkTtk_Background.cpp +++ b/generic/gttk_Background.cpp @@ -1,8 +1,8 @@ /* - * gtkTtk_Background.cpp + * gttk_Background.cpp * ----------------------- * - * This file is part of the gtkTtk package, a Tk/Tile based theme that uses + * This file is part of the gttk package, a Tk/Tile based theme that uses * Gtk/GNOME for drawing. * * Copyright (C) 2004-2008 by: @@ -13,9 +13,9 @@ * Aghia Paraskevi, 153 10, Athens, Greece. */ -#include "gtkTtk_Utilities.h" -#include "gtkTtk_TkHeaders.h" -#include "gtkTtk_WidgetDefaults.h" +#include "gttk_Utilities.h" +#include "gttk_TkHeaders.h" +#include "gttk_WidgetDefaults.h" /* * Map between Tk/Tile & Gtk/GNOME state flags. @@ -44,18 +44,18 @@ static void BackgroundElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned state) { - GTKTTK_GTK_DRAWABLE_DEFINITIONS; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - GTKTTK_SETUP_GTK_DRAWABLE; - //GtkTtk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, - // GTKTTK_SECTION_ALL); - GTKTTK_DEFAULT_BACKGROUND; - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + GTTK_GTK_DRAWABLE_DEFINITIONS; + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GTTK_SETUP_GTK_DRAWABLE; + //gttk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, + // GTTK_SECTION_ALL); + GTTK_DEFAULT_BACKGROUND; + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height, b.x, b.y); - GTKTTK_CLEANUP_GTK_DRAWABLE; + GTTK_CLEANUP_GTK_DRAWABLE; } -static Ttk_ElementSpec GtkTtk_BackgroundElementSpec = { +static Ttk_ElementSpec gttk_BackgroundElementSpec = { TK_STYLE_VERSION_2, sizeof(BackgroundElement), BackgroundElementOptions, @@ -84,22 +84,22 @@ static void BorderElementGeometry( void *clientData, void *elementRecord, Tk_Window tkwin, int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr) { - if (!GtkTtk_GtkInitialised()) NO_GTK_STYLE_ENGINE; - //Tcl_MutexLock(>kTtkMutex); + if (!gttk_GtkInitialised()) NO_GTK_STYLE_ENGINE; + //Tcl_MutexLock(>tkMutex); BorderElement *border = (BorderElement*) elementRecord; int borderWidth = 0; Tcl_GetIntFromObj(NULL, border->borderWidthObj, &borderWidth); *paddingPtr = Ttk_UniformPadding((short)borderWidth+2); - //Tcl_MutexUnlock(>kTtkMutex); + //Tcl_MutexUnlock(>tkMutex); } static void BorderElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned state) { - if (!GtkTtk_GtkInitialised()) NO_GTK_STYLE_ENGINE; - NULL_PROXY_WIDGET(GtkTtk_QWidget_WidgetParent); - Tcl_MutexLock(>kTtkMutex); + if (!gttk_GtkInitialised()) NO_GTK_STYLE_ENGINE; + NULL_PROXY_WIDGET(gttk_QWidget_WidgetParent); + Tcl_MutexLock(>tkMutex); BorderElement *border = (BorderElement*) elementRecord; int relief = TK_RELIEF_FLAT; int borderWidth = 0; @@ -125,23 +125,23 @@ static void BorderElementDraw( QPixmap pixmap(b.width, b.height); QPainter painter(&pixmap); - if (wc->GtkTtk_QPixmap_BackgroundTile && - !(wc->GtkTtk_QPixmap_BackgroundTile->isNull())) { + if (wc->gttk_QPixmap_BackgroundTile && + !(wc->gttk_QPixmap_BackgroundTile->isNull())) { painter.fillRect(0, 0, b.width, b.height, QBrush(QColor(255,255,255), - *(wc->GtkTtk_QPixmap_BackgroundTile))); + *(wc->gttk_QPixmap_BackgroundTile))); } else { painter.fillRect(0, 0, b.width, b.height, qApp->palette().active().background()); } if (borderWidth) { - wc->GtkTtk_Style->drawPrimitive(QStyle::PE_GroupBoxFrame, &painter, + wc->gttk_Style->drawPrimitive(QStyle::PE_GroupBoxFrame, &painter, QRect(0, 0, b.width, b.height), qApp->palette().active(), sflags, QStyleOption(borderWidth, 0)); } - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height, b.x, b.y); - Tcl_MutexUnlock(>kTtkMutex); + Tcl_MutexUnlock(>tkMutex); } static Ttk_ElementSpec BorderElementSpec = { @@ -157,14 +157,14 @@ static Ttk_ElementSpec BorderElementSpec = { * +++ Widget layout. */ -int GtkTtk_Init_Background(Tcl_Interp *interp, - GtkTtk_WidgetCache **wc, Ttk_Theme themePtr) +int gttk_Init_Background(Tcl_Interp *interp, + gttk_WidgetCache **wc, Ttk_Theme themePtr) { /* * Register elements: */ Ttk_RegisterElement(interp, themePtr, "background", - &GtkTtk_BackgroundElementSpec, (void *) wc[0]); + >tk_BackgroundElementSpec, (void *) wc[0]); //Ttk_RegisterElement(interp, themePtr, "border", // &BorderElementSpec, NULL); /* @@ -172,4 +172,4 @@ int GtkTtk_Init_Background(Tcl_Interp *interp, */ return TCL_OK; -}; /* GtkTtk_Init_Background */ +}; /* gttk_Init_Background */ diff --git a/generic/gtkTtk_Button.cpp b/generic/gttk_Button.cpp similarity index 75% rename from generic/gtkTtk_Button.cpp rename to generic/gttk_Button.cpp index 67e53e1..6934009 100644 --- a/generic/gtkTtk_Button.cpp +++ b/generic/gttk_Button.cpp @@ -1,8 +1,8 @@ /* - * gtkTtk_Button.cpp + * gttk_Button.cpp * ------------------- * - * This file is part of the gtkTtk package, a Tk/Tile based theme that uses + * This file is part of the gttk package, a Tk/Tile based theme that uses * Gtk/GNOME for drawing. * * Copyright (C) 2004-2008 by: @@ -13,9 +13,9 @@ * Aghia Paraskevi, 153 10, Athens, Greece. */ -#include "gtkTtk_Utilities.h" -#include "gtkTtk_TkHeaders.h" -#include "gtkTtk_WidgetDefaults.h" +#include "gttk_Utilities.h" +#include "gttk_TkHeaders.h" +#include "gttk_WidgetDefaults.h" typedef struct { Tcl_Obj *defaultStateObj; @@ -31,13 +31,13 @@ static void ButtonElementGeometry( void *clientData, void *elementRecord, Tk_Window tkwin, int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr) { - GTKTTK_WIDGET_CACHE_DEFINITION; + GTTK_WIDGET_CACHE_DEFINITION; gint focus_width; gint focus_pad; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - GtkWidget *widget = GtkTtk_GetButton(wc); - GTKTTK_ENSURE_WIDGET_OK; - GtkTtk_gtk_widget_style_get(widget, + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GtkWidget *widget = gttk_GetButton(wc); + GTTK_ENSURE_WIDGET_OK; + gttk_gtk_widget_style_get(widget, "focus-line-width", &focus_width, "focus-padding", &focus_pad, NULL); *paddingPtr = Ttk_UniformPadding(PushButtonUniformPadding + @@ -48,7 +48,7 @@ static void ButtonElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned int state) { - GTKTTK_GTK_DRAWABLE_DEFINITIONS; + GTTK_GTK_DRAWABLE_DEFINITIONS; gint width, height; gint x, y; gint border_width; @@ -58,43 +58,43 @@ static void ButtonElementDraw( gboolean interior_focus; gint focus_width; gint focus_pad; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - GtkWidget *widget = GtkTtk_GetButton(wc); + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GtkWidget *widget = gttk_GetButton(wc); ButtonElement *bd = (ButtonElement *) elementRecord; GtkButton *button = (GtkButton *) widget; - GTKTTK_ENSURE_WIDGET_OK; - GTKTTK_STYLE_FROM_WIDGET; - GTKTTK_DRAWABLE_FROM_WIDGET; - GTKTTK_DEFAULT_BACKGROUND; - GtkTtk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, - GTKTTK_SECTION_BUTTONS|GTKTTK_SECTION_ALL); - GTKTTK_WIDGET_SET_FOCUS(widget); - GTKTTK_WIDGET_SET_DEFAULT(widget, bd->defaultStateObj); - // GtkTtk_StateInfo(state, gtkState, gtkShadow, tkwin, widget); - // GtkTtk_gtk_paint_box(style, gdkDrawable, gtkState, gtkShadow, NULL, + GTTK_ENSURE_WIDGET_OK; + GTTK_STYLE_FROM_WIDGET; + GTTK_DRAWABLE_FROM_WIDGET; + GTTK_DEFAULT_BACKGROUND; + gttk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, + GTTK_SECTION_BUTTONS|GTTK_SECTION_ALL); + GTTK_WIDGET_SET_FOCUS(widget); + GTTK_WIDGET_SET_DEFAULT(widget, bd->defaultStateObj); + // gttk_StateInfo(state, gtkState, gtkShadow, tkwin, widget); + // gttk_gtk_paint_box(style, gdkDrawable, gtkState, gtkShadow, NULL, // widget, has_default ? "buttondefault" : "button", // 0, 0, b.width, b.height); - // GtkTtk_gtk_paint_focus(style, gdkDrawable, gtkState, + // gttk_gtk_paint_focus(style, gdkDrawable, gtkState, // NULL, widget, "button", 0, 0, b.width, b.height); /* * The following was taken from GTK+ button drawing code. */ border_width = ((GtkContainer*) widget)->border_width; - GtkTtk_gtk_widget_style_get(widget, + gttk_gtk_widget_style_get(widget, "default-border", &tmp_border, "default-outside-border", &tmp_outside_border, "interior-focus", &interior_focus, NULL); if (tmp_border) { default_border = *tmp_border; - GtkTtk_gtk_border_free(tmp_border); + gttk_gtk_border_free(tmp_border); } if (tmp_outside_border) { default_outside_border = *tmp_outside_border; - GtkTtk_gtk_border_free(tmp_outside_border); + gttk_gtk_border_free(tmp_outside_border); } - GtkTtk_gtk_widget_style_get(widget, + gttk_gtk_widget_style_get(widget, "focus-line-width", &focus_width, "focus-padding", &focus_pad, NULL); @@ -104,7 +104,7 @@ static void ButtonElementDraw( height = b.height - border_width * 2; if (has_default && button->relief == GTK_RELIEF_NORMAL) { - GtkTtk_gtk_paint_box(style, gdkDrawable, GTK_STATE_NORMAL, GTK_SHADOW_IN, + gttk_gtk_paint_box(style, gdkDrawable, GTK_STATE_NORMAL, GTK_SHADOW_IN, NULL, widget, "buttondefault", x, y, width, height); x += default_border.left; y += default_border.top; @@ -126,7 +126,7 @@ static void ButtonElementDraw( if (button->relief != GTK_RELIEF_NONE || (state & TTK_STATE_PRESSED) || (state & TTK_STATE_ACTIVE) ) { - GtkTtk_gtk_paint_box(style, gdkDrawable, gtkState, gtkShadow, NULL, + gttk_gtk_paint_box(style, gdkDrawable, gtkState, gtkShadow, NULL, widget, "button", x, y, width, height); } @@ -135,7 +135,7 @@ static void ButtonElementDraw( gint child_displacement_y; gboolean displace_focus; - GtkTtk_gtk_widget_style_get(widget, + gttk_gtk_widget_style_get(widget, "child-displacement-y", &child_displacement_y, "child-displacement-x", &child_displacement_x, "displace-focus", &displace_focus, NULL); @@ -157,13 +157,13 @@ static void ButtonElementDraw( y += child_displacement_y; } - GtkTtk_gtk_paint_focus(style, gdkDrawable, gtkState, NULL, widget, + gttk_gtk_paint_focus(style, gdkDrawable, gtkState, NULL, widget, "button", x, y, width, height); } - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height, b.x, b.y); - GTKTTK_CLEANUP_GTK_DRAWABLE; + GTTK_CLEANUP_GTK_DRAWABLE; } static Ttk_ElementSpec ButtonElementSpec = { @@ -191,8 +191,8 @@ TTK_BEGIN_LAYOUT(ButtonLayout) TTK_NODE("Button.label", TTK_FILL_BOTH))) TTK_END_LAYOUT -int GtkTtk_Init_Button(Tcl_Interp *interp, - GtkTtk_WidgetCache **wc, Ttk_Theme themePtr) +int gttk_Init_Button(Tcl_Interp *interp, + gttk_WidgetCache **wc, Ttk_Theme themePtr) { /* * Register elements: @@ -205,4 +205,4 @@ int GtkTtk_Init_Button(Tcl_Interp *interp, */ Ttk_RegisterLayout(themePtr, "TButton", ButtonLayout); return TCL_OK; -}; /* GtkTtk_Init_Button */ +}; /* gttk_Init_Button */ diff --git a/generic/gtkTtk_CheckButton.cpp b/generic/gttk_CheckButton.cpp similarity index 66% rename from generic/gtkTtk_CheckButton.cpp rename to generic/gttk_CheckButton.cpp index 2f4a256..4e46567 100644 --- a/generic/gtkTtk_CheckButton.cpp +++ b/generic/gttk_CheckButton.cpp @@ -1,8 +1,8 @@ /* - * gtkTtk_CheckButton.cpp + * gttk_CheckButton.cpp * ------------------------ * - * This file is part of the gtkTtk package, a Tk/Tile based theme that uses + * This file is part of the gttk package, a Tk/Tile based theme that uses * Gtk/GNOME for drawing. * * Copyright (C) 2004-2008 by: @@ -13,9 +13,9 @@ * Aghia Paraskevi, 153 10, Athens, Greece. */ -#include "gtkTtk_Utilities.h" -#include "gtkTtk_TkHeaders.h" -#include "gtkTtk_WidgetDefaults.h" +#include "gttk_Utilities.h" +#include "gttk_TkHeaders.h" +#include "gttk_WidgetDefaults.h" typedef struct { } CheckButtonIndicatorElement; @@ -29,13 +29,13 @@ static void CheckButtonIndicatorElementGeometry( void *clientData, void *elementRecord, Tk_Window tkwin, int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr) { - GTKTTK_WIDGET_CACHE_DEFINITION; + GTTK_WIDGET_CACHE_DEFINITION; gint size, spacing = CheckButtonHorizontalPadding; gint focus_width, focus_pad; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - GtkWidget *widget = GtkTtk_GetCheckButton(wc); - GTKTTK_ENSURE_WIDGET_OK; - GtkTtk_gtk_widget_style_get(widget, + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GtkWidget *widget = gttk_GetCheckButton(wc); + GTTK_ENSURE_WIDGET_OK; + gttk_gtk_widget_style_get(widget, "indicator-size", &size, "indicator-spacing", &spacing, "focus-line-width", &focus_width, @@ -49,28 +49,28 @@ static void CheckButtonIndicatorElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned state) { - GTKTTK_GTK_DRAWABLE_DEFINITIONS; + GTTK_GTK_DRAWABLE_DEFINITIONS; gint indicator_size, x, y; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - GtkWidget *widget = GtkTtk_GetCheckButton(wc); - GTKTTK_ENSURE_WIDGET_OK; - GTKTTK_DRAWABLE_FROM_WIDGET; - style = GtkTtk_GetGtkWindowStyle(wc->gtkWindow); - GTKTTK_DEFAULT_BACKGROUND; - GTKTTK_STYLE_FROM_WIDGET; - GTKTTK_WIDGET_SET_FOCUS(widget); - GtkTtk_gtk_widget_style_get(widget, + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GtkWidget *widget = gttk_GetCheckButton(wc); + GTTK_ENSURE_WIDGET_OK; + GTTK_DRAWABLE_FROM_WIDGET; + style = gttk_GetGtkWindowStyle(wc->gtkWindow); + GTTK_DEFAULT_BACKGROUND; + GTTK_STYLE_FROM_WIDGET; + GTTK_WIDGET_SET_FOCUS(widget); + gttk_gtk_widget_style_get(widget, "indicator-size", &indicator_size, NULL); - GtkTtk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, - GTKTTK_SECTION_BUTTONS|GTKTTK_SECTION_ALL); - // GtkTtk_StateInfo(state, gtkState, gtkShadow, tkwin, widget); + gttk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, + GTTK_SECTION_BUTTONS|GTTK_SECTION_ALL); + // gttk_StateInfo(state, gtkState, gtkShadow, tkwin, widget); x = (b.width - indicator_size) / 2; y = (b.height - indicator_size) / 2; - GtkTtk_gtk_paint_check(style, gdkDrawable, gtkState, gtkShadow, NULL, + gttk_gtk_paint_check(style, gdkDrawable, gtkState, gtkShadow, NULL, widget, "checkbutton", x, y, indicator_size, indicator_size); - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height, b.x, b.y); - GTKTTK_CLEANUP_GTK_DRAWABLE; + GTTK_CLEANUP_GTK_DRAWABLE; } static Ttk_ElementSpec CheckButtonIndicatorElementSpec = { @@ -93,13 +93,13 @@ static void CheckButtonBorderElementGeometry( void *clientData, void *elementRecord, Tk_Window tkwin, int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr) { - GTKTTK_WIDGET_CACHE_DEFINITION; + GTTK_WIDGET_CACHE_DEFINITION; gint focus_width; gint focus_pad; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - GtkWidget *widget = GtkTtk_GetCheckButton(wc); - GTKTTK_ENSURE_WIDGET_OK; - GtkTtk_gtk_widget_style_get(widget, + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GtkWidget *widget = gttk_GetCheckButton(wc); + GTTK_ENSURE_WIDGET_OK; + gttk_gtk_widget_style_get(widget, "focus-line-width", &focus_width, "focus-padding", &focus_pad, NULL); *paddingPtr = Ttk_UniformPadding(focus_width + focus_pad); @@ -109,31 +109,31 @@ static void CheckButtonBorderElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned state) { - GTKTTK_GTK_DRAWABLE_DEFINITIONS; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - GtkWidget *widget = GtkTtk_GetCheckButton(wc); - GTKTTK_ENSURE_WIDGET_OK; - GTKTTK_DRAWABLE_FROM_WIDGET; - GTKTTK_STYLE_BACKGROUND_DEFAULT; - GTKTTK_DEFAULT_BACKGROUND; + GTTK_GTK_DRAWABLE_DEFINITIONS; + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GtkWidget *widget = gttk_GetCheckButton(wc); + GTTK_ENSURE_WIDGET_OK; + GTTK_DRAWABLE_FROM_WIDGET; + GTTK_STYLE_BACKGROUND_DEFAULT; + GTTK_DEFAULT_BACKGROUND; if (state & TTK_STATE_FOCUS) { gint border_width = ((GtkContainer*) widget)->border_width; gint focus_width; gint focus_pad; - GTKTTK_STYLE_FROM_WIDGET; - GTKTTK_WIDGET_SET_FOCUS(widget); - GtkTtk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, - GTKTTK_SECTION_BUTTONS|GTKTTK_SECTION_ALL); - GtkTtk_gtk_widget_style_get(widget, + GTTK_STYLE_FROM_WIDGET; + GTTK_WIDGET_SET_FOCUS(widget); + gttk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, + GTTK_SECTION_BUTTONS|GTTK_SECTION_ALL); + gttk_gtk_widget_style_get(widget, "focus-line-width", &focus_width, "focus-padding", &focus_pad, NULL); - GtkTtk_gtk_paint_focus(style, gdkDrawable, gtkState, NULL, widget, + gttk_gtk_paint_focus(style, gdkDrawable, gtkState, NULL, widget, "checkbutton", b.x + border_width, b.y + border_width, b.width - 2 * border_width, b.height - 2 * border_width); } - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height, b.x, b.y); - GTKTTK_CLEANUP_GTK_DRAWABLE; + GTTK_CLEANUP_GTK_DRAWABLE; } static Ttk_ElementSpec CheckButtonBorderElementSpec = { @@ -164,8 +164,8 @@ TTK_BEGIN_LAYOUT(CheckbuttonLayout) TTK_NODE("Checkbutton.label", TTK_PACK_LEFT|TTK_STICK_W|TTK_FILL_BOTH))) TTK_END_LAYOUT -int GtkTtk_Init_CheckButton(Tcl_Interp *interp, - GtkTtk_WidgetCache **wc, Ttk_Theme themePtr) +int gttk_Init_CheckButton(Tcl_Interp *interp, + gttk_WidgetCache **wc, Ttk_Theme themePtr) { /* * Register elements: @@ -181,4 +181,4 @@ int GtkTtk_Init_CheckButton(Tcl_Interp *interp, Ttk_RegisterLayout(themePtr, "TCheckbutton", CheckbuttonLayout); return TCL_OK; -}; /* GtkTtk_Init_CheckButton */ +}; /* gttk_Init_CheckButton */ diff --git a/generic/gtkTtk_Combobox.cpp b/generic/gttk_Combobox.cpp similarity index 55% rename from generic/gtkTtk_Combobox.cpp rename to generic/gttk_Combobox.cpp index 4f54ffd..8566b21 100644 --- a/generic/gtkTtk_Combobox.cpp +++ b/generic/gttk_Combobox.cpp @@ -1,8 +1,8 @@ /* - * gtkTtk_Combobox.cpp + * gttk_Combobox.cpp * --------------------- * - * This file is part of the gtkTtk package, a Tk/Tile based theme that uses + * This file is part of the gttk package, a Tk/Tile based theme that uses * Gtk/GNOME for drawing. * * Copyright (C) 2004-2008 by: @@ -13,9 +13,9 @@ * Aghia Paraskevi, 153 10, Athens, Greece. */ -#include "gtkTtk_Utilities.h" -#include "gtkTtk_TkHeaders.h" -#include "gtkTtk_WidgetDefaults.h" +#include "gttk_Utilities.h" +#include "gttk_TkHeaders.h" +#include "gttk_WidgetDefaults.h" typedef struct { } ComboboxFieldElement; @@ -29,10 +29,10 @@ static void ComboboxFieldElementGeometry( void *clientData, void *elementRecord, Tk_Window tkwin, int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr) { - GTKTTK_WIDGET_CACHE_DEFINITION; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - GtkWidget *widget = GtkTtk_GetComboboxEntry(wc); - GTKTTK_ENSURE_WIDGET_OK; + GTTK_WIDGET_CACHE_DEFINITION; + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GtkWidget *widget = gttk_GetComboboxEntry(wc); + GTTK_ENSURE_WIDGET_OK; int xt = widget->style->xthickness; int yt = widget->style->ythickness; *paddingPtr = Ttk_MakePadding(xt + EntryUniformPadding, @@ -45,37 +45,37 @@ static void ComboboxFieldElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned state) { - GTKTTK_GTK_DRAWABLE_DEFINITIONS; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GTTK_GTK_DRAWABLE_DEFINITIONS; + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; GtkWidget *widget = NULL; if (state & (TTK_STATE_DISABLED|TTK_STATE_READONLY)) { - widget = GtkTtk_GetCombobox(wc); - GTKTTK_ENSURE_WIDGET_OK; - GTKTTK_DRAWABLE_FROM_WIDGET; - GTKTTK_STYLE_BACKGROUND_DEFAULT; - GTKTTK_DEFAULT_BACKGROUND; - GTKTTK_STYLE_FROM_WIDGET; - GtkTtk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, - GTKTTK_SECTION_BUTTONS|GTKTTK_SECTION_ALL); - GTKTTK_WIDGET_SET_FOCUS(widget); - GtkTtk_gtk_paint_box(style, gdkDrawable, gtkState, gtkShadow, NULL, + widget = gttk_GetCombobox(wc); + GTTK_ENSURE_WIDGET_OK; + GTTK_DRAWABLE_FROM_WIDGET; + GTTK_STYLE_BACKGROUND_DEFAULT; + GTTK_DEFAULT_BACKGROUND; + GTTK_STYLE_FROM_WIDGET; + gttk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, + GTTK_SECTION_BUTTONS|GTTK_SECTION_ALL); + GTTK_WIDGET_SET_FOCUS(widget); + gttk_gtk_paint_box(style, gdkDrawable, gtkState, gtkShadow, NULL, widget, "button", 0, 0, b.width, b.height); } else { - widget = GtkTtk_GetComboboxEntry(wc); - GTKTTK_ENSURE_WIDGET_OK; - GTKTTK_DRAWABLE_FROM_WIDGET; - GTKTTK_STYLE_BACKGROUND_DEFAULT; - GTKTTK_DEFAULT_BACKGROUND; - GTKTTK_STYLE_FROM_WIDGET; - GtkTtk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, - GTKTTK_SECTION_ENTRY|GTKTTK_SECTION_ALL); - GTKTTK_WIDGET_SET_FOCUS(widget); - GtkTtk_gtk_paint_shadow(style, gdkDrawable, gtkState, gtkShadow, NULL, + widget = gttk_GetComboboxEntry(wc); + GTTK_ENSURE_WIDGET_OK; + GTTK_DRAWABLE_FROM_WIDGET; + GTTK_STYLE_BACKGROUND_DEFAULT; + GTTK_DEFAULT_BACKGROUND; + GTTK_STYLE_FROM_WIDGET; + gttk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, + GTTK_SECTION_ENTRY|GTTK_SECTION_ALL); + GTTK_WIDGET_SET_FOCUS(widget); + gttk_gtk_paint_shadow(style, gdkDrawable, gtkState, gtkShadow, NULL, widget, "combobox", 0, 0, b.width, b.height); } - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height, b.x, b.y); - GTKTTK_CLEANUP_GTK_DRAWABLE; + GTTK_CLEANUP_GTK_DRAWABLE; } static Ttk_ElementSpec ComboboxFieldElementSpec = { @@ -98,11 +98,11 @@ static void ComboboxArrowElementGeometry( void *clientData, void *elementRecord, Tk_Window tkwin, int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr) { - GTKTTK_WIDGET_CACHE_DEFINITION; + GTTK_WIDGET_CACHE_DEFINITION; gint size = 15; - GtkWidget *widget = GtkTtk_GetComboboxEntry(wc); - GTKTTK_ENSURE_WIDGET_OK; - GtkTtk_gtk_widget_style_get(widget, "arrow-size", &size, NULL); + GtkWidget *widget = gttk_GetComboboxEntry(wc); + GTTK_ENSURE_WIDGET_OK; + gttk_gtk_widget_style_get(widget, "arrow-size", &size, NULL); *widthPtr = *heightPtr = size; *paddingPtr = Ttk_UniformPadding(3); @@ -112,51 +112,51 @@ static void ComboboxArrowElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned state) { - GTKTTK_GTK_DRAWABLE_DEFINITIONS; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - /* GTKTTK_SETUP_GTK_DRAWABLE; */ + GTTK_GTK_DRAWABLE_DEFINITIONS; + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + /* GTTK_SETUP_GTK_DRAWABLE; */ GtkWidget *widget = NULL; - GtkWidget *arrow_widget = GtkTtk_GetArrow(wc); + GtkWidget *arrow_widget = gttk_GetArrow(wc); gfloat arrow_scaling; gint arrow_x; gint arrow_y; gint arrow_width; gint arrow_height; if (state & (TTK_STATE_DISABLED|TTK_STATE_READONLY)) { - widget = GtkTtk_GetCombobox(wc); - GTKTTK_ENSURE_WIDGET_OK; - GTKTTK_STYLE_FROM_WIDGET; - GTKTTK_DRAWABLE_FROM_WIDGET; - GtkTtk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, - GTKTTK_SECTION_BUTTONS|GTKTTK_SECTION_ALL); - GTKTTK_WIDGET_SET_FOCUS(widget); - GtkTtk_gtk_paint_flat_box(style, gdkDrawable, gtkState, gtkShadow, NULL, + widget = gttk_GetCombobox(wc); + GTTK_ENSURE_WIDGET_OK; + GTTK_STYLE_FROM_WIDGET; + GTTK_DRAWABLE_FROM_WIDGET; + gttk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, + GTTK_SECTION_BUTTONS|GTTK_SECTION_ALL); + GTTK_WIDGET_SET_FOCUS(widget); + gttk_gtk_paint_flat_box(style, gdkDrawable, gtkState, gtkShadow, NULL, widget, "button", 0, 0, b.width, b.height); } else { - widget = GtkTtk_GetComboboxEntry(wc); - GTKTTK_ENSURE_WIDGET_OK; - GTKTTK_STYLE_FROM_WIDGET; - GTKTTK_DRAWABLE_FROM_WIDGET; - GtkTtk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, - GTKTTK_SECTION_ENTRY|GTKTTK_SECTION_ALL); - GTKTTK_WIDGET_SET_FOCUS(widget); - GtkTtk_gtk_paint_flat_box(style, gdkDrawable, gtkState, gtkShadow, NULL, + widget = gttk_GetComboboxEntry(wc); + GTTK_ENSURE_WIDGET_OK; + GTTK_STYLE_FROM_WIDGET; + GTTK_DRAWABLE_FROM_WIDGET; + gttk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, + GTTK_SECTION_ENTRY|GTTK_SECTION_ALL); + GTTK_WIDGET_SET_FOCUS(widget); + gttk_gtk_paint_flat_box(style, gdkDrawable, gtkState, gtkShadow, NULL, widget, "combobox", 0, 0, b.width, b.height); } /* Draw the arrow, according to the desired scaling! */ - GtkTtk_gtk_widget_style_get(arrow_widget, "arrow-scaling", + gttk_gtk_widget_style_get(arrow_widget, "arrow-scaling", &arrow_scaling, NULL); if (arrow_scaling == 0.0) arrow_scaling = 1.0; arrow_width = b.width * arrow_scaling; arrow_height = b.height * arrow_scaling; arrow_x = (b.width - arrow_width) / 2; arrow_y = (b.height - arrow_height) / 2; - GtkTtk_gtk_paint_arrow(style, gdkDrawable, gtkState, GTK_SHADOW_NONE, NULL, + gttk_gtk_paint_arrow(style, gdkDrawable, gtkState, GTK_SHADOW_NONE, NULL, arrow_widget, "combo", GTK_ARROW_DOWN, TRUE, arrow_x, arrow_y, arrow_width, arrow_height); - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height, b.x, b.y); - GTKTTK_CLEANUP_GTK_DRAWABLE; + GTTK_CLEANUP_GTK_DRAWABLE; } static Ttk_ElementSpec ComboboxArrowElementSpec = { @@ -171,8 +171,8 @@ static Ttk_ElementSpec ComboboxArrowElementSpec = { * +++ Widget layout. */ -int GtkTtk_Init_Combobox(Tcl_Interp *interp, - GtkTtk_WidgetCache **wc, Ttk_Theme themePtr) +int gttk_Init_Combobox(Tcl_Interp *interp, + gttk_WidgetCache **wc, Ttk_Theme themePtr) { /* * Register elements: @@ -187,4 +187,4 @@ int GtkTtk_Init_Combobox(Tcl_Interp *interp, */ return TCL_OK; -}; /* GtkTtk_Init_Combobox */ +}; /* gttk_Init_Combobox */ diff --git a/generic/gttk_Elements.h b/generic/gttk_Elements.h new file mode 100644 index 0000000..2ebd05e --- /dev/null +++ b/generic/gttk_Elements.h @@ -0,0 +1,52 @@ +/* + * gttk_Elements.h + * ------------------- + * + * This file is part of the gttk package, a Tk/Tile based theme that uses + * Gtk/GNOME for drawing. + * + * Copyright (C) 2004-2008 by: + * Georgios Petasis, petasis@iit.demokritos.gr, + * Software and Knowledge Engineering Laboratory, + * Institute of Informatics and Telecommunications, + * National Centre for Scientific Research (NCSR) "Demokritos", + * Aghia Paraskevi, 153 10, Athens, Greece. + */ +#include "gttk_TkHeaders.h" + +extern int gttk_Init_Background(Tcl_Interp *interp, + gttk_WidgetCache **, Ttk_Theme themePtr); +extern int gttk_Init_Button(Tcl_Interp *interp, + gttk_WidgetCache **, Ttk_Theme themePtr); +extern int gttk_Init_CheckButton(Tcl_Interp *interp, + gttk_WidgetCache **, Ttk_Theme themePtr); +extern int gttk_Init_RadioButton(Tcl_Interp *interp, + gttk_WidgetCache **, Ttk_Theme themePtr); +extern int gttk_Init_Menubutton(Tcl_Interp *interp, + gttk_WidgetCache **, Ttk_Theme themePtr); +extern int gttk_Init_ToolButton(Tcl_Interp *interp, + gttk_WidgetCache **, Ttk_Theme themePtr); +extern int gttk_Init_Entry(Tcl_Interp *interp, + gttk_WidgetCache **, Ttk_Theme themePtr); +extern int gttk_Init_Combobox(Tcl_Interp *interp, + gttk_WidgetCache **, Ttk_Theme themePtr); +extern int gttk_Init_Labelframe(Tcl_Interp *interp, + gttk_WidgetCache **, Ttk_Theme themePtr); +extern int gttk_Init_Scrollbar(Tcl_Interp *interp, + gttk_WidgetCache **, Ttk_Theme themePtr); +extern int gttk_Init_Notebook(Tcl_Interp *interp, + gttk_WidgetCache **, Ttk_Theme themePtr); +extern int gttk_Init_TreeView(Tcl_Interp *interp, + gttk_WidgetCache **, Ttk_Theme themePtr); +extern int gttk_Init_Progress(Tcl_Interp *interp, + gttk_WidgetCache **, Ttk_Theme themePtr); +extern int gttk_Init_Scale(Tcl_Interp *interp, + gttk_WidgetCache **, Ttk_Theme themePtr); +extern int gttk_Init_Paned(Tcl_Interp *interp, + gttk_WidgetCache **, Ttk_Theme themePtr); +extern int gttk_Init_SizeGrip(Tcl_Interp *interp, + gttk_WidgetCache **, Ttk_Theme themePtr); +extern int gttk_Init_Separator(Tcl_Interp *interp, + gttk_WidgetCache **, Ttk_Theme themePtr); +extern int gttk_Init_Arrows(Tcl_Interp *interp, + gttk_WidgetCache **, Ttk_Theme themePtr); diff --git a/generic/gtkTtk_Entry.cpp b/generic/gttk_Entry.cpp similarity index 56% rename from generic/gtkTtk_Entry.cpp rename to generic/gttk_Entry.cpp index 05e3b3f..77c64e0 100644 --- a/generic/gtkTtk_Entry.cpp +++ b/generic/gttk_Entry.cpp @@ -1,8 +1,8 @@ /* - * gtkTtk_Entry.cpp + * gttk_Entry.cpp * ------------------ * - * This file is part of the gtkTtk package, a Tk/Tile based theme that uses + * This file is part of the gttk package, a Tk/Tile based theme that uses * Gtk/GNOME for drawing. * * Copyright (C) 2004-2008 by: @@ -13,9 +13,9 @@ * Aghia Paraskevi, 153 10, Athens, Greece. */ -#include "gtkTtk_Utilities.h" -#include "gtkTtk_TkHeaders.h" -#include "gtkTtk_WidgetDefaults.h" +#include "gttk_Utilities.h" +#include "gttk_TkHeaders.h" +#include "gttk_WidgetDefaults.h" #if 0 /* @@ -38,46 +38,48 @@ static void EntryFieldElementGeometry( void *clientData, void *elementRecord, Tk_Window tkwin, int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr) { - GTKTTK_WIDGET_CACHE_DEFINITION; + GTTK_WIDGET_CACHE_DEFINITION; // GtkBorder border = {0, 0, 0, 0}; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - GtkWidget *widget = GtkTtk_GetEntry(wc); - GTKTTK_ENSURE_WIDGET_OK; + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GtkWidget *widget = gttk_GetEntry(wc); + GTTK_ENSURE_WIDGET_OK; int xt = widget->style->xthickness; int yt = widget->style->ythickness; *paddingPtr = Ttk_MakePadding(xt + EntryUniformPadding, yt + EntryUniformPadding, xt + EntryUniformPadding, yt + EntryUniformPadding); - // GtkTtk_gtk_widget_style_get(widget, "inner-border", &border, NULL); - // GtkTtk_g_object_get(widget, "inner-border", &border, NULL); - // *paddingPtr = GTKTTK_GTKBORDER_TO_PADDING(border); + // gttk_gtk_widget_style_get(widget, "inner-border", &border, NULL); + // gttk_g_object_get(widget, "inner-border", &border, NULL); + // *paddingPtr = GTTK_GTKBORDER_TO_PADDING(border); } static void EntryFieldElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned state) { - GTKTTK_GTK_DRAWABLE_DEFINITIONS; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GTTK_GTK_DRAWABLE_DEFINITIONS; + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; gboolean hasFrame = TRUE; - GtkWidget *widget = GtkTtk_GetEntry(wc); - GTKTTK_ENSURE_WIDGET_OK; - GTKTTK_DRAWABLE_FROM_WIDGET; - style = GtkTtk_GetGtkWindowStyle(wc->gtkWindow); - GTKTTK_DEFAULT_BACKGROUND; + GtkWidget *widget = gttk_GetEntry(wc); + GTTK_ENSURE_WIDGET_OK; + GTTK_DRAWABLE_FROM_WIDGET; + style = gttk_GetGtkWindowStyle(wc->gtkWindow); + GTTK_DEFAULT_BACKGROUND; if (hasFrame) { - GTKTTK_STYLE_FROM_WIDGET; - GtkTtk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, - GTKTTK_SECTION_ENTRY|GTKTTK_SECTION_ALL); - GTKTTK_WIDGET_SET_FOCUS(widget); - GtkTtk_gtk_paint_shadow(style, gdkDrawable, gtkState, gtkShadow, NULL, + GTTK_STYLE_FROM_WIDGET; + gttk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, + GTTK_SECTION_ENTRY|GTTK_SECTION_ALL); + gttk_gtk_paint_flat_box(style, gdkDrawable, gtkState, gtkShadow, NULL, widget, + "entry_bg", 0, 0, b.width, b.height); + GTTK_WIDGET_SET_FOCUS(widget); + gttk_gtk_paint_shadow(style, gdkDrawable, gtkState, gtkShadow, NULL, widget, "entry", 0, 0, b.width, b.height); } - // GtkTtk_StateInfo(state, gtkState, gtkShadow, tkwin, widget); - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + // gttk_StateInfo(state, gtkState, gtkShadow, tkwin, widget); + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height, b.x, b.y); - GTKTTK_CLEANUP_GTK_DRAWABLE; + GTTK_CLEANUP_GTK_DRAWABLE; } static Ttk_ElementSpec EntryFieldElementSpec = { @@ -92,8 +94,8 @@ static Ttk_ElementSpec EntryFieldElementSpec = { * +++ Widget layout. */ -int GtkTtk_Init_Entry(Tcl_Interp *interp, - GtkTtk_WidgetCache **wc, Ttk_Theme themePtr) +int gttk_Init_Entry(Tcl_Interp *interp, + gttk_WidgetCache **wc, Ttk_Theme themePtr) { /* * Register elements: @@ -106,4 +108,4 @@ int GtkTtk_Init_Entry(Tcl_Interp *interp, */ return TCL_OK; -}; /* GtkTtk_Init_Entry */ +}; /* gttk_Init_Entry */ diff --git a/generic/gttk_GtkApp.cpp b/generic/gttk_GtkApp.cpp new file mode 100644 index 0000000..4b85477 --- /dev/null +++ b/generic/gttk_GtkApp.cpp @@ -0,0 +1,248 @@ +/* + * gttk_GtkApp.c + * --------------- + * + * This file is part of the gttk package, a Tk/Tile based theme that uses + * Gtk/GNOME for drawing. + * + * Copyright (C) 2004-2008 by: + * Georgios Petasis, petasis@iit.demokritos.gr, + * Software and Knowledge Engineering Laboratory, + * Institute of Informatics and Telecommunications, + * National Centre for Scientific Research (NCSR) "Demokritos", + * Aghia Paraskevi, 153 10, Athens, Greece. + */ + +#ifdef GTTK_ENABLE_GNOME +#include +GnomeProgram *my_app = NULL; +#endif /* GTTK_ENABLE_GNOME */ + +#include "gttk_Utilities.h" +#include "gttk_TkHeaders.h" +#include +gboolean gttk_GtkInitialisedFlag = FALSE; +static int gttk_xlib_rgb_initialised = 0; +GtkWidget *gttk_GtkWindow = NULL; + + + +/* In the following variable we store the XErrorHandler, before we install our + * own, which filters out some XErrors... */ +static int (*gttk_TkXErrorHandler)(Display *displayPtr, + XErrorEvent *errorPtr); +static int (*gttk_GtkXErrorHandler)(Display *displayPtr, + XErrorEvent *errorPtr); +static int gttk_XErrorHandler(Display *displayPtr, XErrorEvent *errorPtr); + +static int gttk_XEventHandler(ClientData clientdata, XEvent *eventPtr); + +/* + * gttk_InterpDeleteProc: + * This function will be called when the interpreter gets deleted. It must free + * all allocated interp-specific memory segments. + */ +static void gttk_InterpDeleteProc(ClientData clientData, Tcl_Interp *interp) { + gttk_WidgetCache **wc_array = (gttk_WidgetCache **) clientData; + gttk_WidgetCache *wc = wc_array[0]; + if (wc && wc->gtkWindow) { + /*This will destroy also ALL children!*/ + gttk_gtk_widget_destroy(wc->gtkWindow); + } + // printf("Tk_DeleteGenericHandler: %p\n", interp); fflush(NULL); + Tk_DeleteGenericHandler(>tk_XEventHandler, (ClientData) interp); + Tcl_Free((char *) wc_array[0]); + Tcl_Free((char *) wc_array[1]); + Tcl_Free((char *) wc_array); +}; /* gttk_InterpDeleteProc */ + +gttk_WidgetCache **gttk_CreateGtkApp(Tcl_Interp *interp) { + /* + * The first step is to initialise the gtk library. This must be done once + * in the application lifetime. + */ + Tcl_MutexLock(>tkMutex); + if (!gttk_GtkInitialisedFlag) { +#ifdef GTTK_ENABLE_GNOME + gchar **remaining_args = NULL; + GOptionEntry option_entries[] = { + {G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &remaining_args, + "Special option that collects any remaining arguments for us"}, + { NULL } + }; + GOptionContext *option_context; +#endif /* GTTK_ENABLE_GNOME */ + int argc = 1; + char **argv = gttk_g_new0(char*, 2); + argv[0] = (char *) Tcl_GetNameOfExecutable(); + +#ifdef GTTK_INSTALL_XERROR_HANDLER + gttk_TkXErrorHandler = XSetErrorHandler(gttk_XErrorHandler); +#endif /* GTTK_INSTALL_XERROR_HANDLER */ + +#ifdef GTTK_ENABLE_GNOME + option_context = gttk_g_option_context_new("tile-gtk"); + gttk_g_option_context_add_main_entries(option_context, + option_entries, NULL); + /* We assume PACKAGE and VERSION are set to the program name and version + * number respectively. Also, assume that 'option_entries' is a global + * array of GOptionEntry structures. + */ + my_app = gnome_program_init(PACKAGE_NAME, PACKAGE_VERSION, + LIBGNOMEUI_MODULE, argc, argv, + GNOME_PARAM_GOPTION_CONTEXT, option_context, + GNOME_PARAM_NONE); + if (my_app) gttk_GtkInitialisedFlag = TRUE; + if (remaining_args != NULL) { + gttk_g_strfreev(remaining_args); + remaining_args = NULL; + } +#else /* GTTK_ENABLE_GNOME */ + gttk_gtk_disable_setlocale(); + gttk_GtkInitialisedFlag = gttk_gtk_init_check(&argc, &argv); +#endif /* GTTK_ENABLE_GNOME */ + gttk_g_free(argv); + if (!gttk_GtkInitialisedFlag) { + Tcl_MutexUnlock(>tkMutex); + return NULL; + } + /* Initialise gttk_GtkWindow... */ + gttk_GtkWindow = gttk_gtk_window_new(GTK_WINDOW_POPUP); + gttk_gtk_widget_realize(gttk_GtkWindow); +#ifdef GTTK_INSTALL_XERROR_HANDLER + /* + * GTK+ xerror handler will terminate the application. + * Just get rid of that... + */ + gttk_GtkXErrorHandler = XSetErrorHandler(gttk_XErrorHandler); +#endif /* GTTK_INSTALL_XERROR_HANDLER */ + +#ifdef GTTK_SYNCHRONIZE + XSynchronize(Tk_Display(Tk_MainWindow(interp)), true); +#endif /* GTTK_SYNCHRONIZE */ + } + Tcl_MutexUnlock(>tkMutex); + + /* + * Allocate the widget cache. We keep a widget cache per interpreter. + * Each cache is an array of two elements, one for each orientation. + */ + + gttk_WidgetCache **wc_array = (gttk_WidgetCache **) + Tcl_Alloc(sizeof(gttk_WidgetCache*)*2); + wc_array[0] = (gttk_WidgetCache *) + Tcl_Alloc(sizeof(gttk_WidgetCache)); + wc_array[1] = (gttk_WidgetCache *) + Tcl_Alloc(sizeof(gttk_WidgetCache)); + Tcl_SetAssocData(interp, "gttkTtk_gtk_widget_cache", + >tk_InterpDeleteProc, (ClientData) wc_array); + gttk_WidgetCache *wc = wc_array[0]; + memset(wc, 0, sizeof(gttk_WidgetCache)); + /* + * Initialise the widget cache. + */ + wc->gttk_MainInterp = interp; + wc->gttk_tkwin = Tk_MainWindow(interp); + if (wc->gttk_tkwin != NULL && wc->gttk_MainDisplay == NULL) { + Tk_MakeWindowExist(wc->gttk_tkwin); + wc->gttk_MainDisplay = Tk_Display(wc->gttk_tkwin); + } + if (wc->gttk_MainDisplay == NULL) { + Tcl_MutexUnlock(>tkMutex); + Tcl_Free((char *) wc_array[0]); + Tcl_Free((char *) wc_array[1]); + Tcl_Free((char *) wc_array); + return NULL; + } +#ifndef __WIN32__ + wc->gdkDisplay = gttk_gdk_x11_lookup_xdisplay(wc->gttk_MainDisplay); +#endif + if (!wc->gdkDisplay) { + wc->gdkDisplay = gttk_gdk_display_get_default(); + } + wc->gtkWindow = gttk_gtk_window_new(GTK_WINDOW_POPUP); + if (wc->gtkWindow) gttk_gtk_widget_realize(wc->gtkWindow); + wc->protoLayout = gttk_gtk_fixed_new(); + gttk_gtk_container_add((GtkContainer*)(wc->gtkWindow), wc->protoLayout); + memcpy(wc_array[1], wc_array[0], sizeof(gttk_WidgetCache)); + wc_array[0]->orientation = TTK_ORIENT_HORIZONTAL; + wc_array[1]->orientation = TTK_ORIENT_VERTICAL; + wc_array[0]->gtkOrientation = GTK_ORIENTATION_HORIZONTAL; + wc_array[1]->gtkOrientation = GTK_ORIENTATION_VERTICAL; + +#ifndef __WIN32__ + Tcl_MutexLock(>tkMutex); + if (!gttk_xlib_rgb_initialised) { + gttk_xlib_rgb_init(wc->gttk_MainDisplay,Tk_Screen(wc->gttk_tkwin)); + gttk_xlib_rgb_initialised = 1; + } + Tcl_MutexUnlock(>tkMutex); +#endif + return wc_array; +}; /* gttk_CreateGtkApp */ + +void gttk_DestroyGtkApp(void) { + Tcl_MutexLock(>tkMutex); + if (gttk_GtkInitialisedFlag) { + // XSetErrorHandler(gttk_TkXErrorHandler); + gttk_GtkInitialisedFlag = FALSE; + } + Tcl_MutexUnlock(>tkMutex); +}; /* gttk_DestroyGtkApp */ + +/* + * gttk_XErrorHandler: + * This XError handler just prints some debug information and then calls + * Tk's XError handler... + */ +static int gttk_XErrorHandler(Display *displayPtr, XErrorEvent *errorPtr) { +#ifdef GTTK_VERBOSE_XERROR_HANDLER + char buf[64]; + XGetErrorText (displayPtr, errorPtr->error_code, buf, 63); + printf("===============================================================\n"); + printf(" gttk_XErrorHandler:\n"); + printf(" error_code = %s (%d)\n", buf, errorPtr->error_code); + printf(" request_code = %d\n", errorPtr->request_code); + printf(" minor_code = %d\n", errorPtr->minor_code); + printf("===============================================================\n"); +#endif /* GTTK_VERBOSE_XERROR_HANDLER */ + return gttk_TkXErrorHandler(displayPtr, errorPtr); +}; /* gttk_XErrorHandler */ + +static int gttk_XEventHandler(ClientData clientData, XEvent *eventPtr) { + const char *tcl_callback; + int status; + if (eventPtr->type != ClientMessage) return 0; + // Atom gttk_KIPC_COMM_ATOM = XInternAtom(eventPtr->xclient.display, + // "KIPC_COMM_ATOM" , false); + Atom gttk_KIPC_COMM_ATOM = None; + if (eventPtr->xclient.message_type != gttk_KIPC_COMM_ATOM) return 0; + /* The following data variable contains the type of the KIPC message, + * As defined in gnomelibs/gnomecore/kipc.h: + * PaletteChanged = 0 + * StyleChanged = 2 + * ToolbarStyleChanged = 6 + */ + switch (eventPtr->xclient.data.l[0]) { + case 0: /* PaletteChanged */ + tcl_callback = "tile::theme::gttk::gnomePaletteChangeNotification"; + break; + case 2: /* StyleChanged */ + case 6: { /* ToolbarStyleChanged */ + tcl_callback = "tile::theme::gttk::gnomeStyleChangeNotification"; + break; + } + default: { + return 0; + } + } + Tcl_Interp *interp = (Tcl_Interp *) clientData; + if (interp == NULL) return 0; + // printf("gttk_XEventHandler: %p\n", interp); fflush(NULL); + /* Notify the tile engine about the change... */ + status = Tcl_Eval(interp, tcl_callback); + if (status != TCL_OK) Tcl_BackgroundError(interp); + /* Do not remove True: As many interpreters may have registered this event + * handler, allow Tk to call all of them! */ + return True; +} /* gttk_XEventHandler */ diff --git a/generic/gtkTtk_GtkHeaders.h b/generic/gttk_GtkHeaders.h similarity index 66% rename from generic/gtkTtk_GtkHeaders.h rename to generic/gttk_GtkHeaders.h index 3558dfc..a84d1c8 100644 --- a/generic/gtkTtk_GtkHeaders.h +++ b/generic/gttk_GtkHeaders.h @@ -1,8 +1,8 @@ /* - * gtkTtk_GtkHeaders.h + * gttk_GtkHeaders.h * -------------------- * - * This file is part of the gtkTtk package, a Tk/Tile based theme that uses + * This file is part of the gttk package, a Tk/Tile based theme that uses * Gtk/GNOME for drawing. * * Copyright (C) 2004-2008 by: @@ -12,21 +12,21 @@ * National Centre for Scientific Research (NCSR) "Demokritos", * Aghia Paraskevi, 153 10, Athens, Greece. */ -#ifndef _GTKTTK_GTKHEADERS -#define _GTKTTK_GTKHEADERS +#ifndef _GTTK_GTKHEADERS +#define _GTTK_GTKHEADERS #include -#include "gtkTtk_Symbols.h" +#include "gttk_Symbols.h" /* Convenience memory allocators */ -#define GtkTtk_g_new0(struct_type, n_structs) \ - ((struct_type *) GtkTtk_g_malloc0 (((gsize) sizeof (struct_type)) * ((gsize) (n_structs)))) +#define gttk_g_new0(struct_type, n_structs) \ + ((struct_type *) gttk_g_malloc0 (((gsize) sizeof (struct_type)) * ((gsize) (n_structs)))) -typedef struct GtkTtk_WidgetCache { - Tk_Window GtkTtk_tkwin; - Display* GtkTtk_MainDisplay; - Tcl_Interp* GtkTtk_MainInterp; +typedef struct gttk_WidgetCache { + Tk_Window gttk_tkwin; + Display* gttk_MainDisplay; + Tcl_Interp* gttk_MainInterp; int orientation; GtkOrientation gtkOrientation; GdkDisplay* gdkDisplay; @@ -54,7 +54,7 @@ typedef struct GtkTtk_WidgetCache { GtkWidget* gtkVPaned; GtkWidget* gtkWindow; GtkWidget* protoLayout; -} GtkTtk_WidgetCache; +} gttk_WidgetCache; typedef struct { GtkStateType state; /* State value to return if this entry matches */ @@ -63,15 +63,15 @@ typedef struct { unsigned int onBits; /* Bits which must be set */ unsigned int offBits; /* Bits which must be cleared */ unsigned int section; /* Table section to match */ -} GtkTtk_StateTable; +} gttk_StateTable; -#define GTKTTK_SECTION_ALL (1<<0) -#define GTKTTK_SECTION_BUTTONS (1<<1) -#define GTKTTK_SECTION_ENTRY (1<<2) -#define GTKTTK_SECTION_SCROLLBAR (1<<3) -#define GTKTTK_SECTION_STEPPERS (1<<4) -#define GTKTTK_SECTION_TROUGH (1<<5) -#define GTKTTK_SECTION_SASH (1<<6) -#define GTKTTK_SECTION_TABS (1<<7) +#define GTTK_SECTION_ALL (1<<0) +#define GTTK_SECTION_BUTTONS (1<<1) +#define GTTK_SECTION_ENTRY (1<<2) +#define GTTK_SECTION_SCROLLBAR (1<<3) +#define GTTK_SECTION_STEPPERS (1<<4) +#define GTTK_SECTION_TROUGH (1<<5) +#define GTTK_SECTION_SASH (1<<6) +#define GTTK_SECTION_TABS (1<<7) #endif diff --git a/generic/gtkTtk_Init.cpp b/generic/gttk_Init.cpp similarity index 59% rename from generic/gtkTtk_Init.cpp rename to generic/gttk_Init.cpp index 2fa101d..78eb5b7 100644 --- a/generic/gtkTtk_Init.cpp +++ b/generic/gttk_Init.cpp @@ -1,61 +1,61 @@ /* - * $Id: gtkTtk_Init.cpp,v 1.15 2012/07/22 19:26:14 petasis Exp $ + * $Id: gttk_Init.cpp,v 1.15 2012/07/22 19:26:14 petasis Exp $ * * Copyright (C) 2004-2008 Georgios Petasis * - * The gtkTtk theme is a Tk/Tile theme that uses Gtk/GNOME for drawing. + * The gttk theme is a Tk/Tile theme that uses Gtk/GNOME for drawing. */ -#include "gtkTtk_Utilities.h" -#include "gtkTtk_TkHeaders.h" +#include "gttk_Utilities.h" +#include "gttk_TkHeaders.h" +#include #include -static int GtkTtk_GtkAppCreated = 0; +static int gttk_GtkAppCreated = 0; -extern GtkTtk_WidgetCache **GtkTtk_CreateGtkApp(Tcl_Interp *interp); -extern void GtkTtk_DestroyGtkApp(void); +extern gttk_WidgetCache **gttk_CreateGtkApp(Tcl_Interp *interp); +extern void gttk_DestroyGtkApp(void); static char initScript[] = - "namespace eval gtkTtk { };" - "namespace eval ttk::theme::gtkTtk { variable version " - PACKAGE_VERSION " };" - "tcl_findLibrary gtkTtk $ttk::theme::gtkTtk::version " - "$ttk::theme::gtkTtk::version gtkTtk.tcl GTKTTK_LIBRARY gtkTtk::library;"; -#ifdef GTKTTK_LOAD_GTK_DYNAMICALLY + "namespace eval gttk { };" + "namespace eval ttk::theme::gttk { variable version " PACKAGE_VERSION " };" + "tcl_findLibrary gttk $ttk::theme::gttk::version " + "$ttk::theme::gttk::version [file join [pwd] gttk.tcl] GTTK_LIBRARY gttk::library;"; +#ifdef GTTK_LOAD_GTK_DYNAMICALLY static char libsInitScript[] = - "ttk::theme::gtkTtk::loadLibraries"; -#endif /* GTKTTK_LOAD_GTK_DYNAMICALLY */ + "ttk::theme::gttk::loadLibraries"; +#endif /* GTTK_LOAD_GTK_DYNAMICALLY */ /* * Exit Handler. */ -static void GtkTtk_ExitProc(ClientData data) { - //Tcl_MutexLock(>kTtkMutex); - //GtkTtk_DestroyGtkApp(); - //Tcl_MutexUnlock(>kTtkMutex); - Tcl_MutexLock(>kTtkMutex); - // printf("GtkTtk_ExitProc: %d\n", GtkTtk_GtkAppCreated); fflush(NULL); - if (GtkTtk_GtkAppCreated < 0) { - Tcl_MutexUnlock(>kTtkMutex); +static void gttk_ExitProc(ClientData data) { + //Tcl_MutexLock(>tkMutex); + //gttk_DestroyGtkApp(); + //Tcl_MutexUnlock(>tkMutex); + Tcl_MutexLock(>tkMutex); + // printf("gttk_ExitProc: %d\n", gttk_GtkAppCreated); fflush(NULL); + if (gttk_GtkAppCreated < 0) { + Tcl_MutexUnlock(>tkMutex); return; } - --GtkTtk_GtkAppCreated; - if (GtkTtk_GtkAppCreated == 0) { - // printf("GtkTtk_ExitProc: %d <- GtkTtk_DestroyGtkApp();\n", - // GtkTtk_GtkAppCreated); fflush(NULL); - GtkTtk_DestroyGtkApp(); + --gttk_GtkAppCreated; + if (gttk_GtkAppCreated == 0) { + // printf("gttk_ExitProc: %d <- gttk_DestroyGtkApp();\n", + // gttk_GtkAppCreated); fflush(NULL); + gttk_DestroyGtkApp(); } - Tcl_MutexUnlock(>kTtkMutex); + Tcl_MutexUnlock(>tkMutex); return; -}; /* GtkTtk_ExitProc */ +}; /* gttk_ExitProc */ /* * Helper Functions */ -int Gtkttk_ThemeName(ClientData clientData, Tcl_Interp *interp, +int gttk_ThemeName(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { - // GtkTtk_WidgetCache **wc_array = (GtkTtk_WidgetCache **) clientData; - // GtkTtk_WidgetCache *wc; + // gttk_WidgetCache **wc_array = (gttk_WidgetCache **) clientData; + // gttk_WidgetCache *wc; // if (!wc_array || !wc_array[0]) { // Tcl_SetResult(interp, (char *) "empty wc_array!", TCL_STATIC); // return TCL_ERROR; @@ -69,20 +69,39 @@ int Gtkttk_ThemeName(ClientData clientData, Tcl_Interp *interp, gchar *strval = NULL; if (objc != 1) {Tcl_WrongNumArgs(interp, 1, objv, ""); return TCL_ERROR;} - Tcl_MutexLock(>kTtkMutex); - settings = GtkTtk_gtk_settings_get_default(); + Tcl_MutexLock(>tkMutex); + settings = gttk_gtk_settings_get_default(); if (settings) { - GtkTtk_g_object_get(settings, "gtk-theme-name", &strval, NULL); + gttk_g_object_get(settings, "gtk-theme-name", &strval, NULL); if (strval) { Tcl_SetResult(interp, (char *) strval, TCL_VOLATILE); - GtkTtk_g_free(strval); + gttk_g_free(strval); } } - Tcl_MutexUnlock(>kTtkMutex); + Tcl_MutexUnlock(>tkMutex); return TCL_OK; -}; /* Gtkttk_ThemeName */ +}; /* gttk_ThemeName */ -int Gtkttk_SettingsProperty(ClientData clientData, Tcl_Interp *interp, +int gttk_set_gtk_theme(ClientData clientData, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) { + /** @brief Tcl command 'setGtkTheme': Set the GTK theme from Tcl */ + if (objc != 2) { + Tcl_WrongNumArgs(interp, 1, objv, "fileName"); + return TCL_ERROR; + } + // Get the argument and format it into the proper string + const char* name = Tcl_GetStringFromObj(objv[1], NULL); + // Make GTK parse the resource string + Tcl_MutexLock(>tkMutex); + GtkSettings* settings = gtk_settings_get_default(); + gtk_settings_set_string_property(settings, "gtk-theme-name", name, NULL); + gtk_rc_reset_styles(settings); + + Tcl_MutexUnlock(>tkMutex); + + return TCL_OK; +} // gttk_set_gtk_theme + +int gttk_SettingsProperty(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { static const char *Methods[] = { "integer", "boolean", "string", (char *) NULL @@ -106,35 +125,35 @@ int Gtkttk_SettingsProperty(ClientData clientData, Tcl_Interp *interp, } } - Tcl_MutexLock(>kTtkMutex); - settings = GtkTtk_gtk_settings_get_default(); + Tcl_MutexLock(>tkMutex); + settings = gttk_gtk_settings_get_default(); if (settings) { switch ((enum methods) type) { case INTEGER: - GtkTtk_g_object_get(settings, Tcl_GetString(objv[1]), &i_val, NULL); + gttk_g_object_get(settings, Tcl_GetString(objv[1]), &i_val, NULL); Tcl_SetObjResult(interp, Tcl_NewIntObj(i_val)); break; case BOOLEAN: - GtkTtk_g_object_get(settings, Tcl_GetString(objv[1]), &b_val, NULL); + gttk_g_object_get(settings, Tcl_GetString(objv[1]), &b_val, NULL); if (b_val) Tcl_SetObjResult(interp, Tcl_NewBooleanObj(1)); else Tcl_SetObjResult(interp, Tcl_NewBooleanObj(0)); break; case STRING: - GtkTtk_g_object_get(settings, Tcl_GetString(objv[1]), &s_val, NULL); + gttk_g_object_get(settings, Tcl_GetString(objv[1]), &s_val, NULL); if (s_val) { Tcl_SetResult(interp, (char *) s_val, TCL_VOLATILE); - GtkTtk_g_free (s_val); + gttk_g_free (s_val); } break; } } - Tcl_MutexUnlock(>kTtkMutex); + Tcl_MutexUnlock(>tkMutex); return TCL_OK; -}; /* Gtkttk_SettingsProperty */ +}; /* gttk_SettingsProperty */ #define GETPROPERTY_GTK_WIDGET_GET 0 #define GETPROPERTY_GTK_WIDGET_STYLE_GET 1 -int Gtkttk_GetProperty(ClientData clientData, Tcl_Interp *interp, +int gttk_GetProperty(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[], int gtkMethod) { static const char *Methods[] = { "integer", "boolean", "string", (char *) NULL @@ -154,8 +173,8 @@ int Gtkttk_GetProperty(ClientData clientData, Tcl_Interp *interp, gboolean b_val = FALSE; gint i_val = 0; GtkWidget *widget = NULL; - GtkTtk_WidgetCache **wc_array = (GtkTtk_WidgetCache **) clientData; - GtkTtk_WidgetCache *wc; + gttk_WidgetCache **wc_array = (gttk_WidgetCache **) clientData; + gttk_WidgetCache *wc; if (!wc_array || !wc_array[0]) { Tcl_SetResult(interp, (char *) "empty wc_array!", TCL_STATIC); return TCL_ERROR; @@ -172,10 +191,10 @@ int Gtkttk_GetProperty(ClientData clientData, Tcl_Interp *interp, return TCL_ERROR; } switch ((enum widgets) type) { - case W_HSCROLLBAR: {widget = GtkTtk_GetHScrollBar(wc); break;} - case W_VSCROLLBAR: {widget = GtkTtk_GetVScrollBar(wc); break;} - case W_NOTEBOOK: {widget = GtkTtk_GetNotebook(wc); break;} - case W_BUTTON: {widget = GtkTtk_GetButton(wc); break;} + case W_HSCROLLBAR: {widget = gttk_GetHScrollBar(wc); break;} + case W_VSCROLLBAR: {widget = gttk_GetVScrollBar(wc); break;} + case W_NOTEBOOK: {widget = gttk_GetNotebook(wc); break;} + case W_BUTTON: {widget = gttk_GetButton(wc); break;} } /* Get property type, which defaults to "string"... */ if (objc == 4) { @@ -185,17 +204,17 @@ int Gtkttk_GetProperty(ClientData clientData, Tcl_Interp *interp, } } - Tcl_MutexLock(>kTtkMutex); + Tcl_MutexLock(>tkMutex); if (widget) { switch ((enum methods) type) { case INTEGER: switch (gtkMethod) { case GETPROPERTY_GTK_WIDGET_GET: - GtkTtk_gtk_object_get((GtkObject *) widget, + gttk_gtk_object_get((GtkObject *) widget, Tcl_GetString(objv[2]), &i_val, NULL); break; case GETPROPERTY_GTK_WIDGET_STYLE_GET: - GtkTtk_gtk_widget_style_get(widget, Tcl_GetString(objv[2]), + gttk_gtk_widget_style_get(widget, Tcl_GetString(objv[2]), &i_val, NULL); break; } @@ -204,11 +223,11 @@ int Gtkttk_GetProperty(ClientData clientData, Tcl_Interp *interp, case BOOLEAN: switch (gtkMethod) { case GETPROPERTY_GTK_WIDGET_GET: - GtkTtk_gtk_object_get((GtkObject *) widget, + gttk_gtk_object_get((GtkObject *) widget, Tcl_GetString(objv[2]), &b_val, NULL); break; case GETPROPERTY_GTK_WIDGET_STYLE_GET: - GtkTtk_gtk_widget_style_get(widget, Tcl_GetString(objv[2]), + gttk_gtk_widget_style_get(widget, Tcl_GetString(objv[2]), &b_val, NULL); break; } @@ -218,38 +237,38 @@ int Gtkttk_GetProperty(ClientData clientData, Tcl_Interp *interp, case STRING: switch (gtkMethod) { case GETPROPERTY_GTK_WIDGET_GET: - GtkTtk_gtk_object_get((GtkObject *) widget, + gttk_gtk_object_get((GtkObject *) widget, Tcl_GetString(objv[2]), &s_val, NULL); break; case GETPROPERTY_GTK_WIDGET_STYLE_GET: - GtkTtk_gtk_widget_style_get(widget, Tcl_GetString(objv[2]), + gttk_gtk_widget_style_get(widget, Tcl_GetString(objv[2]), &s_val, NULL); break; } if (s_val) { Tcl_SetResult(interp, (char *) s_val, TCL_VOLATILE); - GtkTtk_g_free (s_val); + gttk_g_free (s_val); } break; } } - Tcl_MutexUnlock(>kTtkMutex); + Tcl_MutexUnlock(>tkMutex); return TCL_OK; -}; /* Gtkttk_GetProperty */ +}; /* gttk_GetProperty */ -int Gtkttk_WidgetProperty(ClientData clientData, Tcl_Interp *interp, +int gttk_WidgetProperty(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { - return Gtkttk_GetProperty(clientData, interp, objc, objv, + return gttk_GetProperty(clientData, interp, objc, objv, GETPROPERTY_GTK_WIDGET_GET); -}; /* Gtkttk_WidgetProperty */ +}; /* gttk_WidgetProperty */ -int Gtkttk_WidgetStyleProperty(ClientData clientData, Tcl_Interp *interp, +int gttk_WidgetStyleProperty(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { - return Gtkttk_GetProperty(clientData, interp, objc, objv, + return gttk_GetProperty(clientData, interp, objc, objv, GETPROPERTY_GTK_WIDGET_STYLE_GET); -}; /* Gtkttk_WidgetStyleProperty */ +}; /* gttk_WidgetStyleProperty */ -int Gtkttk_GtkEnum(ClientData clientData, Tcl_Interp *interp, +int gttk_GtkEnum(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { static const char *Methods[] = { "GtkPositionType", (char *) NULL @@ -286,15 +305,15 @@ int Gtkttk_GtkEnum(ClientData clientData, Tcl_Interp *interp, } Tcl_SetResult(interp, (char *) n, TCL_STATIC); return TCL_OK; -}; /* Gtkttk_GtkEnum */ +}; /* gttk_GtkEnum */ -int Gtkttk_GtkDirectory(ClientData clientData, Tcl_Interp *interp, +int gttk_GtkDirectory(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { static const char *Methods[] = { - "theme", "default_files", (char *) NULL + "theme", "default_files", "module", (char *) NULL }; enum methods { - THEME, DEFAULT_FILES + THEME, DEFAULT_FILES, MODULE }; int type; gchar *dir = NULL, **dirs = NULL; @@ -308,10 +327,10 @@ int Gtkttk_GtkDirectory(ClientData clientData, Tcl_Interp *interp, return TCL_ERROR; } - Tcl_MutexLock(>kTtkMutex); + Tcl_MutexLock(>tkMutex); switch ((enum methods) type) { case THEME: - dir = GtkTtk_gtk_rc_get_theme_dir(); + dir = gttk_gtk_rc_get_theme_dir(); break; case DEFAULT_FILES: if (objc == 3) { @@ -319,24 +338,27 @@ int Gtkttk_GtkDirectory(ClientData clientData, Tcl_Interp *interp, if (Tcl_ListObjGetElements(interp, objv[2], &mobjc, &mobjv) != TCL_OK) { return TCL_ERROR; } - dirs = GtkTtk_g_new0(gchar *, mobjc+1); + dirs = gttk_g_new0(gchar *, mobjc+1); for (int i = 0; i < mobjc; ++i) { Tcl_IncrRefCount(mobjv[i]); dirs[i] = Tcl_GetString(mobjv[i]); } - GtkTtk_gtk_rc_set_default_files(dirs); + gttk_gtk_rc_set_default_files(dirs); for (int i = 0; i < mobjc; ++i) { Tcl_DecrRefCount(mobjv[i]); } - GtkTtk_g_free(dirs); dirs = NULL; + gttk_g_free(dirs); dirs = NULL; } else { - dirs = GtkTtk_gtk_rc_get_default_files(); + dirs = gttk_gtk_rc_get_default_files(); } break; + case MODULE: + dir = gtk_rc_get_module_dir(); + break; } if (dir) { Tcl_SetResult(interp, (char *) dir, TCL_VOLATILE); - GtkTtk_g_free(dir); + gttk_g_free(dir); } if (dirs) { Tcl_Obj *list = Tcl_NewListObj(0, NULL); @@ -346,11 +368,11 @@ int Gtkttk_GtkDirectory(ClientData clientData, Tcl_Interp *interp, } Tcl_SetObjResult(interp, list); } - Tcl_MutexUnlock(>kTtkMutex); + Tcl_MutexUnlock(>tkMutex); return TCL_OK; -}; /* Gtkttk_GtkDirectory */ +}; /* gttk_GtkDirectory */ -int Gtkttk_gtk_method(ClientData clientData, Tcl_Interp *interp, +int gttk_gtk_method(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { static const char *Methods[] = { "gtk_rc_reparse_all_for_settings", "gtk_rc_reset_styles", (char *) NULL @@ -368,21 +390,21 @@ int Gtkttk_gtk_method(ClientData clientData, Tcl_Interp *interp, return TCL_ERROR; } - Tcl_MutexLock(>kTtkMutex); + Tcl_MutexLock(>tkMutex); switch ((enum methods) type) { case GTK_RC_REPARSE_ALL_FOR_SETTINGS: - GtkTtk_gtk_rc_reparse_all_for_settings( - GtkTtk_gtk_settings_get_default(), TRUE); + gttk_gtk_rc_reparse_all_for_settings( + gttk_gtk_settings_get_default(), TRUE); break; case GTK_RC_RESET_STYLES: - GtkTtk_gtk_rc_reset_styles(GtkTtk_gtk_settings_get_default()); + gttk_gtk_rc_reset_styles(gttk_gtk_settings_get_default()); break; } - Tcl_MutexUnlock(>kTtkMutex); + Tcl_MutexUnlock(>tkMutex); return TCL_OK; -}; /* Gtkttk_gtk_method */ +}; /* gttk_gtk_method */ -int Gtkttk_ThemeColour(ClientData clientData, Tcl_Interp *interp, +int gttk_ThemeColour(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { static const char *Methods[] = { "fg(NORMAL)", "fg(PRELIGHT)", "fg(ACTIVE)", @@ -421,7 +443,7 @@ int Gtkttk_ThemeColour(ClientData clientData, Tcl_Interp *interp, TAA_NORMAL, TAA_PRELIGHT, TAA_ACTIVE, TAA_SELECTED, TAA_INSENSITIVE }; - GtkTtk_WidgetCache **wc = (GtkTtk_WidgetCache **) clientData; + gttk_WidgetCache **wc = (gttk_WidgetCache **) clientData; GdkColor colour; gchar* colour_str = NULL; GtkStyle *style; @@ -430,7 +452,7 @@ int Gtkttk_ThemeColour(ClientData clientData, Tcl_Interp *interp, Tcl_SetResult(interp, (char *) "empty wc!", TCL_STATIC); return TCL_ERROR; } - style = GtkTtk_GetGtkWindowStyle(wc[0]->gtkWindow); + style = gttk_GetGtkWindowStyle(wc[0]->gtkWindow); if (!style) { Tcl_SetResult(interp, (char *) "empty style!", TCL_STATIC); return TCL_ERROR; @@ -484,24 +506,24 @@ int Gtkttk_ThemeColour(ClientData clientData, Tcl_Interp *interp, case TAA_SELECTED: colour = style->text_aa[GTK_STATE_SELECTED]; break; case TAA_INSENSITIVE: colour = style->text_aa[GTK_STATE_INSENSITIVE]; } - colour_str = GtkTtk_gdk_color_to_string(&colour); + colour_str = gttk_gdk_color_to_string(&colour); } else { - if (GtkTtk_gtk_style_lookup_color(style, Tcl_GetString(objv[1]), &colour)){ - colour_str = GtkTtk_gdk_color_to_string(&colour); + if (gttk_gtk_style_lookup_color(style, Tcl_GetString(objv[1]), &colour)){ + colour_str = gttk_gdk_color_to_string(&colour); } } if (colour_str) { Tcl_SetResult(interp, (char *) colour_str, TCL_VOLATILE); - GtkTtk_g_free(colour_str); + gttk_g_free(colour_str); return TCL_OK; } Tcl_SetResult(interp, (char *) "colour not found: ", TCL_STATIC); Tcl_AppendResult(interp, (char *) Tcl_GetString(objv[1]), NULL); return TCL_ERROR; -}; /* Gtkttk_ThemeColour */ +}; /* gttk_ThemeColour */ -#ifndef GTKTTK_LOAD_GTK_DYNAMICALLY +#ifndef GTTK_LOAD_GTK_DYNAMICALLY #ifndef GTK_STYLE_GET_PRIVATE struct _GtkStylePrivate { GSList *color_hashes; @@ -509,39 +531,39 @@ struct _GtkStylePrivate { typedef struct _GtkStylePrivate GtkStylePrivate; #define GTK_STYLE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_STYLE, GtkStylePrivate)) #endif -#endif /* GTKTTK_LOAD_GTK_DYNAMICALLY */ +#endif /* GTTK_LOAD_GTK_DYNAMICALLY */ -int Gtkttk_ColourKeys(ClientData clientData, Tcl_Interp *interp, +int gttk_ColourKeys(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { - GtkTtk_WidgetCache **wc = (GtkTtk_WidgetCache **) clientData; + gttk_WidgetCache **wc = (gttk_WidgetCache **) clientData; GtkStyle *style; if (!wc) { Tcl_SetResult(interp, (char *) "empty wc!", TCL_STATIC); return TCL_ERROR; } - style = GtkTtk_GetGtkWindowStyle(wc[0]->gtkWindow); + style = gttk_GetGtkWindowStyle(wc[0]->gtkWindow); if (!style) { Tcl_SetResult(interp, (char *) "empty style!", TCL_STATIC); return TCL_ERROR; } -#ifndef GTKTTK_LOAD_GTK_DYNAMICALLY +#ifndef GTTK_LOAD_GTK_DYNAMICALLY GtkStylePrivate *priv = GTK_STYLE_GET_PRIVATE(style); GSList *iter; Tcl_Obj *list = Tcl_NewListObj(0, NULL); for (iter = priv->color_hashes; iter != NULL; iter = iter->next) { GHashTable *hash = (GHashTable *) iter->data; - GList *keys = GtkTtk_g_hash_table_get_keys(hash); + GList *keys = gttk_g_hash_table_get_keys(hash); for (; keys != NULL; keys = keys->next) { Tcl_ListObjAppendElement(NULL, list, Tcl_NewStringObj((char *) keys->data, -1)); } } Tcl_SetObjResult(interp, list); -#endif /* GTKTTK_LOAD_GTK_DYNAMICALLY */ +#endif /* GTTK_LOAD_GTK_DYNAMICALLY */ return TCL_OK; -}; /* Gtkttk_ColourKeys */ +}; /* gttk_ColourKeys */ -int Gtkttk_InitialiseLibrary(ClientData clientData, Tcl_Interp *interp, +int gttk_InitialiseLibrary(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { static const char *Methods[] = { "required", @@ -564,56 +586,56 @@ int Gtkttk_InitialiseLibrary(ClientData clientData, Tcl_Interp *interp, if (Tcl_GetIndexFromObj(interp, objv[1], (const char **) Methods, "method", 0, &index) != TCL_OK) return TCL_ERROR; - Tcl_MutexLock(>kTtkMutex); + Tcl_MutexLock(>tkMutex); switch ((enum methods) index) { case L_REQUIRED: -#ifdef GTKTTK_LOAD_GTK_DYNAMICALLY +#ifdef GTTK_LOAD_GTK_DYNAMICALLY Tcl_SetObjResult(interp, Tcl_NewBooleanObj(1)); #else Tcl_SetObjResult(interp, Tcl_NewBooleanObj(0)); -#endif /* GTKTTK_LOAD_GTK_DYNAMICALLY */ - Tcl_MutexUnlock(>kTtkMutex); +#endif /* GTTK_LOAD_GTK_DYNAMICALLY */ + Tcl_MutexUnlock(>tkMutex); return TCL_OK; -#ifdef GTKTTK_LOAD_GTK_DYNAMICALLY +#ifdef GTTK_LOAD_GTK_DYNAMICALLY case L_GDK: - if (!GTKTTK_LAST_SYMBOL_gdk && objc > 2) { - status = GtkTtk_InitialiseSymbols_gdk(interp, objv[2]); + if (!GTTK_LAST_SYMBOL_gdk && objc > 2) { + status = gttk_InitialiseSymbols_gdk(interp, objv[2]); } break; case L_GDK_PIXBUF: - if (!GTKTTK_LAST_SYMBOL_gdk_pixbuf && objc > 2) { - status = GtkTtk_InitialiseSymbols_gdk_pixbuf(interp, objv[2]); + if (!GTTK_LAST_SYMBOL_gdk_pixbuf && objc > 2) { + status = gttk_InitialiseSymbols_gdk_pixbuf(interp, objv[2]); } break; case L_GDK_PIXBUF_XLIB: #ifndef __WIN32__ - if (!GTKTTK_LAST_SYMBOL_gdk_pixbuf_xlib && objc > 2) { - status = GtkTtk_InitialiseSymbols_gdk_pixbuf_xlib(interp, objv[2]); + if (!GTTK_LAST_SYMBOL_gdk_pixbuf_xlib && objc > 2) { + status = gttk_InitialiseSymbols_gdk_pixbuf_xlib(interp, objv[2]); } #endif break; case L_GLIB: - if (!GTKTTK_LAST_SYMBOL_glib && objc > 2) { - status = GtkTtk_InitialiseSymbols_glib(interp, objv[2]); + if (!GTTK_LAST_SYMBOL_glib && objc > 2) { + status = gttk_InitialiseSymbols_glib(interp, objv[2]); } break; case L_GOBJECT: - if (!GTKTTK_LAST_SYMBOL_gobject && objc > 2) { - status = GtkTtk_InitialiseSymbols_gobject(interp, objv[2]); + if (!GTTK_LAST_SYMBOL_gobject && objc > 2) { + status = gttk_InitialiseSymbols_gobject(interp, objv[2]); } break; case L_GTK: - if (!GTKTTK_LAST_SYMBOL_gtk && objc > 2) { - status = GtkTtk_InitialiseSymbols_gtk(interp, objv[2]); + if (!GTTK_LAST_SYMBOL_gtk && objc > 2) { + status = gttk_InitialiseSymbols_gtk(interp, objv[2]); } break; -#endif /* GTKTTK_LOAD_GTK_DYNAMICALLY */ +#endif /* GTTK_LOAD_GTK_DYNAMICALLY */ } - Tcl_MutexUnlock(>kTtkMutex); + Tcl_MutexUnlock(>tkMutex); return status; -}; /* Gtkttk_InitialiseLibrary */ +}; /* gttk_InitialiseLibrary */ -int Gtkttk_SetPalette(ClientData clientData, Tcl_Interp *interp, +int gttk_SetPalette(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { #if 0 static const char *Methods[] = { @@ -639,19 +661,19 @@ int Gtkttk_SetPalette(ClientData clientData, Tcl_Interp *interp, Tcl_WrongNumArgs(interp, 1, objv, "?-key value?"); return TCL_ERROR; } - Tcl_MutexLock(>kTtkMutex); - Tcl_MutexUnlock(>kTtkMutex); + Tcl_MutexLock(>tkMutex); + Tcl_MutexUnlock(>tkMutex); #endif return TCL_OK; -}; /* Gtkttk_SetPalette */ +}; /* gttk_SetPalette */ -int Gtkttk_SetStyle(ClientData clientData, Tcl_Interp *interp, +int gttk_SetStyle(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { if (objc != 2) {Tcl_WrongNumArgs(interp, 1, objv, "style"); return TCL_ERROR;} - Tcl_MutexLock(>kTtkMutex); + Tcl_MutexLock(>tkMutex); #if 0 - GtkTtk_WidgetCache **wc_array = (GtkTtk_WidgetCache **) clientData; - GtkTtk_WidgetCache *wc = wc_array[0]; + gttk_WidgetCache **wc_array = (gttk_WidgetCache **) clientData; + gttk_WidgetCache *wc = wc_array[0]; if (qApp) { int len; const char* str = Tcl_GetStringFromObj(objv[1], &len); @@ -661,59 +683,59 @@ int Gtkttk_SetStyle(ClientData clientData, Tcl_Interp *interp, if (new_style == NULL) { Tcl_SetResult(interp, (char *) "unknwon style: \"", TCL_STATIC); Tcl_AppendResult(interp, str, "\"", NULL); - Tcl_MutexUnlock(>kTtkMutex); + Tcl_MutexUnlock(>tkMutex); return TCL_ERROR; } //qApp->setStyle(style); /* Is this style the qApp style? */ - if (wc->GtkTtk_Style_Owner) todelete = wc->GtkTtk_Style; + if (wc->gttk_Style_Owner) todelete = wc->gttk_Style; -#ifdef GTKTTK_GTK_VERSION_3 +#ifdef GTTK_GTK_VERSION_3 if (strcmp(qApp->style().name(), str) == 0) { - wc->GtkTtk_Style = &(qApp->style()); -#endif /* GTKTTK_GTK_VERSION_3 */ -#ifdef GTKTTK_GTK_VERSION_4 + wc->gttk_Style = &(qApp->style()); +#endif /* GTTK_GTK_VERSION_3 */ +#ifdef GTTK_GTK_VERSION_4 if (qApp->style()->objectName() == style) { - wc->GtkTtk_Style = qApp->style(); -#endif /* GTKTTK_GTK_VERSION_4 */ - wc->GtkTtk_Style_Owner = false; + wc->gttk_Style = qApp->style(); +#endif /* GTTK_GTK_VERSION_4 */ + wc->gttk_Style_Owner = false; } else { - wc->GtkTtk_Style = QStyleFactory::create(style); - wc->GtkTtk_Style_Owner = true; + wc->gttk_Style = QStyleFactory::create(style); + wc->gttk_Style_Owner = true; } - GtkTtk_StoreStyleNameLowers(wc); - wc->GtkTtk_QScrollBar_Widget->setStyle(wc->GtkTtk_Style); - wc->GtkTtk_QComboBox_RW_Widget->setStyle(wc->GtkTtk_Style); - wc->GtkTtk_QComboBox_RO_Widget->setStyle(wc->GtkTtk_Style); - wc->GtkTtk_QWidget_WidgetParent->setStyle(wc->GtkTtk_Style); - wc->GtkTtk_QWidget_Widget->setStyle(wc->GtkTtk_Style); -#ifdef GTKTTK_GTK_VERSION_3 - wc->GtkTtk_QWidget_Widget->polish(); -#endif /* GTKTTK_GTK_VERSION_3 */ - wc->GtkTtk_QSlider_Hor_Widget->setStyle(wc->GtkTtk_Style); - wc->GtkTtk_QSlider_Ver_Widget->setStyle(wc->GtkTtk_Style); - wc->GtkTtk_QProgressBar_Hor_Widget->setStyle(wc->GtkTtk_Style); - wc->GtkTtk_GTKabWidget_Widget->setStyle(wc->GtkTtk_Style); - wc->GtkTtk_QPixmap_BackgroundTile = -#ifdef GTKTTK_GTK_VERSION_3 - (wc->GtkTtk_QWidget_Widget)->paletteBackgroundPixmap(); -#endif /* GTKTTK_GTK_VERSION_3 */ -#ifdef GTKTTK_GTK_VERSION_4 - (wc->GtkTtk_QWidget_Widget)->palette().window().texture(); -#endif /* GTKTTK_GTK_VERSION_4 */ - wc->GtkTtk_Style->polish(wc->GtkTtk_QWidget_Widget); + gttk_StoreStyleNameLowers(wc); + wc->gttk_QScrollBar_Widget->setStyle(wc->gttk_Style); + wc->gttk_QComboBox_RW_Widget->setStyle(wc->gttk_Style); + wc->gttk_QComboBox_RO_Widget->setStyle(wc->gttk_Style); + wc->gttk_QWidget_WidgetParent->setStyle(wc->gttk_Style); + wc->gttk_QWidget_Widget->setStyle(wc->gttk_Style); +#ifdef GTTK_GTK_VERSION_3 + wc->gttk_QWidget_Widget->polish(); +#endif /* GTTK_GTK_VERSION_3 */ + wc->gttk_QSlider_Hor_Widget->setStyle(wc->gttk_Style); + wc->gttk_QSlider_Ver_Widget->setStyle(wc->gttk_Style); + wc->gttk_QProgressBar_Hor_Widget->setStyle(wc->gttk_Style); + wc->gttk_GTKabWidget_Widget->setStyle(wc->gttk_Style); + wc->gttk_QPixmap_BackgroundTile = +#ifdef GTTK_GTK_VERSION_3 + (wc->gttk_QWidget_Widget)->paletteBackgroundPixmap(); +#endif /* GTTK_GTK_VERSION_3 */ +#ifdef GTTK_GTK_VERSION_4 + (wc->gttk_QWidget_Widget)->palette().window().texture(); +#endif /* GTTK_GTK_VERSION_4 */ + wc->gttk_Style->polish(wc->gttk_QWidget_Widget); if (todelete) delete todelete; #if 0 // Print Scrollbar statistics... #define SC_PRINT_INFO(subcontrol) \ - wc->GtkTtk_Style->querySubControlMetrics(QStyle::CC_ScrollBar,\ - wc->GtkTtk_QScrollBar_Widget, subcontrol).x(),\ - wc->GtkTtk_Style->querySubControlMetrics(QStyle::CC_ScrollBar,\ - wc->GtkTtk_QScrollBar_Widget, subcontrol).y(),\ - wc->GtkTtk_Style->querySubControlMetrics(QStyle::CC_ScrollBar,\ - wc->GtkTtk_QScrollBar_Widget, subcontrol).width(),\ - wc->GtkTtk_Style->querySubControlMetrics(QStyle::CC_ScrollBar,\ - wc->GtkTtk_QScrollBar_Widget, subcontrol).height() + wc->gttk_Style->querySubControlMetrics(QStyle::CC_ScrollBar,\ + wc->gttk_QScrollBar_Widget, subcontrol).x(),\ + wc->gttk_Style->querySubControlMetrics(QStyle::CC_ScrollBar,\ + wc->gttk_QScrollBar_Widget, subcontrol).y(),\ + wc->gttk_Style->querySubControlMetrics(QStyle::CC_ScrollBar,\ + wc->gttk_QScrollBar_Widget, subcontrol).width(),\ + wc->gttk_Style->querySubControlMetrics(QStyle::CC_ScrollBar,\ + wc->gttk_QScrollBar_Widget, subcontrol).height() printf("SC_ScrollBarAddLine: x=%d, y=%d, w=%d, h=%d\n", SC_PRINT_INFO(QStyle::SC_ScrollBarAddLine)); printf("SC_ScrollBarSubLine: x=%d, y=%d, w=%d, h=%d\n", SC_PRINT_INFO(QStyle::SC_ScrollBarSubLine)); printf("SC_ScrollBarAddPage: x=%d, y=%d, w=%d, h=%d\n", SC_PRINT_INFO(QStyle::SC_ScrollBarAddPage)); @@ -722,29 +744,29 @@ int Gtkttk_SetStyle(ClientData clientData, Tcl_Interp *interp, printf("SC_ScrollBarLast: x=%d, y=%d, w=%d, h=%d\n", SC_PRINT_INFO(QStyle::SC_ScrollBarLast)); #endif } - memcpy(wc_array[1], wc_array[0], sizeof(GtkTtk_WidgetCache)); + memcpy(wc_array[1], wc_array[0], sizeof(gttk_WidgetCache)); wc_array[0]->orientation = TTK_ORIENT_HORIZONTAL; wc_array[1]->orientation = TTK_ORIENT_VERTICAL; /* Save the name of the current theme... */ - Tcl_SetVar(interp, "ttk::theme::gtkTtk::theme", -#ifdef GTKTTK_GTK_VERSION_3 - wc->GtkTtk_Style->name(), TCL_GLOBAL_ONLY); -#endif /* GTKTTK_GTK_VERSION_3 */ -#ifdef GTKTTK_GTK_VERSION_4 - wc->GtkTtk_Style->objectName().toUtf8().data(), TCL_GLOBAL_ONLY); -#endif /* GTKTTK_GTK_VERSION_4 */ + Tcl_SetVar(interp, "ttk::theme::gttk::theme", +#ifdef GTTK_GTK_VERSION_3 + wc->gttk_Style->name(), TCL_GLOBAL_ONLY); +#endif /* GTTK_GTK_VERSION_3 */ +#ifdef GTTK_GTK_VERSION_4 + wc->gttk_Style->objectName().toUtf8().data(), TCL_GLOBAL_ONLY); +#endif /* GTTK_GTK_VERSION_4 */ #endif - Tcl_MutexUnlock(>kTtkMutex); + Tcl_MutexUnlock(>tkMutex); return TCL_OK; -}; /* Gtkttk_SetStyle */ +}; /* gttk_SetStyle */ extern "C" int DLLEXPORT -Gtkttk_Init(Tcl_Interp *interp) +_Gttk_Init(Tcl_Interp *interp) { Ttk_Theme themePtr; Tk_Window tkwin; char tmpScript[1024]; - GtkTtk_WidgetCache **wc = NULL; + gttk_WidgetCache **wc = NULL; GtkSettings *settings = NULL; gchar *strval = NULL; @@ -758,130 +780,109 @@ Gtkttk_Init(Tcl_Interp *interp) tkwin = Tk_MainWindow(interp); if (tkwin == NULL) return TCL_ERROR; - themePtr = Ttk_CreateTheme(interp, "gtkTtk", NULL); + themePtr = Ttk_CreateTheme(interp, "gttk", NULL); if (!themePtr) return TCL_ERROR; Tcl_CreateObjCommand(interp, - "ttk::theme::gtkTtk::initialiseLibrary", - Gtkttk_InitialiseLibrary, (ClientData) wc, NULL); + "ttk::theme::gttk::initialiseLibrary", + gttk_InitialiseLibrary, (ClientData) wc, NULL); if (Tcl_Eval(interp, initScript) != TCL_OK) { return TCL_ERROR; } -#ifdef GTKTTK_LOAD_GTK_DYNAMICALLY - if (!GtkTtk_GtkAppCreated) { +#ifdef GTTK_LOAD_GTK_DYNAMICALLY + if (!gttk_GtkAppCreated) { if (Tcl_Eval(interp, libsInitScript) != TCL_OK) { return TCL_ERROR; } } -#endif /* GTKTTK_LOAD_GTK_DYNAMICALLY */ +#endif /* GTTK_LOAD_GTK_DYNAMICALLY */ /* * Initialise Gtk: */ - Tcl_MutexLock(>kTtkMutex); - wc = GtkTtk_CreateGtkApp(interp); - ++GtkTtk_GtkAppCreated; + Tcl_MutexLock(>tkMutex); + wc = gttk_CreateGtkApp(interp); + ++gttk_GtkAppCreated; /* * Register the various widgets... */ - GtkTtk_Init_Background(interp, wc, themePtr); - GtkTtk_Init_Button(interp, wc, themePtr); - GtkTtk_Init_CheckButton(interp, wc, themePtr); - GtkTtk_Init_RadioButton(interp, wc, themePtr); - GtkTtk_Init_ToolButton(interp, wc, themePtr); - GtkTtk_Init_Labelframe(interp, wc, themePtr); - GtkTtk_Init_Entry(interp, wc, themePtr); - GtkTtk_Init_Menubutton(interp, wc, themePtr); - GtkTtk_Init_Scrollbar(interp, wc, themePtr); - GtkTtk_Init_Scale(interp, wc, themePtr); - GtkTtk_Init_Progress(interp, wc, themePtr); - GtkTtk_Init_SizeGrip(interp, wc, themePtr); - GtkTtk_Init_Paned(interp, wc, themePtr); - GtkTtk_Init_Notebook(interp, wc, themePtr); - GtkTtk_Init_Combobox(interp, wc, themePtr); + gttk_Init_Background(interp, wc, themePtr); + gttk_Init_Button(interp, wc, themePtr); + gttk_Init_CheckButton(interp, wc, themePtr); + gttk_Init_RadioButton(interp, wc, themePtr); + gttk_Init_ToolButton(interp, wc, themePtr); + gttk_Init_Labelframe(interp, wc, themePtr); + gttk_Init_Entry(interp, wc, themePtr); + gttk_Init_Menubutton(interp, wc, themePtr); + gttk_Init_Scrollbar(interp, wc, themePtr); + gttk_Init_Scale(interp, wc, themePtr); + gttk_Init_Progress(interp, wc, themePtr); + gttk_Init_SizeGrip(interp, wc, themePtr); + gttk_Init_Paned(interp, wc, themePtr); + gttk_Init_Notebook(interp, wc, themePtr); + gttk_Init_Combobox(interp, wc, themePtr); #if 0 - GtkTtk_Init_TreeView(interp, wc, themePtr); - //GtkTtk_Init_Separator(interp, wc, themePtr); - //GtkTtk_Init_Arrows(interp, wc, themePtr); + gttk_Init_TreeView(interp, wc, themePtr); + //gttk_Init_Separator(interp, wc, themePtr); + //gttk_Init_Arrows(interp, wc, themePtr); #endif - Tcl_CreateExitHandler(&GtkTtk_ExitProc, 0); - //Tcl_CreateThreadExitHandler(&GtkTtk_ExitProc, 0); + Tcl_CreateExitHandler(>tk_ExitProc, 0); + //Tcl_CreateThreadExitHandler(>tk_ExitProc, 0); - /* - * Register the TileGtk package... - */ - Tcl_CreateObjCommand(interp, "ttk::theme::gtkTtk::gtkEnum", - Gtkttk_GtkEnum, (ClientData) wc, NULL); - Tcl_CreateObjCommand(interp, "ttk::theme::gtkTtk::settingsProperty", - Gtkttk_SettingsProperty, (ClientData) wc, NULL); - Tcl_CreateObjCommand(interp, "ttk::theme::gtkTtk::widgetStyleProperty", - Gtkttk_WidgetStyleProperty, (ClientData) wc, NULL); - Tcl_CreateObjCommand(interp, "ttk::theme::gtkTtk::widgetProperty", - Gtkttk_WidgetProperty, (ClientData) wc, NULL); - Tcl_CreateObjCommand(interp, "ttk::theme::gtkTtk::currentThemeName", - Gtkttk_ThemeName, (ClientData) wc, NULL); - Tcl_CreateObjCommand(interp, "ttk::theme::gtkTtk::gtkDirectory", - Gtkttk_GtkDirectory, (ClientData) wc, NULL); - Tcl_CreateObjCommand(interp, "ttk::theme::gtkTtk::setStyle", - Gtkttk_SetStyle, (ClientData) wc, NULL); - Tcl_CreateObjCommand(interp, "ttk::theme::gtkTtk::gtk_method", - Gtkttk_gtk_method, (ClientData) wc, NULL); - Tcl_CreateObjCommand(interp, - "ttk::theme::gtkTtk::currentThemeColour", - Gtkttk_ThemeColour, (ClientData) wc, NULL); - Tcl_CreateObjCommand(interp, - "ttk::theme::gtkTtk::currentThemeColourKeys", - Gtkttk_ColourKeys, (ClientData) wc, NULL); + // Register ttk::theme::gttk Tcl commands + Tcl_CreateObjCommand(interp, "ttk::theme::gttk::gtkEnum", gttk_GtkEnum, (ClientData) wc, NULL); + Tcl_CreateObjCommand(interp, "ttk::theme::gttk::settingsProperty", gttk_SettingsProperty, (ClientData) wc, NULL); + Tcl_CreateObjCommand(interp, "ttk::theme::gttk::widgetStyleProperty", gttk_WidgetStyleProperty, (ClientData) wc, NULL); + Tcl_CreateObjCommand(interp, "ttk::theme::gttk::widgetProperty", gttk_WidgetProperty, (ClientData) wc, NULL); + Tcl_CreateObjCommand(interp, "ttk::theme::gttk::currentThemeName", gttk_ThemeName, (ClientData) wc, NULL); + Tcl_CreateObjCommand(interp, "ttk::theme::gttk::gtkDirectory", gttk_GtkDirectory, (ClientData) wc, NULL); + Tcl_CreateObjCommand(interp, "ttk::theme::gttk::setStyle", gttk_SetStyle, (ClientData) wc, NULL); + Tcl_CreateObjCommand(interp, "ttk::theme::gttk::gtk_method", gttk_gtk_method, (ClientData) wc, NULL); + Tcl_CreateObjCommand(interp, "ttk::theme::gttk::currentThemeColour", gttk_ThemeColour, (ClientData) wc, NULL); + Tcl_CreateObjCommand(interp, "ttk::theme::gttk::currentThemeColourKeys", gttk_ColourKeys, (ClientData) wc, NULL); + Tcl_CreateObjCommand(interp, "ttk::theme::gttk::setGtkTheme", gttk_set_gtk_theme, (ClientData) wc, NULL); #if 0 - Tcl_CreateObjCommand(interp, - "ttk::theme::gtkTtk::setPalette", - Gtkttk_SetPalette, (ClientData) wc, NULL); - Tcl_CreateObjCommand(interp, - "ttk::theme::gtkTtk::getPixelMetric", - Gtkttk_GetPixelMetric, (ClientData) wc, NULL); - Tcl_CreateObjCommand(interp, - "ttk::theme::gtkTtk::getStyleHint", - Gtkttk_GetStyleHint, (ClientData) wc, NULL); - Tcl_CreateObjCommand(interp, - "ttk::theme::gtkTtk::getSubControlMetrics", - Gtkttk_GetSubControlMetrics, (ClientData) wc, NULL); + Tcl_CreateObjCommand(interp, "ttk::theme::gttk::setPalette", gttk_SetPalette, (ClientData) wc, NULL); + Tcl_CreateObjCommand(interp, "ttk::theme::gttk::getPixelMetric", gttk_GetPixelMetric, (ClientData) wc, NULL); + Tcl_CreateObjCommand(interp, "ttk::theme::gttk::getStyleHint", gttk_GetStyleHint, (ClientData) wc, NULL); + Tcl_CreateObjCommand(interp, "ttk::theme::gttk::getSubControlMetrics", gttk_GetSubControlMetrics, (ClientData) wc, NULL); #endif /* Save the name of the current theme... */ - strcpy(tmpScript, "namespace eval ttk::theme::gtkTtk { variable theme "); - settings = GtkTtk_gtk_settings_get_default(); + strcpy(tmpScript, "namespace eval ttk::theme::gttk { variable theme "); + settings = gttk_gtk_settings_get_default(); if (settings) { - GtkTtk_g_object_get(settings, "gtk-theme-name", &strval, NULL); + gttk_g_object_get(settings, "gtk-theme-name", &strval, NULL); strcat(tmpScript, "{"); if (strval) { strcat(tmpScript, strval); - GtkTtk_g_free(strval); + gttk_g_free(strval); } strcat(tmpScript, "}"); } else { strcat(tmpScript, "{}"); } strcat(tmpScript, " };"); - Tcl_MutexUnlock(>kTtkMutex); + Tcl_MutexUnlock(>tkMutex); if (Tcl_Eval(interp, tmpScript) != TCL_OK) { return TCL_ERROR; } - if (Tcl_Eval(interp, "ttk::theme::gtkTtk::init") != TCL_OK) { + if (Tcl_Eval(interp, "ttk::theme::gttk::init") != TCL_OK) { return TCL_ERROR; } - Tcl_PkgProvide(interp, "ttk::theme::gtkTtk", PACKAGE_VERSION); + Tcl_PkgProvide(interp, "ttk::theme::gttk", PACKAGE_VERSION); Tcl_PkgProvide(interp, PACKAGE_NAME, PACKAGE_VERSION); return TCL_OK; -}; /* GtkTtk_Init */ +}; /* gttk_Init */ int DLLEXPORT -GtkTtk_Finish(Tcl_Interp *interp) +Gttk_Finish(Tcl_Interp *interp) { - Tcl_MutexLock(>kTtkMutex); - if (GtkTtk_GtkAppCreated < 0) {Tcl_MutexUnlock(>kTtkMutex); return 0;} - --GtkTtk_GtkAppCreated; - if (GtkTtk_GtkAppCreated == 0) GtkTtk_DestroyGtkApp(); - Tcl_MutexUnlock(>kTtkMutex); + Tcl_MutexLock(>tkMutex); + if (gttk_GtkAppCreated < 0) {Tcl_MutexUnlock(>tkMutex); return 0;} + --gttk_GtkAppCreated; + if (gttk_GtkAppCreated == 0) gttk_DestroyGtkApp(); + Tcl_MutexUnlock(>tkMutex); return 0; -}; /* GtkTtk_Finish */ +}; /* gttk_Finish */ diff --git a/generic/gtkTtk_Labelframe.cpp b/generic/gttk_Labelframe.cpp similarity index 62% rename from generic/gtkTtk_Labelframe.cpp rename to generic/gttk_Labelframe.cpp index 4d09979..7e5db13 100644 --- a/generic/gtkTtk_Labelframe.cpp +++ b/generic/gttk_Labelframe.cpp @@ -1,8 +1,8 @@ /* - * gtkTtk_Labelframe.cpp + * gttk_Labelframe.cpp * ----------------------- * - * This file is part of the gtkTtk package, a Tk/Tile based theme that uses + * This file is part of the gttk package, a Tk/Tile based theme that uses * Gtk/GNOME for drawing. * * Copyright (C) 2004-2008 by: @@ -13,9 +13,9 @@ * Aghia Paraskevi, 153 10, Athens, Greece. */ -#include "gtkTtk_Utilities.h" -#include "gtkTtk_TkHeaders.h" -#include "gtkTtk_WidgetDefaults.h" +#include "gttk_Utilities.h" +#include "gttk_TkHeaders.h" +#include "gttk_WidgetDefaults.h" #if 0 /* @@ -45,28 +45,28 @@ static void LabelframeBorderElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned state) { - GTKTTK_GTK_DRAWABLE_DEFINITIONS; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - /* GTKTTK_SETUP_GTK_DRAWABLE; */ - GtkWidget *widget = GtkTtk_GetFrame(wc); - GTKTTK_ENSURE_WIDGET_OK; - GTKTTK_STYLE_FROM_WIDGET; - GTKTTK_DRAWABLE_FROM_WIDGET; - // GTKTTK_ATTACH_STYLE_TO_WIDGET; - // GTKTTK_SETUP_WIDGET_SIZE(b.width, b.height); - // GTKTTK_WIDGET_SET_FOCUS(widget); - GTKTTK_DEFAULT_BACKGROUND; - // GtkTtk_gtk_paint_flat_box(style, gdkDrawable, gtkState, gtkShadow, NULL, + GTTK_GTK_DRAWABLE_DEFINITIONS; + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + /* GTTK_SETUP_GTK_DRAWABLE; */ + GtkWidget *widget = gttk_GetFrame(wc); + GTTK_ENSURE_WIDGET_OK; + GTTK_STYLE_FROM_WIDGET; + GTTK_DRAWABLE_FROM_WIDGET; + // GTTK_ATTACH_STYLE_TO_WIDGET; + // GTTK_SETUP_WIDGET_SIZE(b.width, b.height); + // GTTK_WIDGET_SET_FOCUS(widget); + GTTK_DEFAULT_BACKGROUND; + // gttk_gtk_paint_flat_box(style, gdkDrawable, gtkState, gtkShadow, NULL, // widget, "frame", 0, 0, b.width, b.height); - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height, 0, 0); - GtkTtk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, - GTKTTK_SECTION_BUTTONS|GTKTTK_SECTION_ALL); - GtkTtk_gtk_paint_shadow(style, gdkDrawable, gtkState, gtkShadow, NULL, widget, + gttk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, + GTTK_SECTION_BUTTONS|GTTK_SECTION_ALL); + gttk_gtk_paint_shadow(style, gdkDrawable, gtkState, gtkShadow, NULL, widget, "frame", 0, 0, b.width, b.height); - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height, b.x, b.y); - GTKTTK_CLEANUP_GTK_DRAWABLE; + GTTK_CLEANUP_GTK_DRAWABLE; } static Ttk_ElementSpec LabelframeBorderElementSpec = { @@ -86,8 +86,8 @@ TTK_BEGIN_LAYOUT(LabelframeLayout) TTK_NODE("Labelframe.border", TTK_FILL_BOTH) TTK_END_LAYOUT -int GtkTtk_Init_Labelframe(Tcl_Interp *interp, - GtkTtk_WidgetCache **wc, Ttk_Theme themePtr) +int gttk_Init_Labelframe(Tcl_Interp *interp, + gttk_WidgetCache **wc, Ttk_Theme themePtr) { /* * Register elements: @@ -101,4 +101,4 @@ int GtkTtk_Init_Labelframe(Tcl_Interp *interp, Ttk_RegisterLayout(themePtr, "TLabelframe", LabelframeLayout); return TCL_OK; -}; /* GtkTtk_Init_Labelframe */ +}; /* gttk_Init_Labelframe */ diff --git a/generic/gtkTtk_Menubutton.cpp b/generic/gttk_Menubutton.cpp similarity index 61% rename from generic/gtkTtk_Menubutton.cpp rename to generic/gttk_Menubutton.cpp index 9058abf..4a6adad 100644 --- a/generic/gtkTtk_Menubutton.cpp +++ b/generic/gttk_Menubutton.cpp @@ -1,8 +1,8 @@ /* - * gtkTtk_Menubutton.cpp + * gttk_Menubutton.cpp * ------------------- * - * This file is part of the gtkTtk package, a Tk/Tile based theme that uses + * This file is part of the gttk package, a Tk/Tile based theme that uses * Gtk/GNOME for drawing. * * Copyright (C) 2004-2008 by: @@ -13,9 +13,9 @@ * Aghia Paraskevi, 153 10, Athens, Greece. */ -#include "gtkTtk_Utilities.h" -#include "gtkTtk_TkHeaders.h" -#include "gtkTtk_WidgetDefaults.h" +#include "gttk_Utilities.h" +#include "gttk_TkHeaders.h" +#include "gttk_WidgetDefaults.h" #if 0 /* @@ -37,11 +37,11 @@ static void MenubuttonIndicatorElementGeometry( void *clientData, void *elementRecord, Tk_Window tkwin, int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr) { - GTKTTK_WIDGET_CACHE_DEFINITION; + GTTK_WIDGET_CACHE_DEFINITION; gint size = 15; - GtkWidget *widget = GtkTtk_GetComboboxEntry(wc); - GTKTTK_ENSURE_WIDGET_OK; - GtkTtk_gtk_widget_style_get(widget, "arrow-size", &size, NULL); + GtkWidget *widget = gttk_GetComboboxEntry(wc); + GTTK_ENSURE_WIDGET_OK; + gttk_gtk_widget_style_get(widget, "arrow-size", &size, NULL); *widthPtr = *heightPtr = size; *paddingPtr = Ttk_UniformPadding(3); @@ -51,38 +51,38 @@ static void MenubuttonIndicatorElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned state) { - GTKTTK_GTK_DRAWABLE_DEFINITIONS; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - /* GTKTTK_SETUP_GTK_DRAWABLE; */ - GtkWidget *widget = GtkTtk_GetCombobox(wc); - GtkWidget *arrow_widget = GtkTtk_GetArrow(wc); + GTTK_GTK_DRAWABLE_DEFINITIONS; + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + /* GTTK_SETUP_GTK_DRAWABLE; */ + GtkWidget *widget = gttk_GetCombobox(wc); + GtkWidget *arrow_widget = gttk_GetArrow(wc); gfloat arrow_scaling; gint arrow_x; gint arrow_y; gint arrow_width; gint arrow_height; - GTKTTK_ENSURE_WIDGET_OK; - GTKTTK_STYLE_FROM_WIDGET; - GTKTTK_DRAWABLE_FROM_WIDGET; - GtkTtk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, - GTKTTK_SECTION_BUTTONS|GTKTTK_SECTION_ALL); - GTKTTK_WIDGET_SET_FOCUS(widget); - GtkTtk_gtk_paint_flat_box(style, gdkDrawable, gtkState, gtkShadow, NULL, widget, + GTTK_ENSURE_WIDGET_OK; + GTTK_STYLE_FROM_WIDGET; + GTTK_DRAWABLE_FROM_WIDGET; + gttk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, + GTTK_SECTION_BUTTONS|GTTK_SECTION_ALL); + GTTK_WIDGET_SET_FOCUS(widget); + gttk_gtk_paint_flat_box(style, gdkDrawable, gtkState, gtkShadow, NULL, widget, "button", 0, 0, b.width, b.height); /* Draw the arrow, according to the desired scaling! */ - GtkTtk_gtk_widget_style_get(arrow_widget, "arrow-scaling", + gttk_gtk_widget_style_get(arrow_widget, "arrow-scaling", &arrow_scaling, NULL); if (arrow_scaling == 0.0) arrow_scaling = 1.0; arrow_width = b.width * arrow_scaling; arrow_height = b.height * arrow_scaling; arrow_x = (b.width - arrow_width) / 2; arrow_y = (b.height - arrow_height) / 2; - GtkTtk_gtk_paint_arrow(style, gdkDrawable, gtkState, gtkShadow, NULL, + gttk_gtk_paint_arrow(style, gdkDrawable, gtkState, gtkShadow, NULL, arrow_widget, "combo", GTK_ARROW_DOWN, TRUE, arrow_x, arrow_y, arrow_width, arrow_height); - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height, b.x, b.y); - GTKTTK_CLEANUP_GTK_DRAWABLE; + GTTK_CLEANUP_GTK_DRAWABLE; } static Ttk_ElementSpec MenubuttonIndicatorElementSpec = { @@ -104,11 +104,11 @@ static void MenubuttonElementGeometry( void *clientData, void *elementRecord, Tk_Window tkwin, int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr) { - GTKTTK_WIDGET_CACHE_DEFINITION; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - GtkWidget *widget = GtkTtk_GetCombobox(wc); - GTKTTK_ENSURE_WIDGET_OK; - GTKTTK_GET_WIDGET_SIZE(*widthPtr, *heightPtr); + GTTK_WIDGET_CACHE_DEFINITION; + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GtkWidget *widget = gttk_GetCombobox(wc); + GTTK_ENSURE_WIDGET_OK; + GTTK_GET_WIDGET_SIZE(*widthPtr, *heightPtr); *paddingPtr = Ttk_UniformPadding(PushButtonUniformPadding); } @@ -116,23 +116,23 @@ static void MenubuttonElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned state) { - GTKTTK_GTK_DRAWABLE_DEFINITIONS; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - /* GTKTTK_SETUP_GTK_DRAWABLE; */ - GtkWidget *widget = GtkTtk_GetCombobox(wc); - GTKTTK_ENSURE_WIDGET_OK; - GTKTTK_DRAWABLE_FROM_WIDGET; - GTKTTK_STYLE_BACKGROUND_DEFAULT; - GTKTTK_DEFAULT_BACKGROUND; - GTKTTK_STYLE_FROM_WIDGET; - GtkTtk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, - GTKTTK_SECTION_BUTTONS|GTKTTK_SECTION_ALL); - GTKTTK_WIDGET_SET_FOCUS(widget); - GtkTtk_gtk_paint_box(style, gdkDrawable, gtkState, gtkShadow, NULL, widget, + GTTK_GTK_DRAWABLE_DEFINITIONS; + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + /* GTTK_SETUP_GTK_DRAWABLE; */ + GtkWidget *widget = gttk_GetCombobox(wc); + GTTK_ENSURE_WIDGET_OK; + GTTK_DRAWABLE_FROM_WIDGET; + GTTK_STYLE_BACKGROUND_DEFAULT; + GTTK_DEFAULT_BACKGROUND; + GTTK_STYLE_FROM_WIDGET; + gttk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, + GTTK_SECTION_BUTTONS|GTTK_SECTION_ALL); + GTTK_WIDGET_SET_FOCUS(widget); + gttk_gtk_paint_box(style, gdkDrawable, gtkState, gtkShadow, NULL, widget, "button", 0, 0, b.width, b.height); - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height, b.x, b.y); - GTKTTK_CLEANUP_GTK_DRAWABLE; + GTTK_CLEANUP_GTK_DRAWABLE; } static Ttk_ElementSpec MenubuttonElementSpec = { @@ -155,8 +155,8 @@ TTK_BEGIN_LAYOUT(MenubuttonLayout) TTK_NODE("Menubutton.label", TTK_PACK_LEFT)))) TTK_END_LAYOUT -int GtkTtk_Init_Menubutton(Tcl_Interp *interp, - GtkTtk_WidgetCache **wc, Ttk_Theme themePtr) +int gttk_Init_Menubutton(Tcl_Interp *interp, + gttk_WidgetCache **wc, Ttk_Theme themePtr) { /* * Register elements: @@ -171,4 +171,4 @@ int GtkTtk_Init_Menubutton(Tcl_Interp *interp, */ Ttk_RegisterLayout(themePtr, "TMenubutton", MenubuttonLayout); return TCL_OK; -}; /* GtkTtk_Init_Menubutton */ +}; /* gttk_Init_Menubutton */ diff --git a/generic/gtkTtk_Notebook.cpp b/generic/gttk_Notebook.cpp similarity index 67% rename from generic/gtkTtk_Notebook.cpp rename to generic/gttk_Notebook.cpp index 8c693a4..ece06a2 100644 --- a/generic/gtkTtk_Notebook.cpp +++ b/generic/gttk_Notebook.cpp @@ -1,8 +1,8 @@ /* - * gtkTtk_Notebook.cpp + * gttk_Notebook.cpp * --------------------- * - * This file is part of the gtkTtk package, a Tk/Tile based theme that uses + * This file is part of the gttk package, a Tk/Tile based theme that uses * Gtk/GNOME for drawing. * * Copyright (C) 2004-2008 by: @@ -13,9 +13,9 @@ * Aghia Paraskevi, 153 10, Athens, Greece. */ -#include "gtkTtk_Utilities.h" -#include "gtkTtk_TkHeaders.h" -#include "gtkTtk_WidgetDefaults.h" +#include "gttk_Utilities.h" +#include "gttk_TkHeaders.h" +#include "gttk_WidgetDefaults.h" #if 0 /* @@ -38,12 +38,12 @@ static void NotebookTabElementGeometry( void *clientData, void *elementRecord, Tk_Window tkwin, int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr) { - GTKTTK_WIDGET_CACHE_DEFINITION; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - GtkWidget *widget = GtkTtk_GetNotebook(wc); + GTTK_WIDGET_CACHE_DEFINITION; + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GtkWidget *widget = gttk_GetNotebook(wc); gint focus_width = 1, tab_curvature = 1; - GTKTTK_ENSURE_WIDGET_OK; - GtkTtk_gtk_widget_style_get(widget, "focus-line-width", &focus_width, + GTTK_ENSURE_WIDGET_OK; + gttk_gtk_widget_style_get(widget, "focus-line-width", &focus_width, "tab-curvature", &tab_curvature, NULL); *paddingPtr = Ttk_UniformPadding(tab_curvature + focus_width + ((GtkNotebook *)widget)->tab_hborder); @@ -55,20 +55,20 @@ static void NotebookTabElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned state) { - GTKTTK_GTK_DRAWABLE_DEFINITIONS; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GTTK_GTK_DRAWABLE_DEFINITIONS; + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; int height_with_overlap = b.height + TAB_BASE_OVERLAP_MAX; int dh = 0; - /* GTKTTK_SETUP_GTK_DRAWABLE_PIXMAP_SIZE(b.width, height_with_overlap); */ - /* GtkWidget *widget = GtkTtk_GetNotebook(wc); */ + /* GTTK_SETUP_GTK_DRAWABLE_PIXMAP_SIZE(b.width, height_with_overlap); */ + /* GtkWidget *widget = gttk_GetNotebook(wc); */ /* 10 Aug 2009: Notebook widgets usually have a lighter background. * To avoid multiple background colours inside the widget, * use a frame for drawing instead of a notebook gtk widget. */ - GtkWidget *widget = GtkTtk_GetFrame(wc); - GTKTTK_ENSURE_WIDGET_OK; - GTKTTK_STYLE_FROM_WIDGET; - GTKTTK_DRAWABLE_FROM_WIDGET_SIZE(b.width, height_with_overlap); - GtkTtk_gtk_style_apply_default_background(style, gdkDrawable, TRUE, + GtkWidget *widget = gttk_GetFrame(wc); + GTTK_ENSURE_WIDGET_OK; + GTTK_STYLE_FROM_WIDGET; + GTTK_DRAWABLE_FROM_WIDGET_SIZE(b.width, height_with_overlap); + gttk_gtk_style_apply_default_background(style, gdkDrawable, TRUE, gtkState, NULL, 0, 0, b.width, height_with_overlap); if (state & TTK_STATE_SELECTED) { @@ -82,15 +82,15 @@ static void NotebookTabElementDraw( } else if (state & TTK_STATE_USER2) { /* This is the last tab! */ } - GTKTTK_DEFAULT_BACKGROUND; - GtkTtk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, - GTKTTK_SECTION_TABS|GTKTTK_SECTION_ALL); - // GtkTtk_StateInfo(state, gtkState, gtkShadow, tkwin, widget); - GtkTtk_gtk_paint_extension(style, gdkDrawable, gtkState, gtkShadow, NULL, + GTTK_DEFAULT_BACKGROUND; + gttk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, + GTTK_SECTION_TABS|GTTK_SECTION_ALL); + // gttk_StateInfo(state, gtkState, gtkShadow, tkwin, widget); + gttk_gtk_paint_extension(style, gdkDrawable, gtkState, gtkShadow, NULL, widget, (char *) "tab", 0, 0, b.width, b.height + dh, GTK_POS_BOTTOM); - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height + dh, b.x, b.y); - GTKTTK_CLEANUP_GTK_DRAWABLE; + GTTK_CLEANUP_GTK_DRAWABLE; } static Ttk_ElementSpec NotebookTabElementSpec = { @@ -123,26 +123,26 @@ static void NotebookClientElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned state) { - GTKTTK_GTK_DRAWABLE_DEFINITIONS; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - /* GTKTTK_SETUP_GTK_DRAWABLE; */ - /* GtkWidget *widget = GtkTtk_GetNotebook(wc); */ + GTTK_GTK_DRAWABLE_DEFINITIONS; + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + /* GTTK_SETUP_GTK_DRAWABLE; */ + /* GtkWidget *widget = gttk_GetNotebook(wc); */ /* 10 Aug 2009: Notebook widgets usually have a lighter background. * To avoid multiple background colours inside the widget, * use a frame for drawing instead of a notebook gtk widget. */ - GtkWidget *widget = GtkTtk_GetFrame(wc); - GTKTTK_ENSURE_WIDGET_OK; - GTKTTK_STYLE_FROM_WIDGET; - GTKTTK_DRAWABLE_FROM_WIDGET; - // GtkTtk_gtk_paint_box_gap(style, gdkDrawable, + GtkWidget *widget = gttk_GetFrame(wc); + GTTK_ENSURE_WIDGET_OK; + GTTK_STYLE_FROM_WIDGET; + GTTK_DRAWABLE_FROM_WIDGET; + // gttk_gtk_paint_box_gap(style, gdkDrawable, // GTK_STATE_NORMAL,GTK_SHADOW_OUT, // NULL, widget, (char *) "notebook", 0, 0, b.width, b.height, // GTK_POS_TOP, 0, 0); - GtkTtk_gtk_paint_box(style, gdkDrawable, GTK_STATE_NORMAL, GTK_SHADOW_OUT, + gttk_gtk_paint_box(style, gdkDrawable, GTK_STATE_NORMAL, GTK_SHADOW_OUT, NULL, widget, (char *) "notebook", 0, 0, b.width, b.height); - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height, b.x, b.y); - GTKTTK_CLEANUP_GTK_DRAWABLE; + GTTK_CLEANUP_GTK_DRAWABLE; } static Ttk_ElementSpec NotebookClientElementSpec = { @@ -157,8 +157,8 @@ static Ttk_ElementSpec NotebookClientElementSpec = { * +++ Widget layout. */ -int GtkTtk_Init_Notebook(Tcl_Interp *interp, - GtkTtk_WidgetCache **wc, Ttk_Theme themePtr) +int gttk_Init_Notebook(Tcl_Interp *interp, + gttk_WidgetCache **wc, Ttk_Theme themePtr) { /* * Register elements: @@ -173,4 +173,4 @@ int GtkTtk_Init_Notebook(Tcl_Interp *interp, */ return TCL_OK; -}; /* GtkTtk_Init_Notebook */ +}; /* gttk_Init_Notebook */ diff --git a/generic/gtkTtk_Paned.cpp b/generic/gttk_Paned.cpp similarity index 67% rename from generic/gtkTtk_Paned.cpp rename to generic/gttk_Paned.cpp index 07238a2..8a7c87b 100644 --- a/generic/gtkTtk_Paned.cpp +++ b/generic/gttk_Paned.cpp @@ -1,8 +1,8 @@ /* - * gtkTtk_Paned.cpp + * gttk_Paned.cpp * --------------------- * - * This file is part of the gtkTtk package, a Tk/Tile based theme that uses + * This file is part of the gttk package, a Tk/Tile based theme that uses * Gtk/GNOME for drawing. * * Copyright (C) 2004-2008 by: @@ -13,9 +13,9 @@ * Aghia Paraskevi, 153 10, Athens, Greece. */ -#include "gtkTtk_Utilities.h" -#include "gtkTtk_TkHeaders.h" -#include "gtkTtk_WidgetDefaults.h" +#include "gttk_Utilities.h" +#include "gttk_TkHeaders.h" +#include "gttk_WidgetDefaults.h" #if 0 /* @@ -37,12 +37,12 @@ static void PanedSashGripElementGeometry( void *clientData, void *elementRecord, Tk_Window tkwin, int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr) { - GTKTTK_WIDGET_CACHE_DEFINITION; - GtkWidget *widget = GtkTtk_GetPaned(wc); + GTTK_WIDGET_CACHE_DEFINITION; + GtkWidget *widget = gttk_GetPaned(wc); gint size = 5; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - GTKTTK_ENSURE_WIDGET_OK; - GtkTtk_gtk_widget_style_get(widget, "handle-size", &size, NULL); + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GTTK_ENSURE_WIDGET_OK; + gttk_gtk_widget_style_get(widget, "handle-size", &size, NULL); if (wc->orientation == TTK_ORIENT_HORIZONTAL) { *widthPtr = size; } else { @@ -55,22 +55,22 @@ static void PanedSashGripElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned state) { - GTKTTK_GTK_DRAWABLE_DEFINITIONS; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - /* GTKTTK_SETUP_GTK_DRAWABLE; */ - GtkWidget *widget = GtkTtk_GetPaned(wc); - GTKTTK_ENSURE_WIDGET_OK; - GTKTTK_STYLE_FROM_WIDGET; - GTKTTK_DRAWABLE_FROM_WIDGET; - GtkTtk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, - GTKTTK_SECTION_SASH|GTKTTK_SECTION_ALL); - GTKTTK_DEFAULT_BACKGROUND; - GtkTtk_gtk_paint_handle(style, gdkDrawable, gtkState, GTK_SHADOW_NONE, + GTTK_GTK_DRAWABLE_DEFINITIONS; + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + /* GTTK_SETUP_GTK_DRAWABLE; */ + GtkWidget *widget = gttk_GetPaned(wc); + GTTK_ENSURE_WIDGET_OK; + GTTK_STYLE_FROM_WIDGET; + GTTK_DRAWABLE_FROM_WIDGET; + gttk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, + GTTK_SECTION_SASH|GTTK_SECTION_ALL); + GTTK_DEFAULT_BACKGROUND; + gttk_gtk_paint_handle(style, gdkDrawable, gtkState, GTK_SHADOW_NONE, NULL, widget, "paned", 0, 0, b.width, b.height, wc->gtkOrientation); - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height, b.x, b.y); - GTKTTK_CLEANUP_GTK_DRAWABLE; + GTTK_CLEANUP_GTK_DRAWABLE; }; /* PanedSashGripElementDraw */ static Ttk_ElementSpec PanedSashGripElementSpec = { @@ -95,8 +95,8 @@ TTK_BEGIN_LAYOUT(VerticalSashLayout) TTK_NODE("Sash.vgrip", TTK_FILL_BOTH)) TTK_END_LAYOUT -int GtkTtk_Init_Paned(Tcl_Interp *interp, - GtkTtk_WidgetCache **wc, Ttk_Theme themePtr) +int gttk_Init_Paned(Tcl_Interp *interp, + gttk_WidgetCache **wc, Ttk_Theme themePtr) { /* * Register elements: @@ -113,4 +113,4 @@ int GtkTtk_Init_Paned(Tcl_Interp *interp, Ttk_RegisterLayout(themePtr, "Vertical.Sash", VerticalSashLayout); return TCL_OK; -}; /* GtkTtk_Init_Paned */ +}; /* gttk_Init_Paned */ diff --git a/generic/gtkTtk_Progress.cpp b/generic/gttk_Progress.cpp similarity index 68% rename from generic/gtkTtk_Progress.cpp rename to generic/gttk_Progress.cpp index 9067026..1cb58bb 100644 --- a/generic/gtkTtk_Progress.cpp +++ b/generic/gttk_Progress.cpp @@ -1,8 +1,8 @@ /* - * gtkTtk_Progress.cpp + * gttk_Progress.cpp * --------------------- * - * This file is part of the gtkTtk package, a Tk/Tile based theme that uses + * This file is part of the gttk package, a Tk/Tile based theme that uses * Gtk/GNOME for drawing. * * Copyright (C) 2004-2008 by: @@ -13,9 +13,9 @@ * Aghia Paraskevi, 153 10, Athens, Greece. */ -#include "gtkTtk_Utilities.h" -#include "gtkTtk_TkHeaders.h" -#include "gtkTtk_WidgetDefaults.h" +#include "gttk_Utilities.h" +#include "gttk_TkHeaders.h" +#include "gttk_WidgetDefaults.h" #if 0 /* @@ -44,24 +44,24 @@ static void ProgressTroughElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned state) { - GTKTTK_GTK_DRAWABLE_DEFINITIONS; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - /* GTKTTK_SETUP_GTK_DRAWABLE; */ - GtkWidget *widget = GtkTtk_GetProgressBar(wc); - GTKTTK_ENSURE_WIDGET_OK; - GTKTTK_STYLE_FROM_WIDGET; - GTKTTK_DRAWABLE_FROM_WIDGET; - GtkTtk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, - GTKTTK_SECTION_TROUGH|GTKTTK_SECTION_ALL); - // GTKTTK_SETUP_WIDGET_SIZE(b.width, b.height); - GTKTTK_WIDGET_SET_FOCUS(widget); - // GTKTTK_DEFAULT_BACKGROUND; - // GtkTtk_StateInfo(state, gtkState, gtkShadow, tkwin, widget); - GtkTtk_gtk_paint_box(style, gdkDrawable, gtkState, GTK_SHADOW_IN, NULL, widget, + GTTK_GTK_DRAWABLE_DEFINITIONS; + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + /* GTTK_SETUP_GTK_DRAWABLE; */ + GtkWidget *widget = gttk_GetProgressBar(wc); + GTTK_ENSURE_WIDGET_OK; + GTTK_STYLE_FROM_WIDGET; + GTTK_DRAWABLE_FROM_WIDGET; + gttk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, + GTTK_SECTION_TROUGH|GTTK_SECTION_ALL); + // GTTK_SETUP_WIDGET_SIZE(b.width, b.height); + GTTK_WIDGET_SET_FOCUS(widget); + // GTTK_DEFAULT_BACKGROUND; + // gttk_StateInfo(state, gtkState, gtkShadow, tkwin, widget); + gttk_gtk_paint_box(style, gdkDrawable, gtkState, GTK_SHADOW_IN, NULL, widget, "trough", 0, 0, b.width, b.height); - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height, b.x, b.y); - GTKTTK_CLEANUP_GTK_DRAWABLE; + GTTK_CLEANUP_GTK_DRAWABLE; } static Ttk_ElementSpec ProgressTroughElementSpec = { @@ -111,13 +111,13 @@ static void ProgressBarElementDraw( //int width = Tk_Width(tkwin), height = Tk_Height(tkwin); //bool determinate = true; //double value, maximum; - GTKTTK_GTK_DRAWABLE_DEFINITIONS; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - /* GTKTTK_SETUP_GTK_DRAWABLE; */ - GtkWidget *widget = GtkTtk_GetProgressBar(wc); - GTKTTK_ENSURE_WIDGET_OK; - GTKTTK_STYLE_FROM_WIDGET; - GTKTTK_DRAWABLE_FROM_WIDGET; + GTTK_GTK_DRAWABLE_DEFINITIONS; + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + /* GTTK_SETUP_GTK_DRAWABLE; */ + GtkWidget *widget = gttk_GetProgressBar(wc); + GTTK_ENSURE_WIDGET_OK; + GTTK_STYLE_FROM_WIDGET; + GTTK_DRAWABLE_FROM_WIDGET; // Tcl_GetDoubleFromObj(NULL, pbar->valueObj, &value); // Tcl_GetDoubleFromObj(NULL, pbar->maximumObj, &maximum); // if (strncmp(Tcl_GetString(pbar->modeObj), "determinate", 10) != 0) { @@ -125,27 +125,27 @@ static void ProgressBarElementDraw( // } // if (determinate) { - // GtkTtk_gtk_progress_bar_set_bar_style((GtkProgressBar *) widget, + // gttk_gtk_progress_bar_set_bar_style((GtkProgressBar *) widget, // GTK_PROGRESS_DISCRETE); - // GtkTtk_gtk_progress_bar_set_fraction((GtkProgressBar *) widget, - // GtkTtk_ValueFromSlider(wc, tkwin, b)); + // gttk_gtk_progress_bar_set_fraction((GtkProgressBar *) widget, + // gttk_ValueFromSlider(wc, tkwin, b)); // } else { - // GtkTtk_gtk_progress_bar_set_bar_style((GtkProgressBar *) widget, + // gttk_gtk_progress_bar_set_bar_style((GtkProgressBar *) widget, // GTK_PROGRESS_CONTINUOUS); - // GtkTtk_gtk_progress_bar_set_fraction((GtkProgressBar *) widget, - // GtkTtk_ValueFromSlider(wc, tkwin, b)); + // gttk_gtk_progress_bar_set_fraction((GtkProgressBar *) widget, + // gttk_ValueFromSlider(wc, tkwin, b)); // } - GTKTTK_WIDGET_SET_FOCUS(widget); - // GTKTTK_DEFAULT_BACKGROUND; - GtkTtk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, - GTKTTK_SECTION_SCROLLBAR|GTKTTK_SECTION_ALL); - // GtkTtk_StateInfo(state, gtkState, gtkShadow, tkwin, widget); - GtkTtk_gtk_paint_box(style, gdkDrawable, gtkState, gtkShadow, NULL, widget, + GTTK_WIDGET_SET_FOCUS(widget); + // GTTK_DEFAULT_BACKGROUND; + gttk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, + GTTK_SECTION_SCROLLBAR|GTTK_SECTION_ALL); + // gttk_StateInfo(state, gtkState, gtkShadow, tkwin, widget); + gttk_gtk_paint_box(style, gdkDrawable, gtkState, gtkShadow, NULL, widget, "bar", 0, 0, b.width, b.height); - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height, b.x, b.y); - GTKTTK_CLEANUP_GTK_DRAWABLE; + GTTK_CLEANUP_GTK_DRAWABLE; } static Ttk_ElementSpec ProgressBarElementSpec = { @@ -170,8 +170,8 @@ TTK_BEGIN_LAYOUT(HorizontalProgressBarLayout) TTK_NODE("Horizontal.Progressbar.pbar", TTK_PACK_LEFT|TTK_FILL_Y)) TTK_END_LAYOUT -int GtkTtk_Init_Progress(Tcl_Interp *interp, - GtkTtk_WidgetCache **wc, Ttk_Theme themePtr) +int gttk_Init_Progress(Tcl_Interp *interp, + gttk_WidgetCache **wc, Ttk_Theme themePtr) { /* * Register elements: @@ -195,4 +195,4 @@ int GtkTtk_Init_Progress(Tcl_Interp *interp, "Vertical.TProgressbar", VerticalProgressBarLayout); return TCL_OK; -}; /* GtkTtk_Init_Progress */ +}; /* gttk_Init_Progress */ diff --git a/generic/gtkTtk_RadioButton.cpp b/generic/gttk_RadioButton.cpp similarity index 66% rename from generic/gtkTtk_RadioButton.cpp rename to generic/gttk_RadioButton.cpp index 887817d..8a83e37 100644 --- a/generic/gtkTtk_RadioButton.cpp +++ b/generic/gttk_RadioButton.cpp @@ -1,8 +1,8 @@ /* - * gtkTtk_RadioButton.cpp + * gttk_RadioButton.cpp * ------------------------ * - * This file is part of the gtkTtk package, a Tk/Tile based theme that uses + * This file is part of the gttk package, a Tk/Tile based theme that uses * Gtk/GNOME for drawing. * * Copyright (C) 2004-2008 by: @@ -13,9 +13,9 @@ * Aghia Paraskevi, 153 10, Athens, Greece. */ -#include "gtkTtk_Utilities.h" -#include "gtkTtk_TkHeaders.h" -#include "gtkTtk_WidgetDefaults.h" +#include "gttk_Utilities.h" +#include "gttk_TkHeaders.h" +#include "gttk_WidgetDefaults.h" typedef struct { } RadioButtonIndicatorElement; @@ -29,13 +29,13 @@ static void RadioButtonIndicatorElementGeometry( void *clientData, void *elementRecord, Tk_Window tkwin, int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr) { - GTKTTK_WIDGET_CACHE_DEFINITION; + GTTK_WIDGET_CACHE_DEFINITION; gint size, spacing = RadioButtonHorizontalPadding; gint focus_width, focus_pad; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - GtkWidget *widget = GtkTtk_GetRadioButton(wc); - GTKTTK_ENSURE_WIDGET_OK; - GtkTtk_gtk_widget_style_get(widget, + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GtkWidget *widget = gttk_GetRadioButton(wc); + GTTK_ENSURE_WIDGET_OK; + gttk_gtk_widget_style_get(widget, "indicator-size", &size, "indicator-spacing", &spacing, "focus-line-width", &focus_width, @@ -49,32 +49,32 @@ static void RadioButtonIndicatorElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned state) { - GTKTTK_GTK_DRAWABLE_DEFINITIONS; + GTTK_GTK_DRAWABLE_DEFINITIONS; gint indicator_size, x, y; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - GtkWidget *widget = GtkTtk_GetRadioButton(wc); - GTKTTK_ENSURE_WIDGET_OK; - GTKTTK_DRAWABLE_FROM_WIDGET_SIZE(b.width+20, b.height+20); - GTKTTK_STYLE_BACKGROUND_DEFAULT; - GTKTTK_DEFAULT_BACKGROUND_SIZE(b.width+20, b.height+20); - GTKTTK_STYLE_FROM_WIDGET; - GTKTTK_WIDGET_SET_FOCUS(widget); - GtkTtk_gtk_widget_style_get(widget, + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GtkWidget *widget = gttk_GetRadioButton(wc); + GTTK_ENSURE_WIDGET_OK; + GTTK_DRAWABLE_FROM_WIDGET_SIZE(b.width+20, b.height+20); + GTTK_STYLE_BACKGROUND_DEFAULT; + GTTK_DEFAULT_BACKGROUND_SIZE(b.width+20, b.height+20); + GTTK_STYLE_FROM_WIDGET; + GTTK_WIDGET_SET_FOCUS(widget); + gttk_gtk_widget_style_get(widget, "indicator-size", &indicator_size, NULL); - GtkTtk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, - GTKTTK_SECTION_BUTTONS|GTKTTK_SECTION_ALL); + gttk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, + GTTK_SECTION_BUTTONS|GTTK_SECTION_ALL); if (state & TTK_STATE_FOCUS) { - GtkTtk_gtk_paint_focus(style, gdkDrawable, gtkState, NULL, widget, + gttk_gtk_paint_focus(style, gdkDrawable, gtkState, NULL, widget, "radiobutton", 0, 0, b.width + 20, b.height + 20); } - // GtkTtk_StateInfo(state, gtkState, gtkShadow, tkwin, widget); + // gttk_StateInfo(state, gtkState, gtkShadow, tkwin, widget); x = 10 + (b.width - indicator_size) / 2; y = 10 + (b.height - indicator_size) / 2; - GtkTtk_gtk_paint_option(style, gdkDrawable, gtkState, gtkShadow, NULL, + gttk_gtk_paint_option(style, gdkDrawable, gtkState, gtkShadow, NULL, widget, "radiobutton", x, y, indicator_size, indicator_size); - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 10, 10, b.width, b.height, b.x, b.y); - GTKTTK_CLEANUP_GTK_DRAWABLE; + GTTK_CLEANUP_GTK_DRAWABLE; } static Ttk_ElementSpec RadioButtonIndicatorElementSpec = { @@ -97,13 +97,13 @@ static void RadioButtonBorderElementGeometry( void *clientData, void *elementRecord, Tk_Window tkwin, int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr) { - GTKTTK_WIDGET_CACHE_DEFINITION; + GTTK_WIDGET_CACHE_DEFINITION; gint focus_width; gint focus_pad; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - GtkWidget *widget = GtkTtk_GetRadioButton(wc); - GTKTTK_ENSURE_WIDGET_OK; - GtkTtk_gtk_widget_style_get(widget, + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GtkWidget *widget = gttk_GetRadioButton(wc); + GTTK_ENSURE_WIDGET_OK; + gttk_gtk_widget_style_get(widget, "focus-line-width", &focus_width, "focus-padding", &focus_pad, NULL); *paddingPtr = Ttk_UniformPadding(focus_width + focus_pad); @@ -113,31 +113,31 @@ static void RadioButtonBorderElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned state) { - GTKTTK_GTK_DRAWABLE_DEFINITIONS; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - GtkWidget *widget = GtkTtk_GetRadioButton(wc); - GTKTTK_ENSURE_WIDGET_OK; - GTKTTK_DRAWABLE_FROM_WIDGET; - GTKTTK_STYLE_BACKGROUND_DEFAULT; - GTKTTK_DEFAULT_BACKGROUND; + GTTK_GTK_DRAWABLE_DEFINITIONS; + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GtkWidget *widget = gttk_GetRadioButton(wc); + GTTK_ENSURE_WIDGET_OK; + GTTK_DRAWABLE_FROM_WIDGET; + GTTK_STYLE_BACKGROUND_DEFAULT; + GTTK_DEFAULT_BACKGROUND; if (state & TTK_STATE_FOCUS) { gint border_width = ((GtkContainer*) widget)->border_width; gint focus_width; gint focus_pad; - GTKTTK_STYLE_FROM_WIDGET; - GTKTTK_WIDGET_SET_FOCUS(widget); - GtkTtk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, - GTKTTK_SECTION_BUTTONS|GTKTTK_SECTION_ALL); - GtkTtk_gtk_widget_style_get(widget, + GTTK_STYLE_FROM_WIDGET; + GTTK_WIDGET_SET_FOCUS(widget); + gttk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, + GTTK_SECTION_BUTTONS|GTTK_SECTION_ALL); + gttk_gtk_widget_style_get(widget, "focus-line-width", &focus_width, "focus-padding", &focus_pad, NULL); - GtkTtk_gtk_paint_focus(style, gdkDrawable, gtkState, NULL, widget, + gttk_gtk_paint_focus(style, gdkDrawable, gtkState, NULL, widget, "radiobutton", b.x + border_width, b.y + border_width, b.width - 2 * border_width, b.height - 2 * border_width); } - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height, b.x, b.y); - GTKTTK_CLEANUP_GTK_DRAWABLE; + GTTK_CLEANUP_GTK_DRAWABLE; } static Ttk_ElementSpec RadioButtonBorderElementSpec = { @@ -169,8 +169,8 @@ TTK_BEGIN_LAYOUT(RadiobuttonLayout) TTK_NODE("Radiobutton.label", TTK_PACK_LEFT|TTK_STICK_W|TTK_FILL_BOTH))) TTK_END_LAYOUT -int GtkTtk_Init_RadioButton(Tcl_Interp *interp, - GtkTtk_WidgetCache **wc, Ttk_Theme themePtr) +int gttk_Init_RadioButton(Tcl_Interp *interp, + gttk_WidgetCache **wc, Ttk_Theme themePtr) { /* * Register elements: @@ -186,4 +186,4 @@ int GtkTtk_Init_RadioButton(Tcl_Interp *interp, Ttk_RegisterLayout(themePtr, "TRadiobutton", RadiobuttonLayout); return TCL_OK; -}; /* GtkTtk_Init_RadioButton */ +}; /* gttk_Init_RadioButton */ diff --git a/generic/gtkTtk_Scale.cpp b/generic/gttk_Scale.cpp similarity index 67% rename from generic/gtkTtk_Scale.cpp rename to generic/gttk_Scale.cpp index 2562224..b8bcc3a 100644 --- a/generic/gtkTtk_Scale.cpp +++ b/generic/gttk_Scale.cpp @@ -1,8 +1,8 @@ /* - * gtkTtk_Scale.cpp + * gttk_Scale.cpp * --------------------- * - * This file is part of the gtkTtk package, a Tk/Tile based theme that uses + * This file is part of the gttk package, a Tk/Tile based theme that uses * Gtk/GNOME for drawing. * * Copyright (C) 2004-2008 by: @@ -13,9 +13,9 @@ * Aghia Paraskevi, 153 10, Athens, Greece. */ -#include "gtkTtk_Utilities.h" -#include "gtkTtk_TkHeaders.h" -#include "gtkTtk_WidgetDefaults.h" +#include "gttk_Utilities.h" +#include "gttk_TkHeaders.h" +#include "gttk_WidgetDefaults.h" #if 0 /* @@ -37,13 +37,13 @@ static void ScaleTroughElementGeometry( void *clientData, void *elementRecord, Tk_Window tkwin, int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr) { - GTKTTK_WIDGET_CACHE_DEFINITION; + GTTK_WIDGET_CACHE_DEFINITION; gint trough_border = 0; int xt = 0, yt = 0; - GtkWidget *widget = GtkTtk_GetScale(wc); - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - GTKTTK_ENSURE_WIDGET_OK; - GtkTtk_gtk_widget_style_get(widget, "trough-border", &trough_border, NULL); + GtkWidget *widget = gttk_GetScale(wc); + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GTTK_ENSURE_WIDGET_OK; + gttk_gtk_widget_style_get(widget, "trough-border", &trough_border, NULL); // xt = widget->style->xthickness; // yt = widget->style->ythickness; *paddingPtr = Ttk_MakePadding(xt + trough_border, @@ -56,44 +56,44 @@ static void ScaleTroughElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned state) { - GTKTTK_GTK_DRAWABLE_DEFINITIONS; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - GtkWidget *widget = GtkTtk_GetScale(wc); + GTTK_GTK_DRAWABLE_DEFINITIONS; + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GtkWidget *widget = gttk_GetScale(wc); gboolean trough_side_details = FALSE; - GTKTTK_ENSURE_WIDGET_OK; - GTKTTK_DRAWABLE_FROM_WIDGET; - GTKTTK_STYLE_BACKGROUND_DEFAULT; - GTKTTK_DEFAULT_BACKGROUND; - GTKTTK_STYLE_FROM_WIDGET; - GtkTtk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, - GTKTTK_SECTION_TROUGH|GTKTTK_SECTION_ALL); - GTKTTK_WIDGET_SET_FOCUS(widget); - GtkTtk_gtk_widget_style_get(widget, "trough-side-details", + GTTK_ENSURE_WIDGET_OK; + GTTK_DRAWABLE_FROM_WIDGET; + GTTK_STYLE_BACKGROUND_DEFAULT; + GTTK_DEFAULT_BACKGROUND; + GTTK_STYLE_FROM_WIDGET; + gttk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, + GTTK_SECTION_TROUGH|GTTK_SECTION_ALL); + GTTK_WIDGET_SET_FOCUS(widget); + gttk_gtk_widget_style_get(widget, "trough-side-details", &trough_side_details, NULL); - // GtkTtk_StateInfo(state, gtkState, gtkShadow, tkwin, widget); + // gttk_StateInfo(state, gtkState, gtkShadow, tkwin, widget); if (trough_side_details) { int trough_change_pos_x = b.width, trough_change_pos_y = b.height; if (wc->gtkOrientation == GTK_ORIENTATION_HORIZONTAL) trough_change_pos_x = b.width / 2; else trough_change_pos_y = b.height / 2; - GtkTtk_gtk_paint_box(style, gdkDrawable, gtkState, GTK_SHADOW_IN, NULL, + gttk_gtk_paint_box(style, gdkDrawable, gtkState, GTK_SHADOW_IN, NULL, widget, "trough-upper", 0, 0, trough_change_pos_x, trough_change_pos_y); if (wc->gtkOrientation == GTK_ORIENTATION_HORIZONTAL) trough_change_pos_y = 0; else trough_change_pos_x = 0; - GtkTtk_gtk_paint_box(style, gdkDrawable, gtkState, GTK_SHADOW_IN, NULL, + gttk_gtk_paint_box(style, gdkDrawable, gtkState, GTK_SHADOW_IN, NULL, widget, "trough-lower", trough_change_pos_x, trough_change_pos_y, b.width-trough_change_pos_x, b.height-trough_change_pos_y); } else { - GtkTtk_gtk_paint_box(style, gdkDrawable, gtkState, GTK_SHADOW_IN, NULL, + gttk_gtk_paint_box(style, gdkDrawable, gtkState, GTK_SHADOW_IN, NULL, widget, "trough", 0, 0, b.width, b.height); } - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height, b.x, b.y); - GTKTTK_CLEANUP_GTK_DRAWABLE; + GTTK_CLEANUP_GTK_DRAWABLE; } static Ttk_ElementSpec ScaleTroughElementSpec = { @@ -118,12 +118,12 @@ static void ScaleSliderElementGeometry( void *clientData, void *elementRecord, Tk_Window tkwin, int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr) { - GTKTTK_WIDGET_CACHE_DEFINITION; + GTTK_WIDGET_CACHE_DEFINITION; gint slider_len = 0, slider_width = ScaleThumbMinimumLen; - GtkWidget *widget = GtkTtk_GetScale(wc); - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - GTKTTK_ENSURE_WIDGET_OK; - GtkTtk_gtk_widget_style_get(widget, + GtkWidget *widget = gttk_GetScale(wc); + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GTTK_ENSURE_WIDGET_OK; + gttk_gtk_widget_style_get(widget, "slider-length", &slider_len, "slider-width", &slider_width, NULL); *heightPtr = *widthPtr = slider_width; @@ -141,29 +141,29 @@ static void ScaleSliderElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned state) { - GTKTTK_GTK_DRAWABLE_DEFINITIONS; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - GtkWidget *widget = GtkTtk_GetScale(wc); + GTTK_GTK_DRAWABLE_DEFINITIONS; + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GtkWidget *widget = gttk_GetScale(wc); GtkAdjustment *adj = NULL; - GTKTTK_ENSURE_WIDGET_OK; - GTKTTK_DRAWABLE_FROM_WIDGET; - GTKTTK_STYLE_BACKGROUND_DEFAULT; - GTKTTK_DEFAULT_BACKGROUND; - GTKTTK_STYLE_FROM_WIDGET; - GTKTTK_WIDGET_SET_FOCUS(widget); - adj = GtkTtk_gtk_range_get_adjustment((GtkRange *) widget); - GtkTtk_gtk_adjustment_set_value(adj, - GtkTtk_ValueFromSlider(wc, tkwin, b)); - GtkTtk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, - GTKTTK_SECTION_SCROLLBAR|GTKTTK_SECTION_ALL); - // GtkTtk_StateInfo(state, gtkState, gtkShadow, tkwin, widget); - GtkTtk_gtk_paint_slider(style, gdkDrawable, gtkState, gtkShadow, NULL, + GTTK_ENSURE_WIDGET_OK; + GTTK_DRAWABLE_FROM_WIDGET; + GTTK_STYLE_BACKGROUND_DEFAULT; + GTTK_DEFAULT_BACKGROUND; + GTTK_STYLE_FROM_WIDGET; + GTTK_WIDGET_SET_FOCUS(widget); + adj = gttk_gtk_range_get_adjustment((GtkRange *) widget); + gttk_gtk_adjustment_set_value(adj, + gttk_ValueFromSlider(wc, tkwin, b)); + gttk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, + GTTK_SECTION_SCROLLBAR|GTTK_SECTION_ALL); + // gttk_StateInfo(state, gtkState, gtkShadow, tkwin, widget); + gttk_gtk_paint_slider(style, gdkDrawable, gtkState, gtkShadow, NULL, widget, (wc->orientation == TTK_ORIENT_HORIZONTAL) ? "hscale" : "vscale", 0, 0, b.width, b.height, wc->gtkOrientation); - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height, b.x, b.y); - GTKTTK_CLEANUP_GTK_DRAWABLE; + GTTK_CLEANUP_GTK_DRAWABLE; } static Ttk_ElementSpec ScaleSliderElementSpec = { @@ -188,8 +188,8 @@ TTK_BEGIN_LAYOUT(HorizontalScaleLayout) TTK_NODE("Horizontal.Scale.slider", TTK_PACK_LEFT) ) TTK_END_LAYOUT -int GtkTtk_Init_Scale(Tcl_Interp *interp, - GtkTtk_WidgetCache **wc, Ttk_Theme themePtr) +int gttk_Init_Scale(Tcl_Interp *interp, + gttk_WidgetCache **wc, Ttk_Theme themePtr) { /* * Register elements: @@ -212,4 +212,4 @@ int GtkTtk_Init_Scale(Tcl_Interp *interp, "Vertical.TScale", VerticalScaleLayout); return TCL_OK; -}; /* GtkTtk_Init_Scale */ +}; /* gttk_Init_Scale */ diff --git a/generic/gtkTtk_Scrollbar.cpp b/generic/gttk_Scrollbar.cpp similarity index 70% rename from generic/gtkTtk_Scrollbar.cpp rename to generic/gttk_Scrollbar.cpp index 18298fe..34fd7a6 100644 --- a/generic/gtkTtk_Scrollbar.cpp +++ b/generic/gttk_Scrollbar.cpp @@ -1,8 +1,8 @@ /* - * gtkTtk_Scrollbar.cpp + * gttk_Scrollbar.cpp * ------------------------ * - * This file is part of the gtkTtk package, a Tk/Tile based theme that uses + * This file is part of the gttk package, a Tk/Tile based theme that uses * Gtk/GNOME for drawing. * * Copyright (C) 2004-2008 by: @@ -13,9 +13,9 @@ * Aghia Paraskevi, 153 10, Athens, Greece. */ -#include "gtkTtk_Utilities.h" -#include "gtkTtk_TkHeaders.h" -#include "gtkTtk_WidgetDefaults.h" +#include "gttk_Utilities.h" +#include "gttk_TkHeaders.h" +#include "gttk_WidgetDefaults.h" #if 0 /* @@ -37,13 +37,13 @@ static void ScrollbarTroughElementGeometry( void *clientData, void *elementRecord, Tk_Window tkwin, int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr) { - GTKTTK_WIDGET_CACHE_DEFINITION; + GTTK_WIDGET_CACHE_DEFINITION; gint trough_border = 0; int xt = 0, yt = 0; - GtkWidget *widget = GtkTtk_GetScrollBar(wc); - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - GTKTTK_ENSURE_WIDGET_OK; - GtkTtk_gtk_widget_style_get(widget, "trough-border", &trough_border, NULL); + GtkWidget *widget = gttk_GetScrollBar(wc); + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GTTK_ENSURE_WIDGET_OK; + gttk_gtk_widget_style_get(widget, "trough-border", &trough_border, NULL); // xt = widget->style->xthickness; // yt = widget->style->ythickness; *paddingPtr = Ttk_MakePadding(xt + trough_border, @@ -56,43 +56,43 @@ static void ScrollbarTroughElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned state) { - GTKTTK_GTK_DRAWABLE_DEFINITIONS; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - GTKTTK_SETUP_GTK_DRAWABLE; - GtkWidget *widget = GtkTtk_GetScrollBar(wc); + GTTK_GTK_DRAWABLE_DEFINITIONS; + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GTTK_SETUP_GTK_DRAWABLE; + GtkWidget *widget = gttk_GetScrollBar(wc); gboolean trough_side_details = FALSE; - GTKTTK_ENSURE_WIDGET_OK; - GTKTTK_STYLE_FROM_WIDGET; - GtkTtk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, - GTKTTK_SECTION_TROUGH|GTKTTK_SECTION_ALL); - //GTKTTK_SETUP_WIDGET_SIZE(b.width, b.height); - GTKTTK_WIDGET_SET_FOCUS(widget); - GtkTtk_gtk_widget_style_get(widget, "trough-side-details", + GTTK_ENSURE_WIDGET_OK; + GTTK_STYLE_FROM_WIDGET; + gttk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, + GTTK_SECTION_TROUGH|GTTK_SECTION_ALL); + //GTTK_SETUP_WIDGET_SIZE(b.width, b.height); + GTTK_WIDGET_SET_FOCUS(widget); + gttk_gtk_widget_style_get(widget, "trough-side-details", &trough_side_details, NULL); - GTKTTK_DEFAULT_BACKGROUND; - // GtkTtk_StateInfo(state, gtkState, gtkShadow, tkwin, widget); + GTTK_DEFAULT_BACKGROUND; + // gttk_StateInfo(state, gtkState, gtkShadow, tkwin, widget); if (trough_side_details) { int trough_change_pos_x = b.width, trough_change_pos_y = b.height; if (wc->gtkOrientation == GTK_ORIENTATION_HORIZONTAL) trough_change_pos_x = b.width / 2; else trough_change_pos_y = b.height / 2; - GtkTtk_gtk_paint_box(style, gdkDrawable, gtkState, GTK_SHADOW_IN, NULL, widget, + gttk_gtk_paint_box(style, gdkDrawable, gtkState, GTK_SHADOW_IN, NULL, widget, "trough-upper", 0, 0, trough_change_pos_x, trough_change_pos_y); if (wc->gtkOrientation == GTK_ORIENTATION_HORIZONTAL) trough_change_pos_y = 0; else trough_change_pos_x = 0; - GtkTtk_gtk_paint_box(style, gdkDrawable, gtkState, GTK_SHADOW_IN, NULL, widget, + gttk_gtk_paint_box(style, gdkDrawable, gtkState, GTK_SHADOW_IN, NULL, widget, "trough-lower", trough_change_pos_x, trough_change_pos_y, b.width-trough_change_pos_x, b.height-trough_change_pos_y); } else { - GtkTtk_gtk_paint_box(style, gdkDrawable, gtkState, GTK_SHADOW_IN, NULL, widget, + gttk_gtk_paint_box(style, gdkDrawable, gtkState, GTK_SHADOW_IN, NULL, widget, "trough", 0, 0, b.width, b.height); } - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height, b.x, b.y); - GTKTTK_CLEANUP_GTK_DRAWABLE; + GTTK_CLEANUP_GTK_DRAWABLE; } static Ttk_ElementSpec ScrollbarTroughElementSpec = { @@ -114,12 +114,12 @@ static void ScrollbarThumbElementGeometry( void *clientData, void *elementRecord, Tk_Window tkwin, int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr) { - GTKTTK_WIDGET_CACHE_DEFINITION; + GTTK_WIDGET_CACHE_DEFINITION; gint slider_width = 0, slider_min = ScrollbarThumbMinimumLen; - GtkWidget *widget = GtkTtk_GetScrollBar(wc); - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - GTKTTK_ENSURE_WIDGET_OK; - GtkTtk_gtk_widget_style_get(widget, "slider-width", &slider_width, + GtkWidget *widget = gttk_GetScrollBar(wc); + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GTTK_ENSURE_WIDGET_OK; + gttk_gtk_widget_style_get(widget, "slider-width", &slider_width, "min-slider-length", &slider_min, NULL); *heightPtr = *widthPtr = slider_min; if (wc->orientation == TTK_ORIENT_HORIZONTAL) { @@ -136,30 +136,30 @@ static void ScrollbarThumbElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned state) { - GTKTTK_GTK_DRAWABLE_DEFINITIONS; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - GTKTTK_SETUP_GTK_DRAWABLE; - GtkWidget *widget = GtkTtk_GetScrollBar(wc); + GTTK_GTK_DRAWABLE_DEFINITIONS; + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GTTK_SETUP_GTK_DRAWABLE; + GtkWidget *widget = gttk_GetScrollBar(wc); GtkAdjustment *adj = NULL; - GTKTTK_ENSURE_WIDGET_OK; - GTKTTK_STYLE_FROM_WIDGET; - // GTKTTK_SETUP_WIDGET_SIZE(b.width, b.height); - GTKTTK_WIDGET_SET_FOCUS(widget); - adj = GtkTtk_gtk_range_get_adjustment((GtkRange *) widget); - GtkTtk_gtk_adjustment_set_value(adj,GtkTtk_ValueFromSlider(wc, tkwin, b)); - // GTKTTK_DEFAULT_BACKGROUND; - GtkTtk_gtk_paint_box(style, gdkDrawable, gtkState, GTK_SHADOW_IN, NULL, widget, + GTTK_ENSURE_WIDGET_OK; + GTTK_STYLE_FROM_WIDGET; + // GTTK_SETUP_WIDGET_SIZE(b.width, b.height); + GTTK_WIDGET_SET_FOCUS(widget); + adj = gttk_gtk_range_get_adjustment((GtkRange *) widget); + gttk_gtk_adjustment_set_value(adj,gttk_ValueFromSlider(wc, tkwin, b)); + // GTTK_DEFAULT_BACKGROUND; + gttk_gtk_paint_box(style, gdkDrawable, gtkState, GTK_SHADOW_IN, NULL, widget, "trough", 0, 0, b.width, b.height); - GtkTtk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, - GTKTTK_SECTION_SCROLLBAR|GTKTTK_SECTION_ALL); - // GtkTtk_StateInfo(state, gtkState, gtkShadow, tkwin, widget); - GtkTtk_gtk_paint_slider(style, gdkDrawable, gtkState, gtkShadow, NULL, widget, + gttk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, + GTTK_SECTION_SCROLLBAR|GTTK_SECTION_ALL); + // gttk_StateInfo(state, gtkState, gtkShadow, tkwin, widget); + gttk_gtk_paint_slider(style, gdkDrawable, gtkState, gtkShadow, NULL, widget, "slider", 0, 0, b.width, b.height, wc->gtkOrientation); - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height, b.x, b.y); - GTKTTK_CLEANUP_GTK_DRAWABLE; + GTTK_CLEANUP_GTK_DRAWABLE; } static Ttk_ElementSpec ScrollbarThumbElementSpec = { @@ -181,13 +181,13 @@ static void ScrollbarUpArrowElementGeometry( void *clientData, void *elementRecord, Tk_Window tkwin, int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr) { - GTKTTK_WIDGET_CACHE_DEFINITION; + GTTK_WIDGET_CACHE_DEFINITION; gint stepper_size = 0, slider_width = 0; - GtkWidget *widget = GtkTtk_GetScrollBar(wc); + GtkWidget *widget = gttk_GetScrollBar(wc); int xt = 0, yt = 0, trough_border = 0; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - GTKTTK_ENSURE_WIDGET_OK; - GtkTtk_gtk_widget_style_get(widget, "stepper-size", &stepper_size, + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GTTK_ENSURE_WIDGET_OK; + gttk_gtk_widget_style_get(widget, "stepper-size", &stepper_size, "slider-width", &slider_width, NULL); if (wc->orientation == TTK_ORIENT_HORIZONTAL) { *widthPtr = stepper_size; @@ -208,42 +208,42 @@ static void ScrollbarUpArrowElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned state) { - GTKTTK_GTK_DRAWABLE_DEFINITIONS; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - GTKTTK_SETUP_GTK_DRAWABLE; - GtkWidget *widget = GtkTtk_GetScrollBar(wc); + GTTK_GTK_DRAWABLE_DEFINITIONS; + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GTTK_SETUP_GTK_DRAWABLE; + GtkWidget *widget = gttk_GetScrollBar(wc); int horizontal = wc->orientation == TTK_ORIENT_HORIZONTAL; gfloat arrow_scaling; gint arrow_x; gint arrow_y; gint arrow_width; gint arrow_height; - GTKTTK_ENSURE_WIDGET_OK; - GTKTTK_STYLE_FROM_WIDGET; - GtkTtk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, - GTKTTK_SECTION_STEPPERS|GTKTTK_SECTION_ALL); - // GTKTTK_SETUP_WIDGET_SIZE(b.width, b.height); - GTKTTK_WIDGET_SET_FOCUS(widget); - // GTKTTK_DEFAULT_BACKGROUND; - // GtkTtk_StateInfo(state, gtkState, gtkShadow, tkwin, widget); - GtkTtk_gtk_paint_box(style, gdkDrawable, gtkState, GTK_SHADOW_IN, NULL, + GTTK_ENSURE_WIDGET_OK; + GTTK_STYLE_FROM_WIDGET; + gttk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, + GTTK_SECTION_STEPPERS|GTTK_SECTION_ALL); + // GTTK_SETUP_WIDGET_SIZE(b.width, b.height); + GTTK_WIDGET_SET_FOCUS(widget); + // GTTK_DEFAULT_BACKGROUND; + // gttk_StateInfo(state, gtkState, gtkShadow, tkwin, widget); + gttk_gtk_paint_box(style, gdkDrawable, gtkState, GTK_SHADOW_IN, NULL, widget, horizontal ? "hscrollbar":"vscrollbar", 0, 0, b.width, b.height); /* Draw the arrow, according to the desired scaling! */ - GtkTtk_gtk_widget_style_get(widget, "arrow-scaling", &arrow_scaling, NULL); + gttk_gtk_widget_style_get(widget, "arrow-scaling", &arrow_scaling, NULL); if (arrow_scaling == 0.0) arrow_scaling = 1.0; arrow_width = b.width * arrow_scaling; arrow_height = b.height * arrow_scaling; arrow_x = (b.width - arrow_width) / 2; arrow_y = (b.height - arrow_height) / 2; - GtkTtk_gtk_paint_arrow(style, gdkDrawable, gtkState, gtkShadow, NULL, + gttk_gtk_paint_arrow(style, gdkDrawable, gtkState, gtkShadow, NULL, widget, horizontal ? "hscrollbar":"vscrollbar", horizontal? GTK_ARROW_LEFT : GTK_ARROW_UP, FALSE, arrow_x, arrow_y, arrow_width, arrow_height); - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height, b.x, b.y); - GTKTTK_CLEANUP_GTK_DRAWABLE; + GTTK_CLEANUP_GTK_DRAWABLE; } static Ttk_ElementSpec ScrollbarUpArrowElementSpec = { @@ -273,42 +273,42 @@ static void ScrollbarDownArrowElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned state) { - GTKTTK_GTK_DRAWABLE_DEFINITIONS; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - GTKTTK_SETUP_GTK_DRAWABLE; - GtkWidget *widget = GtkTtk_GetScrollBar(wc); + GTTK_GTK_DRAWABLE_DEFINITIONS; + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GTTK_SETUP_GTK_DRAWABLE; + GtkWidget *widget = gttk_GetScrollBar(wc); int horizontal = wc->orientation == TTK_ORIENT_HORIZONTAL; - GTKTTK_ENSURE_WIDGET_OK; + GTTK_ENSURE_WIDGET_OK; gfloat arrow_scaling; gint arrow_x; gint arrow_y; gint arrow_width; gint arrow_height; - GTKTTK_STYLE_FROM_WIDGET; - GtkTtk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, - GTKTTK_SECTION_STEPPERS|GTKTTK_SECTION_ALL); - // GTKTTK_SETUP_WIDGET_SIZE(b.width, b.height); - GTKTTK_WIDGET_SET_FOCUS(widget); - // GTKTTK_DEFAULT_BACKGROUND; - // GtkTtk_StateInfo(state, gtkState, gtkShadow, tkwin, widget); - GtkTtk_gtk_paint_box(style, gdkDrawable, gtkState, GTK_SHADOW_IN, NULL, + GTTK_STYLE_FROM_WIDGET; + gttk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, + GTTK_SECTION_STEPPERS|GTTK_SECTION_ALL); + // GTTK_SETUP_WIDGET_SIZE(b.width, b.height); + GTTK_WIDGET_SET_FOCUS(widget); + // GTTK_DEFAULT_BACKGROUND; + // gttk_StateInfo(state, gtkState, gtkShadow, tkwin, widget); + gttk_gtk_paint_box(style, gdkDrawable, gtkState, GTK_SHADOW_IN, NULL, widget, horizontal ? "hscrollbar":"vscrollbar", 0, 0, b.width, b.height); /* Draw the arrow, according to the desired scaling! */ - GtkTtk_gtk_widget_style_get(widget, "arrow-scaling", &arrow_scaling, NULL); + gttk_gtk_widget_style_get(widget, "arrow-scaling", &arrow_scaling, NULL); if (arrow_scaling == 0.0) arrow_scaling = 1.0; arrow_width = b.width * arrow_scaling; arrow_height = b.height * arrow_scaling; arrow_x = (b.width - arrow_width) / 2; arrow_y = (b.height - arrow_height) / 2; - GtkTtk_gtk_paint_arrow(style, gdkDrawable, gtkState, gtkShadow, NULL, + gttk_gtk_paint_arrow(style, gdkDrawable, gtkState, gtkShadow, NULL, widget, horizontal ? "hscrollbar":"vscrollbar", horizontal? GTK_ARROW_RIGHT : GTK_ARROW_DOWN, TRUE, arrow_x, arrow_y, arrow_width, arrow_height); - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height, b.x, b.y); - GTKTTK_CLEANUP_GTK_DRAWABLE; + GTTK_CLEANUP_GTK_DRAWABLE; } static Ttk_ElementSpec ScrollbarDownArrowElementSpec = { @@ -374,8 +374,8 @@ static Ttk_ElementSpec ScrollbarDownSubArrowElementSpec = { // TTK_NODE("Vertical.Scrollbar.thumb", TTK_FILL_BOTH)) // TTK_END_LAYOUT -int GtkTtk_Init_Scrollbar(Tcl_Interp *interp, - GtkTtk_WidgetCache **wc, Ttk_Theme themePtr) +int gttk_Init_Scrollbar(Tcl_Interp *interp, + gttk_WidgetCache **wc, Ttk_Theme themePtr) { /* * Register elements: @@ -416,4 +416,4 @@ int GtkTtk_Init_Scrollbar(Tcl_Interp *interp, // HorizontalScrollbarLayout); return TCL_OK; -}; /* GtkTtk_Init_Scrollbar */ +}; /* gttk_Init_Scrollbar */ diff --git a/generic/gtkTtk_Separator.cpp b/generic/gttk_Separator.cpp similarity index 74% rename from generic/gtkTtk_Separator.cpp rename to generic/gttk_Separator.cpp index 9bb0732..9068b13 100644 --- a/generic/gtkTtk_Separator.cpp +++ b/generic/gttk_Separator.cpp @@ -1,8 +1,8 @@ /* - * gtkTtk_Separator.cpp + * gttk_Separator.cpp * --------------------- * - * This file is part of the gtkTtk package, a Tk/Tile based theme that uses + * This file is part of the gttk package, a Tk/Tile based theme that uses * Gtk/GNOME for drawing. * * Copyright (C) 2004-2008 by: @@ -13,23 +13,23 @@ * Aghia Paraskevi, 153 10, Athens, Greece. */ -#include "gtkTtk_Utilities.h" -#include "gtkTtk_TkHeaders.h" -#include "gtkTtk_WidgetDefaults.h" +#include "gttk_Utilities.h" +#include "gttk_TkHeaders.h" +#include "gttk_WidgetDefaults.h" /* * Map between Tk/Tile & Gtk/GNOME state flags. */ static Ttk_StateTable separator_statemap[] = { -#ifdef GTKTTK_GTK_VERSION_3 +#ifdef GTTK_GTK_VERSION_3 {QStyle::Style_Default, TTK_STATE_DISABLED, 0}, {QStyle::Style_Enabled, 0, 0} -#endif /* GTKTTK_GTK_VERSION_3 */ -#ifdef GTKTTK_GTK_VERSION_4 +#endif /* GTTK_GTK_VERSION_3 */ +#ifdef GTTK_GTK_VERSION_4 {QStyle::State_None, TTK_STATE_DISABLED, 0}, {QStyle::State_Enabled, 0, 0} -#endif /* GTKTTK_GTK_VERSION_4 */ +#endif /* GTTK_GTK_VERSION_4 */ }; typedef struct { @@ -50,12 +50,12 @@ static void SeparatorElementGeometry( void *clientData, void *elementRecord, Tk_Window tkwin, int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr) { - if (!GtkTtk_GtkInitialised()) NO_GTK_STYLE_ENGINE; - NULL_PROXY_ORIENTED_WIDGET(GtkTtk_QWidget_Widget); + if (!gttk_GtkInitialised()) NO_GTK_STYLE_ENGINE; + NULL_PROXY_ORIENTED_WIDGET(gttk_QWidget_Widget); if (orient == TTK_ORIENT_HORIZONTAL) { - *heightPtr = PMW(PM_DefaultFrameWidth, wc->GtkTtk_QWidget_Widget); + *heightPtr = PMW(PM_DefaultFrameWidth, wc->gttk_QWidget_Widget); } else { - *widthPtr = PMW(PM_DefaultFrameWidth, wc->GtkTtk_QWidget_Widget); + *widthPtr = PMW(PM_DefaultFrameWidth, wc->gttk_QWidget_Widget); } *paddingPtr = Ttk_UniformPadding(0); } @@ -64,37 +64,37 @@ static void SeparatorElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned state) { - if (!GtkTtk_GtkInitialised()) NO_GTK_STYLE_ENGINE; - NULL_PROXY_ORIENTED_WIDGET(GtkTtk_QWidget_Widget); - Tcl_MutexLock(>kTtkMutex); + if (!gttk_GtkInitialised()) NO_GTK_STYLE_ENGINE; + NULL_PROXY_ORIENTED_WIDGET(gttk_QWidget_Widget); + Tcl_MutexLock(>tkMutex); QPixmap pixmap(b.width, b.height); QPainter painter(&pixmap); - GTKTTK_PAINT_BACKGROUND(b.width, b.height); -#ifdef GTKTTK_GTK_VERSION_3 - QStyle::SFlags sflags = GtkTtk_StateTableLookup(separator_statemap, state); + GTTK_PAINT_BACKGROUND(b.width, b.height); +#ifdef GTTK_GTK_VERSION_3 + QStyle::SFlags sflags = gttk_StateTableLookup(separator_statemap, state); if (orient == TTK_ORIENT_HORIZONTAL) { sflags |= QStyle::Style_Horizontal; } - wc->GtkTtk_Style->drawPrimitive(QStyle::PE_Separator, &painter, + wc->gttk_Style->drawPrimitive(QStyle::PE_Separator, &painter, QRect(0, 0, b.width, b.height), qApp->palette().active(), sflags); -#endif /* GTKTTK_GTK_VERSION_3 */ -#ifdef GTKTTK_GTK_VERSION_4 +#endif /* GTTK_GTK_VERSION_3 */ +#ifdef GTTK_GTK_VERSION_4 QStyleOption option; option.state |= - (QStyle::StateFlag) GtkTtk_StateTableLookup(separator_statemap, state); - wc->GtkTtk_Style->drawPrimitive(QStyle::PE_Q3Separator, &option, + (QStyle::StateFlag) gttk_StateTableLookup(separator_statemap, state); + wc->gttk_Style->drawPrimitive(QStyle::PE_Q3Separator, &option, &painter); -#endif /* GTKTTK_GTK_VERSION_4 */ - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, +#endif /* GTTK_GTK_VERSION_4 */ + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height, b.x, b.y); - Tcl_MutexUnlock(>kTtkMutex); + Tcl_MutexUnlock(>tkMutex); }; /* SeparatorElementDraw */ static void GeneralSeparatorElementGeometry( void *clientData, void *elementRecord, Tk_Window tkwin, int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr) { - GtkTtk_WidgetCache **wc = (GtkTtk_WidgetCache **) clientData; + gttk_WidgetCache **wc = (gttk_WidgetCache **) clientData; if (wc == NULL) return; SeparatorElement *separator = (SeparatorElement *) elementRecord; int orient; @@ -115,7 +115,7 @@ static void GeneralSeparatorElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned state) { - GtkTtk_WidgetCache **wc = (GtkTtk_WidgetCache **) clientData; + gttk_WidgetCache **wc = (gttk_WidgetCache **) clientData; if (wc == NULL) return; SeparatorElement *separator = (SeparatorElement *) elementRecord; int orient; @@ -156,8 +156,8 @@ TTK_BEGIN_LAYOUT(SeparatorLayout) TTK_NODE("Separator.separator", TTK_FILL_BOTH) TTK_END_LAYOUT -int GtkTtk_Init_Separator(Tcl_Interp *interp, - GtkTtk_WidgetCache **wc, Ttk_Theme themePtr) +int gttk_Init_Separator(Tcl_Interp *interp, + gttk_WidgetCache **wc, Ttk_Theme themePtr) { /* * Register elements: @@ -175,4 +175,4 @@ int GtkTtk_Init_Separator(Tcl_Interp *interp, Ttk_RegisterLayout(themePtr, "TSeparator", SeparatorLayout); return TCL_OK; -}; /* GtkTtk_Init_Separator */ +}; /* gttk_Init_Separator */ diff --git a/generic/gtkTtk_SizeGrip.cpp b/generic/gttk_SizeGrip.cpp similarity index 64% rename from generic/gtkTtk_SizeGrip.cpp rename to generic/gttk_SizeGrip.cpp index 788ab2c..d1af049 100644 --- a/generic/gtkTtk_SizeGrip.cpp +++ b/generic/gttk_SizeGrip.cpp @@ -1,8 +1,8 @@ /* - * gtkTtk_SizeGrip.cpp + * gttk_SizeGrip.cpp * --------------------- * - * This file is part of the gtkTtk package, a Tk/Tile based theme that uses + * This file is part of the gttk package, a Tk/Tile based theme that uses * Gtk/GNOME for drawing. * * Copyright (C) 2004-2008 by: @@ -13,9 +13,9 @@ * Aghia Paraskevi, 153 10, Athens, Greece. */ -#include "gtkTtk_Utilities.h" -#include "gtkTtk_TkHeaders.h" -#include "gtkTtk_WidgetDefaults.h" +#include "gttk_Utilities.h" +#include "gttk_TkHeaders.h" +#include "gttk_WidgetDefaults.h" #if 0 /* @@ -37,12 +37,12 @@ static void SizeGripElementGeometry( void *clientData, void *elementRecord, Tk_Window tkwin, int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr) { - GTKTTK_WIDGET_CACHE_DEFINITION; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - GtkWidget *widget = GtkTtk_GetStatusBar(wc); + GTTK_WIDGET_CACHE_DEFINITION; + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GtkWidget *widget = gttk_GetStatusBar(wc); *widthPtr = 18; *heightPtr = 18; - GTKTTK_ENSURE_WIDGET_OK; + GTTK_ENSURE_WIDGET_OK; *paddingPtr = Ttk_MakePadding(0, 0, widget->style->xthickness, widget->style->ythickness); } @@ -51,22 +51,22 @@ static void SizeGripElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned state) { - GTKTTK_GTK_DRAWABLE_DEFINITIONS; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - /* GTKTTK_SETUP_GTK_DRAWABLE; */ + GTTK_GTK_DRAWABLE_DEFINITIONS; + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + /* GTTK_SETUP_GTK_DRAWABLE; */ GtkWidget *widget = wc->gtkWindow; - GTKTTK_ENSURE_WIDGET_OK; - GTKTTK_STYLE_FROM_WIDGET; - GTKTTK_DRAWABLE_FROM_WIDGET; - // GtkTtk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, - // GTKTTK_SECTION_ALL); - GTKTTK_DEFAULT_BACKGROUND; - // GtkTtk_StateInfo(state, gtkState, gtkShadow, tkwin, widget); - GtkTtk_gtk_paint_resize_grip(style, gdkDrawable, GTK_STATE_NORMAL, NULL, widget, + GTTK_ENSURE_WIDGET_OK; + GTTK_STYLE_FROM_WIDGET; + GTTK_DRAWABLE_FROM_WIDGET; + // gttk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, + // GTTK_SECTION_ALL); + GTTK_DEFAULT_BACKGROUND; + // gttk_StateInfo(state, gtkState, gtkShadow, tkwin, widget); + gttk_gtk_paint_resize_grip(style, gdkDrawable, GTK_STATE_NORMAL, NULL, widget, "window", GDK_WINDOW_EDGE_SOUTH_EAST, 0, 0, b.width, b.height); - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height, b.x, b.y); - GTKTTK_CLEANUP_GTK_DRAWABLE; + GTTK_CLEANUP_GTK_DRAWABLE; }; /* SizeGripElementDraw */ static Ttk_ElementSpec SizeGripElementSpec = { @@ -85,8 +85,8 @@ TTK_BEGIN_LAYOUT(SizegripLayout) TTK_NODE("Sizegrip.sizegrip", TTK_PACK_BOTTOM|TTK_STICK_S|TTK_STICK_E) TTK_END_LAYOUT -int GtkTtk_Init_SizeGrip(Tcl_Interp *interp, - GtkTtk_WidgetCache **wc, Ttk_Theme themePtr) +int gttk_Init_SizeGrip(Tcl_Interp *interp, + gttk_WidgetCache **wc, Ttk_Theme themePtr) { /* * Register elements: @@ -100,4 +100,4 @@ int GtkTtk_Init_SizeGrip(Tcl_Interp *interp, Ttk_RegisterLayout(themePtr, "TSizegrip", SizegripLayout); return TCL_OK; -}; /* GtkTtk_Init_SizeGrip */ +}; /* gttk_Init_SizeGrip */ diff --git a/generic/gttk_Symbols.cpp b/generic/gttk_Symbols.cpp new file mode 100644 index 0000000..6ffd4ab --- /dev/null +++ b/generic/gttk_Symbols.cpp @@ -0,0 +1,804 @@ +/* + * gttk_Symbols.cpp + * ------------------------ + * + * This file is part of the gttk package, a ttk based theme that uses + * Gtk/GNOME for drawing. + * + * Copyright (C) 2004-2012 by: + * Georgios Petasis, petasis@iit.demokritos.gr, + * Software and Knowledge Engineering Laboratory, + * Institute of Informatics and Telecommunications, + * National Centre for Scientific Research (NCSR) "Demokritos", + * Aghia Paraskevi, 153 10, Athens, Greece. + */ +/* THIS FILE IS AUTOMATICALLY GENERATED - DO NOT EDIT! */ +#include "gttk_Symbols.h" +#ifdef GTTK_LOAD_GTK_DYNAMICALLY +#if (TCL_MAJOR_VERSION >= 8) && (TCL_MINOR_VERSION >= 6) +#define LOAD_SYMBOLS_WITH_TCL +#endif + +#ifndef LOAD_SYMBOLS_WITH_TCL +#include +#endif + +Ptr_g_free gttk_g_free = 0; +Ptr_g_hash_table_get_keys gttk_g_hash_table_get_keys = 0; +Ptr_g_malloc gttk_g_malloc = 0; +Ptr_g_malloc0 gttk_g_malloc0 = 0; +Ptr_g_object_get gttk_g_object_get = 0; +Ptr_g_object_unref gttk_g_object_unref = 0; +Ptr_g_option_context_add_main_entries gttk_g_option_context_add_main_entries = 0; +Ptr_g_option_context_new gttk_g_option_context_new = 0; +Ptr_g_strfreev gttk_g_strfreev = 0; +Ptr_gdk_color_to_string gttk_gdk_color_to_string = 0; +Ptr_gdk_display_get_default gttk_gdk_display_get_default = 0; +Ptr_gdk_display_get_screen gttk_gdk_display_get_screen = 0; +Ptr_gdk_drawable_set_colormap gttk_gdk_drawable_set_colormap = 0; +Ptr_gdk_gc_new gttk_gdk_gc_new = 0; +Ptr_gdk_pixbuf_get_from_drawable gttk_gdk_pixbuf_get_from_drawable = 0; +Ptr_gdk_pixbuf_new gttk_gdk_pixbuf_new = 0; +Ptr_gdk_pixbuf_unref gttk_gdk_pixbuf_unref = 0; +Ptr_gdk_pixbuf_xlib_render_to_drawable gttk_gdk_pixbuf_xlib_render_to_drawable = 0; +Ptr_gdk_pixmap_foreign_new_for_screen gttk_gdk_pixmap_foreign_new_for_screen = 0; +Ptr_gdk_pixmap_new gttk_gdk_pixmap_new = 0; +Ptr_gdk_x11_colormap_foreign_new gttk_gdk_x11_colormap_foreign_new = 0; +Ptr_gdk_x11_lookup_xdisplay gttk_gdk_x11_lookup_xdisplay = 0; +Ptr_gdk_x11_screen_lookup_visual gttk_gdk_x11_screen_lookup_visual = 0; +Ptr_gtk_adjustment_new gttk_gtk_adjustment_new = 0; +Ptr_gtk_adjustment_set_value gttk_gtk_adjustment_set_value = 0; +Ptr_gtk_arrow_new gttk_gtk_arrow_new = 0; +Ptr_gtk_border_free gttk_gtk_border_free = 0; +Ptr_gtk_button_get_relief gttk_gtk_button_get_relief = 0; +Ptr_gtk_button_new gttk_gtk_button_new = 0; +Ptr_gtk_button_set_relief gttk_gtk_button_set_relief = 0; +Ptr_gtk_check_button_new gttk_gtk_check_button_new = 0; +Ptr_gtk_combo_box_entry_new gttk_gtk_combo_box_entry_new = 0; +Ptr_gtk_combo_box_new gttk_gtk_combo_box_new = 0; +Ptr_gtk_container_add gttk_gtk_container_add = 0; +Ptr_gtk_disable_setlocale gttk_gtk_disable_setlocale = 0; +Ptr_gtk_entry_new gttk_gtk_entry_new = 0; +Ptr_gtk_fixed_new gttk_gtk_fixed_new = 0; +Ptr_gtk_frame_new gttk_gtk_frame_new = 0; +Ptr_gtk_hpaned_new gttk_gtk_hpaned_new = 0; +Ptr_gtk_hscale_new_with_range gttk_gtk_hscale_new_with_range = 0; +Ptr_gtk_hscrollbar_new gttk_gtk_hscrollbar_new = 0; +Ptr_gtk_init_check gttk_gtk_init_check = 0; +Ptr_gtk_notebook_new gttk_gtk_notebook_new = 0; +Ptr_gtk_object_get gttk_gtk_object_get = 0; +Ptr_gtk_paint_arrow gttk_gtk_paint_arrow = 0; +Ptr_gtk_paint_box gttk_gtk_paint_box = 0; +Ptr_gtk_paint_box_gap gttk_gtk_paint_box_gap = 0; +Ptr_gtk_paint_check gttk_gtk_paint_check = 0; +Ptr_gtk_paint_extension gttk_gtk_paint_extension = 0; +Ptr_gtk_paint_flat_box gttk_gtk_paint_flat_box = 0; +Ptr_gtk_paint_focus gttk_gtk_paint_focus = 0; +Ptr_gtk_paint_handle gttk_gtk_paint_handle = 0; +Ptr_gtk_paint_option gttk_gtk_paint_option = 0; +Ptr_gtk_paint_resize_grip gttk_gtk_paint_resize_grip = 0; +Ptr_gtk_paint_shadow gttk_gtk_paint_shadow = 0; +Ptr_gtk_paint_slider gttk_gtk_paint_slider = 0; +Ptr_gtk_progress_bar_new gttk_gtk_progress_bar_new = 0; +Ptr_gtk_progress_bar_set_bar_style gttk_gtk_progress_bar_set_bar_style = 0; +Ptr_gtk_progress_bar_set_fraction gttk_gtk_progress_bar_set_fraction = 0; +Ptr_gtk_progress_bar_set_orientation gttk_gtk_progress_bar_set_orientation = 0; +Ptr_gtk_range_get_adjustment gttk_gtk_range_get_adjustment = 0; +Ptr_gtk_rc_get_default_files gttk_gtk_rc_get_default_files = 0; +Ptr_gtk_rc_get_style gttk_gtk_rc_get_style = 0; +Ptr_gtk_rc_get_theme_dir gttk_gtk_rc_get_theme_dir = 0; +Ptr_gtk_rc_reparse_all_for_settings gttk_gtk_rc_reparse_all_for_settings = 0; +Ptr_gtk_rc_reset_styles gttk_gtk_rc_reset_styles = 0; +Ptr_gtk_rc_set_default_files gttk_gtk_rc_set_default_files = 0; +Ptr_gtk_settings_get_default gttk_gtk_settings_get_default = 0; +Ptr_gtk_statusbar_new gttk_gtk_statusbar_new = 0; +Ptr_gtk_style_apply_default_background gttk_gtk_style_apply_default_background = 0; +Ptr_gtk_style_attach gttk_gtk_style_attach = 0; +Ptr_gtk_style_lookup_color gttk_gtk_style_lookup_color = 0; +Ptr_gtk_toolbar_new gttk_gtk_toolbar_new = 0; +Ptr_gtk_vpaned_new gttk_gtk_vpaned_new = 0; +Ptr_gtk_vscale_new_with_range gttk_gtk_vscale_new_with_range = 0; +Ptr_gtk_vscrollbar_new gttk_gtk_vscrollbar_new = 0; +Ptr_gtk_widget_destroy gttk_gtk_widget_destroy = 0; +Ptr_gtk_widget_realize gttk_gtk_widget_realize = 0; +Ptr_gtk_widget_set_size_request gttk_gtk_widget_set_size_request = 0; +Ptr_gtk_widget_size_request gttk_gtk_widget_size_request = 0; +Ptr_gtk_widget_style_get gttk_gtk_widget_style_get = 0; +Ptr_gtk_window_new gttk_gtk_window_new = 0; +Ptr_xlib_rgb_init gttk_xlib_rgb_init = 0; + +int gttk_InitialiseSymbols_gdk(Tcl_Interp *interp, Tcl_Obj *file_name) { +#ifdef LOAD_SYMBOLS_WITH_TCL + Tcl_LoadHandle loadHandle; + int status; + status = Tcl_LoadFile(interp, file_name, NULL, 0, NULL, &loadHandle); + if (status != TCL_OK) return status; + gttk_gdk_color_to_string = (Ptr_gdk_color_to_string) Tcl_FindSymbol(interp, loadHandle, "gdk_color_to_string"); + if (gttk_gdk_color_to_string == NULL) return TCL_ERROR; + gttk_gdk_display_get_default = (Ptr_gdk_display_get_default) Tcl_FindSymbol(interp, loadHandle, "gdk_display_get_default"); + if (gttk_gdk_display_get_default == NULL) return TCL_ERROR; + gttk_gdk_display_get_screen = (Ptr_gdk_display_get_screen) Tcl_FindSymbol(interp, loadHandle, "gdk_display_get_screen"); + if (gttk_gdk_display_get_screen == NULL) return TCL_ERROR; + gttk_gdk_drawable_set_colormap = (Ptr_gdk_drawable_set_colormap) Tcl_FindSymbol(interp, loadHandle, "gdk_drawable_set_colormap"); + if (gttk_gdk_drawable_set_colormap == NULL) return TCL_ERROR; + gttk_gdk_gc_new = (Ptr_gdk_gc_new) Tcl_FindSymbol(interp, loadHandle, "gdk_gc_new"); + if (gttk_gdk_gc_new == NULL) return TCL_ERROR; + gttk_gdk_pixbuf_get_from_drawable = (Ptr_gdk_pixbuf_get_from_drawable) Tcl_FindSymbol(interp, loadHandle, "gdk_pixbuf_get_from_drawable"); + if (gttk_gdk_pixbuf_get_from_drawable == NULL) return TCL_ERROR; + gttk_gdk_pixmap_foreign_new_for_screen = (Ptr_gdk_pixmap_foreign_new_for_screen) Tcl_FindSymbol(interp, loadHandle, "gdk_pixmap_foreign_new_for_screen"); + if (gttk_gdk_pixmap_foreign_new_for_screen == NULL) return TCL_ERROR; + gttk_gdk_pixmap_new = (Ptr_gdk_pixmap_new) Tcl_FindSymbol(interp, loadHandle, "gdk_pixmap_new"); + if (gttk_gdk_pixmap_new == NULL) return TCL_ERROR; + gttk_gdk_x11_colormap_foreign_new = (Ptr_gdk_x11_colormap_foreign_new) Tcl_FindSymbol(interp, loadHandle, "gdk_x11_colormap_foreign_new"); + if (gttk_gdk_x11_colormap_foreign_new == NULL) return TCL_ERROR; + gttk_gdk_x11_lookup_xdisplay = (Ptr_gdk_x11_lookup_xdisplay) Tcl_FindSymbol(interp, loadHandle, "gdk_x11_lookup_xdisplay"); + if (gttk_gdk_x11_lookup_xdisplay == NULL) return TCL_ERROR; + gttk_gdk_x11_screen_lookup_visual = (Ptr_gdk_x11_screen_lookup_visual) Tcl_FindSymbol(interp, loadHandle, "gdk_x11_screen_lookup_visual"); + if (gttk_gdk_x11_screen_lookup_visual == NULL) return TCL_ERROR; +#else + const char *fname = Tcl_GetString(file_name); + GModule *m = g_module_open(fname, G_MODULE_BIND_LAZY); + if (!m) { + Tcl_SetResult(interp, (char *) "cannot open module: ", TCL_STATIC); + Tcl_AppendResult(interp, fname, (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gdk_color_to_string", (gpointer *) >tk_gdk_color_to_string)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gdk_color_to_string", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gdk_display_get_default", (gpointer *) >tk_gdk_display_get_default)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gdk_display_get_default", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gdk_display_get_screen", (gpointer *) >tk_gdk_display_get_screen)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gdk_display_get_screen", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gdk_drawable_set_colormap", (gpointer *) >tk_gdk_drawable_set_colormap)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gdk_drawable_set_colormap", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gdk_gc_new", (gpointer *) >tk_gdk_gc_new)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gdk_gc_new", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gdk_pixbuf_get_from_drawable", (gpointer *) >tk_gdk_pixbuf_get_from_drawable)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gdk_pixbuf_get_from_drawable", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gdk_pixmap_foreign_new_for_screen", (gpointer *) >tk_gdk_pixmap_foreign_new_for_screen)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gdk_pixmap_foreign_new_for_screen", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gdk_pixmap_new", (gpointer *) >tk_gdk_pixmap_new)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gdk_pixmap_new", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gdk_x11_colormap_foreign_new", (gpointer *) >tk_gdk_x11_colormap_foreign_new)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gdk_x11_colormap_foreign_new", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gdk_x11_lookup_xdisplay", (gpointer *) >tk_gdk_x11_lookup_xdisplay)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gdk_x11_lookup_xdisplay", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gdk_x11_screen_lookup_visual", (gpointer *) >tk_gdk_x11_screen_lookup_visual)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gdk_x11_screen_lookup_visual", (char *) NULL); + return TCL_ERROR; + } +#endif + return TCL_OK; +}; /* gttk_InitialiseSymbols_gdk */ + + +int gttk_InitialiseSymbols_gdk_pixbuf(Tcl_Interp *interp, Tcl_Obj *file_name) { +#ifdef LOAD_SYMBOLS_WITH_TCL + Tcl_LoadHandle loadHandle; + int status; + status = Tcl_LoadFile(interp, file_name, NULL, 0, NULL, &loadHandle); + if (status != TCL_OK) return status; + gttk_gdk_pixbuf_new = (Ptr_gdk_pixbuf_new) Tcl_FindSymbol(interp, loadHandle, "gdk_pixbuf_new"); + if (gttk_gdk_pixbuf_new == NULL) return TCL_ERROR; + gttk_gdk_pixbuf_unref = (Ptr_gdk_pixbuf_unref) Tcl_FindSymbol(interp, loadHandle, "gdk_pixbuf_unref"); + if (gttk_gdk_pixbuf_unref == NULL) return TCL_ERROR; +#else + const char *fname = Tcl_GetString(file_name); + GModule *m = g_module_open(fname, G_MODULE_BIND_LAZY); + if (!m) { + Tcl_SetResult(interp, (char *) "cannot open module: ", TCL_STATIC); + Tcl_AppendResult(interp, fname, (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gdk_pixbuf_new", (gpointer *) >tk_gdk_pixbuf_new)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gdk_pixbuf_new", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gdk_pixbuf_unref", (gpointer *) >tk_gdk_pixbuf_unref)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gdk_pixbuf_unref", (char *) NULL); + return TCL_ERROR; + } +#endif + return TCL_OK; +}; /* gttk_InitialiseSymbols_gdk_pixbuf */ + + +int gttk_InitialiseSymbols_gdk_pixbuf_xlib(Tcl_Interp *interp, Tcl_Obj *file_name) { +#ifdef LOAD_SYMBOLS_WITH_TCL + Tcl_LoadHandle loadHandle; + int status; + status = Tcl_LoadFile(interp, file_name, NULL, 0, NULL, &loadHandle); + if (status != TCL_OK) return status; + gttk_gdk_pixbuf_xlib_render_to_drawable = (Ptr_gdk_pixbuf_xlib_render_to_drawable) Tcl_FindSymbol(interp, loadHandle, "gdk_pixbuf_xlib_render_to_drawable"); + if (gttk_gdk_pixbuf_xlib_render_to_drawable == NULL) return TCL_ERROR; + gttk_xlib_rgb_init = (Ptr_xlib_rgb_init) Tcl_FindSymbol(interp, loadHandle, "xlib_rgb_init"); + if (gttk_xlib_rgb_init == NULL) return TCL_ERROR; +#else + const char *fname = Tcl_GetString(file_name); + GModule *m = g_module_open(fname, G_MODULE_BIND_LAZY); + if (!m) { + Tcl_SetResult(interp, (char *) "cannot open module: ", TCL_STATIC); + Tcl_AppendResult(interp, fname, (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gdk_pixbuf_xlib_render_to_drawable", (gpointer *) >tk_gdk_pixbuf_xlib_render_to_drawable)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gdk_pixbuf_xlib_render_to_drawable", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "xlib_rgb_init", (gpointer *) >tk_xlib_rgb_init)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "xlib_rgb_init", (char *) NULL); + return TCL_ERROR; + } +#endif + return TCL_OK; +}; /* gttk_InitialiseSymbols_gdk_pixbuf_xlib */ + + +int gttk_InitialiseSymbols_glib(Tcl_Interp *interp, Tcl_Obj *file_name) { +#ifdef LOAD_SYMBOLS_WITH_TCL + Tcl_LoadHandle loadHandle; + int status; + status = Tcl_LoadFile(interp, file_name, NULL, 0, NULL, &loadHandle); + if (status != TCL_OK) return status; + gttk_g_free = (Ptr_g_free) Tcl_FindSymbol(interp, loadHandle, "g_free"); + if (gttk_g_free == NULL) return TCL_ERROR; + gttk_g_hash_table_get_keys = (Ptr_g_hash_table_get_keys) Tcl_FindSymbol(interp, loadHandle, "g_hash_table_get_keys"); + if (gttk_g_hash_table_get_keys == NULL) return TCL_ERROR; + gttk_g_malloc = (Ptr_g_malloc) Tcl_FindSymbol(interp, loadHandle, "g_malloc"); + if (gttk_g_malloc == NULL) return TCL_ERROR; + gttk_g_malloc0 = (Ptr_g_malloc0) Tcl_FindSymbol(interp, loadHandle, "g_malloc0"); + if (gttk_g_malloc0 == NULL) return TCL_ERROR; + gttk_g_option_context_add_main_entries = (Ptr_g_option_context_add_main_entries) Tcl_FindSymbol(interp, loadHandle, "g_option_context_add_main_entries"); + if (gttk_g_option_context_add_main_entries == NULL) return TCL_ERROR; + gttk_g_option_context_new = (Ptr_g_option_context_new) Tcl_FindSymbol(interp, loadHandle, "g_option_context_new"); + if (gttk_g_option_context_new == NULL) return TCL_ERROR; + gttk_g_strfreev = (Ptr_g_strfreev) Tcl_FindSymbol(interp, loadHandle, "g_strfreev"); + if (gttk_g_strfreev == NULL) return TCL_ERROR; +#else + const char *fname = Tcl_GetString(file_name); + GModule *m = g_module_open(fname, G_MODULE_BIND_LAZY); + if (!m) { + Tcl_SetResult(interp, (char *) "cannot open module: ", TCL_STATIC); + Tcl_AppendResult(interp, fname, (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "g_free", (gpointer *) >tk_g_free)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "g_free", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "g_hash_table_get_keys", (gpointer *) >tk_g_hash_table_get_keys)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "g_hash_table_get_keys", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "g_malloc", (gpointer *) >tk_g_malloc)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "g_malloc", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "g_malloc0", (gpointer *) >tk_g_malloc0)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "g_malloc0", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "g_option_context_add_main_entries", (gpointer *) >tk_g_option_context_add_main_entries)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "g_option_context_add_main_entries", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "g_option_context_new", (gpointer *) >tk_g_option_context_new)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "g_option_context_new", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "g_strfreev", (gpointer *) >tk_g_strfreev)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "g_strfreev", (char *) NULL); + return TCL_ERROR; + } +#endif + return TCL_OK; +}; /* gttk_InitialiseSymbols_glib */ + + +int gttk_InitialiseSymbols_gobject(Tcl_Interp *interp, Tcl_Obj *file_name) { +#ifdef LOAD_SYMBOLS_WITH_TCL + Tcl_LoadHandle loadHandle; + int status; + status = Tcl_LoadFile(interp, file_name, NULL, 0, NULL, &loadHandle); + if (status != TCL_OK) return status; + gttk_g_object_get = (Ptr_g_object_get) Tcl_FindSymbol(interp, loadHandle, "g_object_get"); + if (gttk_g_object_get == NULL) return TCL_ERROR; + gttk_g_object_unref = (Ptr_g_object_unref) Tcl_FindSymbol(interp, loadHandle, "g_object_unref"); + if (gttk_g_object_unref == NULL) return TCL_ERROR; +#else + const char *fname = Tcl_GetString(file_name); + GModule *m = g_module_open(fname, G_MODULE_BIND_LAZY); + if (!m) { + Tcl_SetResult(interp, (char *) "cannot open module: ", TCL_STATIC); + Tcl_AppendResult(interp, fname, (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "g_object_get", (gpointer *) >tk_g_object_get)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "g_object_get", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "g_object_unref", (gpointer *) >tk_g_object_unref)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "g_object_unref", (char *) NULL); + return TCL_ERROR; + } +#endif + return TCL_OK; +}; /* gttk_InitialiseSymbols_gobject */ + + +int gttk_InitialiseSymbols_gtk(Tcl_Interp *interp, Tcl_Obj *file_name) { +#ifdef LOAD_SYMBOLS_WITH_TCL + Tcl_LoadHandle loadHandle; + int status; + status = Tcl_LoadFile(interp, file_name, NULL, 0, NULL, &loadHandle); + if (status != TCL_OK) return status; + gttk_gtk_adjustment_new = (Ptr_gtk_adjustment_new) Tcl_FindSymbol(interp, loadHandle, "gtk_adjustment_new"); + if (gttk_gtk_adjustment_new == NULL) return TCL_ERROR; + gttk_gtk_adjustment_set_value = (Ptr_gtk_adjustment_set_value) Tcl_FindSymbol(interp, loadHandle, "gtk_adjustment_set_value"); + if (gttk_gtk_adjustment_set_value == NULL) return TCL_ERROR; + gttk_gtk_arrow_new = (Ptr_gtk_arrow_new) Tcl_FindSymbol(interp, loadHandle, "gtk_arrow_new"); + if (gttk_gtk_arrow_new == NULL) return TCL_ERROR; + gttk_gtk_border_free = (Ptr_gtk_border_free) Tcl_FindSymbol(interp, loadHandle, "gtk_border_free"); + if (gttk_gtk_border_free == NULL) return TCL_ERROR; + gttk_gtk_button_get_relief = (Ptr_gtk_button_get_relief) Tcl_FindSymbol(interp, loadHandle, "gtk_button_get_relief"); + if (gttk_gtk_button_get_relief == NULL) return TCL_ERROR; + gttk_gtk_button_new = (Ptr_gtk_button_new) Tcl_FindSymbol(interp, loadHandle, "gtk_button_new"); + if (gttk_gtk_button_new == NULL) return TCL_ERROR; + gttk_gtk_button_set_relief = (Ptr_gtk_button_set_relief) Tcl_FindSymbol(interp, loadHandle, "gtk_button_set_relief"); + if (gttk_gtk_button_set_relief == NULL) return TCL_ERROR; + gttk_gtk_check_button_new = (Ptr_gtk_check_button_new) Tcl_FindSymbol(interp, loadHandle, "gtk_check_button_new"); + if (gttk_gtk_check_button_new == NULL) return TCL_ERROR; + gttk_gtk_combo_box_entry_new = (Ptr_gtk_combo_box_entry_new) Tcl_FindSymbol(interp, loadHandle, "gtk_combo_box_entry_new"); + if (gttk_gtk_combo_box_entry_new == NULL) return TCL_ERROR; + gttk_gtk_combo_box_new = (Ptr_gtk_combo_box_new) Tcl_FindSymbol(interp, loadHandle, "gtk_combo_box_new"); + if (gttk_gtk_combo_box_new == NULL) return TCL_ERROR; + gttk_gtk_container_add = (Ptr_gtk_container_add) Tcl_FindSymbol(interp, loadHandle, "gtk_container_add"); + if (gttk_gtk_container_add == NULL) return TCL_ERROR; + gttk_gtk_disable_setlocale = (Ptr_gtk_disable_setlocale) Tcl_FindSymbol(interp, loadHandle, "gtk_disable_setlocale"); + if (gttk_gtk_disable_setlocale == NULL) return TCL_ERROR; + gttk_gtk_entry_new = (Ptr_gtk_entry_new) Tcl_FindSymbol(interp, loadHandle, "gtk_entry_new"); + if (gttk_gtk_entry_new == NULL) return TCL_ERROR; + gttk_gtk_fixed_new = (Ptr_gtk_fixed_new) Tcl_FindSymbol(interp, loadHandle, "gtk_fixed_new"); + if (gttk_gtk_fixed_new == NULL) return TCL_ERROR; + gttk_gtk_frame_new = (Ptr_gtk_frame_new) Tcl_FindSymbol(interp, loadHandle, "gtk_frame_new"); + if (gttk_gtk_frame_new == NULL) return TCL_ERROR; + gttk_gtk_hpaned_new = (Ptr_gtk_hpaned_new) Tcl_FindSymbol(interp, loadHandle, "gtk_hpaned_new"); + if (gttk_gtk_hpaned_new == NULL) return TCL_ERROR; + gttk_gtk_hscale_new_with_range = (Ptr_gtk_hscale_new_with_range) Tcl_FindSymbol(interp, loadHandle, "gtk_hscale_new_with_range"); + if (gttk_gtk_hscale_new_with_range == NULL) return TCL_ERROR; + gttk_gtk_hscrollbar_new = (Ptr_gtk_hscrollbar_new) Tcl_FindSymbol(interp, loadHandle, "gtk_hscrollbar_new"); + if (gttk_gtk_hscrollbar_new == NULL) return TCL_ERROR; + gttk_gtk_init_check = (Ptr_gtk_init_check) Tcl_FindSymbol(interp, loadHandle, "gtk_init_check"); + if (gttk_gtk_init_check == NULL) return TCL_ERROR; + gttk_gtk_notebook_new = (Ptr_gtk_notebook_new) Tcl_FindSymbol(interp, loadHandle, "gtk_notebook_new"); + if (gttk_gtk_notebook_new == NULL) return TCL_ERROR; + gttk_gtk_object_get = (Ptr_gtk_object_get) Tcl_FindSymbol(interp, loadHandle, "gtk_object_get"); + if (gttk_gtk_object_get == NULL) return TCL_ERROR; + gttk_gtk_paint_arrow = (Ptr_gtk_paint_arrow) Tcl_FindSymbol(interp, loadHandle, "gtk_paint_arrow"); + if (gttk_gtk_paint_arrow == NULL) return TCL_ERROR; + gttk_gtk_paint_box = (Ptr_gtk_paint_box) Tcl_FindSymbol(interp, loadHandle, "gtk_paint_box"); + if (gttk_gtk_paint_box == NULL) return TCL_ERROR; + gttk_gtk_paint_box_gap = (Ptr_gtk_paint_box_gap) Tcl_FindSymbol(interp, loadHandle, "gtk_paint_box_gap"); + if (gttk_gtk_paint_box_gap == NULL) return TCL_ERROR; + gttk_gtk_paint_check = (Ptr_gtk_paint_check) Tcl_FindSymbol(interp, loadHandle, "gtk_paint_check"); + if (gttk_gtk_paint_check == NULL) return TCL_ERROR; + gttk_gtk_paint_extension = (Ptr_gtk_paint_extension) Tcl_FindSymbol(interp, loadHandle, "gtk_paint_extension"); + if (gttk_gtk_paint_extension == NULL) return TCL_ERROR; + gttk_gtk_paint_flat_box = (Ptr_gtk_paint_flat_box) Tcl_FindSymbol(interp, loadHandle, "gtk_paint_flat_box"); + if (gttk_gtk_paint_flat_box == NULL) return TCL_ERROR; + gttk_gtk_paint_focus = (Ptr_gtk_paint_focus) Tcl_FindSymbol(interp, loadHandle, "gtk_paint_focus"); + if (gttk_gtk_paint_focus == NULL) return TCL_ERROR; + gttk_gtk_paint_handle = (Ptr_gtk_paint_handle) Tcl_FindSymbol(interp, loadHandle, "gtk_paint_handle"); + if (gttk_gtk_paint_handle == NULL) return TCL_ERROR; + gttk_gtk_paint_option = (Ptr_gtk_paint_option) Tcl_FindSymbol(interp, loadHandle, "gtk_paint_option"); + if (gttk_gtk_paint_option == NULL) return TCL_ERROR; + gttk_gtk_paint_resize_grip = (Ptr_gtk_paint_resize_grip) Tcl_FindSymbol(interp, loadHandle, "gtk_paint_resize_grip"); + if (gttk_gtk_paint_resize_grip == NULL) return TCL_ERROR; + gttk_gtk_paint_shadow = (Ptr_gtk_paint_shadow) Tcl_FindSymbol(interp, loadHandle, "gtk_paint_shadow"); + if (gttk_gtk_paint_shadow == NULL) return TCL_ERROR; + gttk_gtk_paint_slider = (Ptr_gtk_paint_slider) Tcl_FindSymbol(interp, loadHandle, "gtk_paint_slider"); + if (gttk_gtk_paint_slider == NULL) return TCL_ERROR; + gttk_gtk_progress_bar_new = (Ptr_gtk_progress_bar_new) Tcl_FindSymbol(interp, loadHandle, "gtk_progress_bar_new"); + if (gttk_gtk_progress_bar_new == NULL) return TCL_ERROR; + gttk_gtk_progress_bar_set_bar_style = (Ptr_gtk_progress_bar_set_bar_style) Tcl_FindSymbol(interp, loadHandle, "gtk_progress_bar_set_bar_style"); + if (gttk_gtk_progress_bar_set_bar_style == NULL) return TCL_ERROR; + gttk_gtk_progress_bar_set_fraction = (Ptr_gtk_progress_bar_set_fraction) Tcl_FindSymbol(interp, loadHandle, "gtk_progress_bar_set_fraction"); + if (gttk_gtk_progress_bar_set_fraction == NULL) return TCL_ERROR; + gttk_gtk_progress_bar_set_orientation = (Ptr_gtk_progress_bar_set_orientation) Tcl_FindSymbol(interp, loadHandle, "gtk_progress_bar_set_orientation"); + if (gttk_gtk_progress_bar_set_orientation == NULL) return TCL_ERROR; + gttk_gtk_range_get_adjustment = (Ptr_gtk_range_get_adjustment) Tcl_FindSymbol(interp, loadHandle, "gtk_range_get_adjustment"); + if (gttk_gtk_range_get_adjustment == NULL) return TCL_ERROR; + gttk_gtk_rc_get_default_files = (Ptr_gtk_rc_get_default_files) Tcl_FindSymbol(interp, loadHandle, "gtk_rc_get_default_files"); + if (gttk_gtk_rc_get_default_files == NULL) return TCL_ERROR; + gttk_gtk_rc_get_style = (Ptr_gtk_rc_get_style) Tcl_FindSymbol(interp, loadHandle, "gtk_rc_get_style"); + if (gttk_gtk_rc_get_style == NULL) return TCL_ERROR; + gttk_gtk_rc_get_theme_dir = (Ptr_gtk_rc_get_theme_dir) Tcl_FindSymbol(interp, loadHandle, "gtk_rc_get_theme_dir"); + if (gttk_gtk_rc_get_theme_dir == NULL) return TCL_ERROR; + gttk_gtk_rc_reparse_all_for_settings = (Ptr_gtk_rc_reparse_all_for_settings) Tcl_FindSymbol(interp, loadHandle, "gtk_rc_reparse_all_for_settings"); + if (gttk_gtk_rc_reparse_all_for_settings == NULL) return TCL_ERROR; + gttk_gtk_rc_reset_styles = (Ptr_gtk_rc_reset_styles) Tcl_FindSymbol(interp, loadHandle, "gtk_rc_reset_styles"); + if (gttk_gtk_rc_reset_styles == NULL) return TCL_ERROR; + gttk_gtk_rc_set_default_files = (Ptr_gtk_rc_set_default_files) Tcl_FindSymbol(interp, loadHandle, "gtk_rc_set_default_files"); + if (gttk_gtk_rc_set_default_files == NULL) return TCL_ERROR; + gttk_gtk_settings_get_default = (Ptr_gtk_settings_get_default) Tcl_FindSymbol(interp, loadHandle, "gtk_settings_get_default"); + if (gttk_gtk_settings_get_default == NULL) return TCL_ERROR; + gttk_gtk_statusbar_new = (Ptr_gtk_statusbar_new) Tcl_FindSymbol(interp, loadHandle, "gtk_statusbar_new"); + if (gttk_gtk_statusbar_new == NULL) return TCL_ERROR; + gttk_gtk_style_apply_default_background = (Ptr_gtk_style_apply_default_background) Tcl_FindSymbol(interp, loadHandle, "gtk_style_apply_default_background"); + if (gttk_gtk_style_apply_default_background == NULL) return TCL_ERROR; + gttk_gtk_style_attach = (Ptr_gtk_style_attach) Tcl_FindSymbol(interp, loadHandle, "gtk_style_attach"); + if (gttk_gtk_style_attach == NULL) return TCL_ERROR; + gttk_gtk_style_lookup_color = (Ptr_gtk_style_lookup_color) Tcl_FindSymbol(interp, loadHandle, "gtk_style_lookup_color"); + if (gttk_gtk_style_lookup_color == NULL) return TCL_ERROR; + gttk_gtk_toolbar_new = (Ptr_gtk_toolbar_new) Tcl_FindSymbol(interp, loadHandle, "gtk_toolbar_new"); + if (gttk_gtk_toolbar_new == NULL) return TCL_ERROR; + gttk_gtk_vpaned_new = (Ptr_gtk_vpaned_new) Tcl_FindSymbol(interp, loadHandle, "gtk_vpaned_new"); + if (gttk_gtk_vpaned_new == NULL) return TCL_ERROR; + gttk_gtk_vscale_new_with_range = (Ptr_gtk_vscale_new_with_range) Tcl_FindSymbol(interp, loadHandle, "gtk_vscale_new_with_range"); + if (gttk_gtk_vscale_new_with_range == NULL) return TCL_ERROR; + gttk_gtk_vscrollbar_new = (Ptr_gtk_vscrollbar_new) Tcl_FindSymbol(interp, loadHandle, "gtk_vscrollbar_new"); + if (gttk_gtk_vscrollbar_new == NULL) return TCL_ERROR; + gttk_gtk_widget_destroy = (Ptr_gtk_widget_destroy) Tcl_FindSymbol(interp, loadHandle, "gtk_widget_destroy"); + if (gttk_gtk_widget_destroy == NULL) return TCL_ERROR; + gttk_gtk_widget_realize = (Ptr_gtk_widget_realize) Tcl_FindSymbol(interp, loadHandle, "gtk_widget_realize"); + if (gttk_gtk_widget_realize == NULL) return TCL_ERROR; + gttk_gtk_widget_set_size_request = (Ptr_gtk_widget_set_size_request) Tcl_FindSymbol(interp, loadHandle, "gtk_widget_set_size_request"); + if (gttk_gtk_widget_set_size_request == NULL) return TCL_ERROR; + gttk_gtk_widget_size_request = (Ptr_gtk_widget_size_request) Tcl_FindSymbol(interp, loadHandle, "gtk_widget_size_request"); + if (gttk_gtk_widget_size_request == NULL) return TCL_ERROR; + gttk_gtk_widget_style_get = (Ptr_gtk_widget_style_get) Tcl_FindSymbol(interp, loadHandle, "gtk_widget_style_get"); + if (gttk_gtk_widget_style_get == NULL) return TCL_ERROR; + gttk_gtk_window_new = (Ptr_gtk_window_new) Tcl_FindSymbol(interp, loadHandle, "gtk_window_new"); + if (gttk_gtk_window_new == NULL) return TCL_ERROR; +#else + const char *fname = Tcl_GetString(file_name); + GModule *m = g_module_open(fname, G_MODULE_BIND_LAZY); + if (!m) { + Tcl_SetResult(interp, (char *) "cannot open module: ", TCL_STATIC); + Tcl_AppendResult(interp, fname, (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_adjustment_new", (gpointer *) >tk_gtk_adjustment_new)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_adjustment_new", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_adjustment_set_value", (gpointer *) >tk_gtk_adjustment_set_value)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_adjustment_set_value", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_arrow_new", (gpointer *) >tk_gtk_arrow_new)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_arrow_new", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_border_free", (gpointer *) >tk_gtk_border_free)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_border_free", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_button_get_relief", (gpointer *) >tk_gtk_button_get_relief)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_button_get_relief", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_button_new", (gpointer *) >tk_gtk_button_new)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_button_new", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_button_set_relief", (gpointer *) >tk_gtk_button_set_relief)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_button_set_relief", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_check_button_new", (gpointer *) >tk_gtk_check_button_new)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_check_button_new", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_combo_box_entry_new", (gpointer *) >tk_gtk_combo_box_entry_new)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_combo_box_entry_new", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_combo_box_new", (gpointer *) >tk_gtk_combo_box_new)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_combo_box_new", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_container_add", (gpointer *) >tk_gtk_container_add)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_container_add", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_disable_setlocale", (gpointer *) >tk_gtk_disable_setlocale)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_disable_setlocale", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_entry_new", (gpointer *) >tk_gtk_entry_new)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_entry_new", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_fixed_new", (gpointer *) >tk_gtk_fixed_new)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_fixed_new", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_frame_new", (gpointer *) >tk_gtk_frame_new)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_frame_new", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_hpaned_new", (gpointer *) >tk_gtk_hpaned_new)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_hpaned_new", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_hscale_new_with_range", (gpointer *) >tk_gtk_hscale_new_with_range)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_hscale_new_with_range", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_hscrollbar_new", (gpointer *) >tk_gtk_hscrollbar_new)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_hscrollbar_new", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_init_check", (gpointer *) >tk_gtk_init_check)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_init_check", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_notebook_new", (gpointer *) >tk_gtk_notebook_new)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_notebook_new", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_object_get", (gpointer *) >tk_gtk_object_get)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_object_get", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_paint_arrow", (gpointer *) >tk_gtk_paint_arrow)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_paint_arrow", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_paint_box", (gpointer *) >tk_gtk_paint_box)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_paint_box", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_paint_box_gap", (gpointer *) >tk_gtk_paint_box_gap)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_paint_box_gap", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_paint_check", (gpointer *) >tk_gtk_paint_check)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_paint_check", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_paint_extension", (gpointer *) >tk_gtk_paint_extension)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_paint_extension", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_paint_flat_box", (gpointer *) >tk_gtk_paint_flat_box)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_paint_flat_box", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_paint_focus", (gpointer *) >tk_gtk_paint_focus)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_paint_focus", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_paint_handle", (gpointer *) >tk_gtk_paint_handle)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_paint_handle", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_paint_option", (gpointer *) >tk_gtk_paint_option)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_paint_option", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_paint_resize_grip", (gpointer *) >tk_gtk_paint_resize_grip)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_paint_resize_grip", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_paint_shadow", (gpointer *) >tk_gtk_paint_shadow)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_paint_shadow", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_paint_slider", (gpointer *) >tk_gtk_paint_slider)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_paint_slider", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_progress_bar_new", (gpointer *) >tk_gtk_progress_bar_new)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_progress_bar_new", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_progress_bar_set_bar_style", (gpointer *) >tk_gtk_progress_bar_set_bar_style)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_progress_bar_set_bar_style", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_progress_bar_set_fraction", (gpointer *) >tk_gtk_progress_bar_set_fraction)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_progress_bar_set_fraction", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_progress_bar_set_orientation", (gpointer *) >tk_gtk_progress_bar_set_orientation)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_progress_bar_set_orientation", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_range_get_adjustment", (gpointer *) >tk_gtk_range_get_adjustment)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_range_get_adjustment", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_rc_get_default_files", (gpointer *) >tk_gtk_rc_get_default_files)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_rc_get_default_files", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_rc_get_style", (gpointer *) >tk_gtk_rc_get_style)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_rc_get_style", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_rc_get_theme_dir", (gpointer *) >tk_gtk_rc_get_theme_dir)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_rc_get_theme_dir", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_rc_reparse_all_for_settings", (gpointer *) >tk_gtk_rc_reparse_all_for_settings)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_rc_reparse_all_for_settings", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_rc_reset_styles", (gpointer *) >tk_gtk_rc_reset_styles)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_rc_reset_styles", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_rc_set_default_files", (gpointer *) >tk_gtk_rc_set_default_files)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_rc_set_default_files", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_settings_get_default", (gpointer *) >tk_gtk_settings_get_default)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_settings_get_default", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_statusbar_new", (gpointer *) >tk_gtk_statusbar_new)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_statusbar_new", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_style_apply_default_background", (gpointer *) >tk_gtk_style_apply_default_background)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_style_apply_default_background", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_style_attach", (gpointer *) >tk_gtk_style_attach)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_style_attach", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_style_lookup_color", (gpointer *) >tk_gtk_style_lookup_color)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_style_lookup_color", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_toolbar_new", (gpointer *) >tk_gtk_toolbar_new)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_toolbar_new", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_vpaned_new", (gpointer *) >tk_gtk_vpaned_new)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_vpaned_new", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_vscale_new_with_range", (gpointer *) >tk_gtk_vscale_new_with_range)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_vscale_new_with_range", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_vscrollbar_new", (gpointer *) >tk_gtk_vscrollbar_new)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_vscrollbar_new", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_widget_destroy", (gpointer *) >tk_gtk_widget_destroy)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_widget_destroy", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_widget_realize", (gpointer *) >tk_gtk_widget_realize)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_widget_realize", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_widget_set_size_request", (gpointer *) >tk_gtk_widget_set_size_request)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_widget_set_size_request", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_widget_size_request", (gpointer *) >tk_gtk_widget_size_request)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_widget_size_request", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_widget_style_get", (gpointer *) >tk_gtk_widget_style_get)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_widget_style_get", (char *) NULL); + return TCL_ERROR; + } + if (!g_module_symbol(m, "gtk_window_new", (gpointer *) >tk_gtk_window_new)) { + Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); + Tcl_AppendResult(interp, (char *) "gtk_window_new", (char *) NULL); + return TCL_ERROR; + } +#endif + return TCL_OK; +}; /* gttk_InitialiseSymbols_gtk */ + +#endif /* GTTK_LOAD_GTK_DYNAMICALLY */ diff --git a/generic/gtkTtk_Symbols.h b/generic/gttk_Symbols.h similarity index 55% rename from generic/gtkTtk_Symbols.h rename to generic/gttk_Symbols.h index f1646f1..35e67c8 100644 --- a/generic/gtkTtk_Symbols.h +++ b/generic/gttk_Symbols.h @@ -2,7 +2,7 @@ * gtkTtk_Symbols.h * -------------------- * - * This file is part of the GtkTtk package, a ttk based theme that uses + * This file is part of the gttk package, a ttk based theme that uses * Gtk/GNOME for drawing. * * Copyright (C) 2004-2012 by: @@ -13,8 +13,8 @@ * Aghia Paraskevi, 153 10, Athens, Greece. */ /* THIS FILE IS AUTOMATICALLY GENERATED - DO NOT EDIT! */ -#ifndef _GTKTTK_SYMBOLS -#define _GTKTTK_SYMBOLS +#ifndef _GTTK_SYMBOLS +#define _GTTK_SYMBOLS #include "tcl.h" #ifdef LOAD_SYMBOLS_WITH_TCL #else @@ -30,357 +30,357 @@ #include #endif -#ifdef GTKTTK_LOAD_GTK_DYNAMICALLY +#ifdef GTTK_LOAD_GTK_DYNAMICALLY extern "C" { typedef void (*Ptr_g_free)(gpointer mem); - extern Ptr_g_free GtkTtk_g_free; + extern Ptr_g_free gttk_g_free; typedef GList* (*Ptr_g_hash_table_get_keys)(GHashTable *hash_table); - extern Ptr_g_hash_table_get_keys GtkTtk_g_hash_table_get_keys; + extern Ptr_g_hash_table_get_keys gttk_g_hash_table_get_keys; typedef gpointer (*Ptr_g_malloc)(gsize n_bytes); - extern Ptr_g_malloc GtkTtk_g_malloc; + extern Ptr_g_malloc gttk_g_malloc; typedef gpointer (*Ptr_g_malloc0)(gsize n_bytes); - extern Ptr_g_malloc0 GtkTtk_g_malloc0; + extern Ptr_g_malloc0 gttk_g_malloc0; typedef void (*Ptr_g_object_get)(gpointer object, const gchar *first_property_name, ...); - extern Ptr_g_object_get GtkTtk_g_object_get; + extern Ptr_g_object_get gttk_g_object_get; typedef void (*Ptr_g_object_unref)(gpointer object); - extern Ptr_g_object_unref GtkTtk_g_object_unref; + extern Ptr_g_object_unref gttk_g_object_unref; typedef void (*Ptr_g_option_context_add_main_entries)(GOptionContext *context, const GOptionEntry *entries, const gchar *translation_domain); - extern Ptr_g_option_context_add_main_entries GtkTtk_g_option_context_add_main_entries; + extern Ptr_g_option_context_add_main_entries gttk_g_option_context_add_main_entries; typedef GOptionContext* (*Ptr_g_option_context_new)(const gchar *parameter_string); - extern Ptr_g_option_context_new GtkTtk_g_option_context_new; + extern Ptr_g_option_context_new gttk_g_option_context_new; typedef void (*Ptr_g_strfreev)(gchar **str_array); - extern Ptr_g_strfreev GtkTtk_g_strfreev; + extern Ptr_g_strfreev gttk_g_strfreev; typedef gchar* (*Ptr_gdk_color_to_string)(const GdkColor *color); - extern Ptr_gdk_color_to_string GtkTtk_gdk_color_to_string; + extern Ptr_gdk_color_to_string gttk_gdk_color_to_string; typedef GdkDisplay* (*Ptr_gdk_display_get_default)(void); - extern Ptr_gdk_display_get_default GtkTtk_gdk_display_get_default; + extern Ptr_gdk_display_get_default gttk_gdk_display_get_default; typedef GdkScreen* (*Ptr_gdk_display_get_screen)(GdkDisplay*, gint); - extern Ptr_gdk_display_get_screen GtkTtk_gdk_display_get_screen; + extern Ptr_gdk_display_get_screen gttk_gdk_display_get_screen; typedef void (*Ptr_gdk_drawable_set_colormap)(GdkColormap*); - extern Ptr_gdk_drawable_set_colormap GtkTtk_gdk_drawable_set_colormap; + extern Ptr_gdk_drawable_set_colormap gttk_gdk_drawable_set_colormap; typedef GdkGC* (*Ptr_gdk_gc_new)(GdkDrawable *drawable); - extern Ptr_gdk_gc_new GtkTtk_gdk_gc_new; + extern Ptr_gdk_gc_new gttk_gdk_gc_new; typedef GdkPixbuf* (*Ptr_gdk_pixbuf_get_from_drawable)(GdkPixbuf *dest, GdkDrawable *src, GdkColormap *cmap, int src_x, int src_y, int dest_x, int dest_y, int width, int height); - extern Ptr_gdk_pixbuf_get_from_drawable GtkTtk_gdk_pixbuf_get_from_drawable; + extern Ptr_gdk_pixbuf_get_from_drawable gttk_gdk_pixbuf_get_from_drawable; typedef GdkPixbuf* (*Ptr_gdk_pixbuf_new)(GdkColorspace colorspace, gboolean has_alpha, int bits_per_sample, int width, int height); - extern Ptr_gdk_pixbuf_new GtkTtk_gdk_pixbuf_new; + extern Ptr_gdk_pixbuf_new gttk_gdk_pixbuf_new; typedef void (*Ptr_gdk_pixbuf_unref)(GdkPixbuf *pixbuf); - extern Ptr_gdk_pixbuf_unref GtkTtk_gdk_pixbuf_unref; + extern Ptr_gdk_pixbuf_unref gttk_gdk_pixbuf_unref; typedef void (*Ptr_gdk_pixbuf_xlib_render_to_drawable)(GdkPixbuf *pixbuf, Drawable drawable, GC gc, int src_x, int src_y, int dest_x, int dest_y, int width, int height, XlibRgbDither dither, int x_dither, int y_dither); - extern Ptr_gdk_pixbuf_xlib_render_to_drawable GtkTtk_gdk_pixbuf_xlib_render_to_drawable; + extern Ptr_gdk_pixbuf_xlib_render_to_drawable gttk_gdk_pixbuf_xlib_render_to_drawable; typedef GdkPixmap* (*Ptr_gdk_pixmap_foreign_new_for_screen)(GdkScreen *screen, GdkNativeWindow anid, gint width, gint height, gint depth); - extern Ptr_gdk_pixmap_foreign_new_for_screen GtkTtk_gdk_pixmap_foreign_new_for_screen; + extern Ptr_gdk_pixmap_foreign_new_for_screen gttk_gdk_pixmap_foreign_new_for_screen; typedef GdkPixmap* (*Ptr_gdk_pixmap_new)(GdkDrawable *drawable, gint width, gint height, gint depth); - extern Ptr_gdk_pixmap_new GtkTtk_gdk_pixmap_new; + extern Ptr_gdk_pixmap_new gttk_gdk_pixmap_new; typedef GdkColormap* (*Ptr_gdk_x11_colormap_foreign_new)(GdkVisual *visual, Colormap xcolormap); - extern Ptr_gdk_x11_colormap_foreign_new GtkTtk_gdk_x11_colormap_foreign_new; + extern Ptr_gdk_x11_colormap_foreign_new gttk_gdk_x11_colormap_foreign_new; typedef GdkDisplay* (*Ptr_gdk_x11_lookup_xdisplay)(Display *xdisplay); - extern Ptr_gdk_x11_lookup_xdisplay GtkTtk_gdk_x11_lookup_xdisplay; + extern Ptr_gdk_x11_lookup_xdisplay gttk_gdk_x11_lookup_xdisplay; typedef GdkVisual* (*Ptr_gdk_x11_screen_lookup_visual)(GdkScreen *screen, VisualID xvisualid); - extern Ptr_gdk_x11_screen_lookup_visual GtkTtk_gdk_x11_screen_lookup_visual; + extern Ptr_gdk_x11_screen_lookup_visual gttk_gdk_x11_screen_lookup_visual; typedef GtkObject* (*Ptr_gtk_adjustment_new)(double, double, double, double, double, double); - extern Ptr_gtk_adjustment_new GtkTtk_gtk_adjustment_new; + extern Ptr_gtk_adjustment_new gttk_gtk_adjustment_new; typedef void (*Ptr_gtk_adjustment_set_value)(GtkAdjustment *adjustment, gdouble value); - extern Ptr_gtk_adjustment_set_value GtkTtk_gtk_adjustment_set_value; + extern Ptr_gtk_adjustment_set_value gttk_gtk_adjustment_set_value; typedef GtkWidget* (*Ptr_gtk_arrow_new)(GtkArrowType at, GtkShadowType st); - extern Ptr_gtk_arrow_new GtkTtk_gtk_arrow_new; + extern Ptr_gtk_arrow_new gttk_gtk_arrow_new; typedef void (*Ptr_gtk_border_free)(GtkBorder*); - extern Ptr_gtk_border_free GtkTtk_gtk_border_free; + extern Ptr_gtk_border_free gttk_gtk_border_free; typedef GtkReliefStyle (*Ptr_gtk_button_get_relief)(GtkButton *button); - extern Ptr_gtk_button_get_relief GtkTtk_gtk_button_get_relief; + extern Ptr_gtk_button_get_relief gttk_gtk_button_get_relief; typedef GtkWidget* (*Ptr_gtk_button_new)(void); - extern Ptr_gtk_button_new GtkTtk_gtk_button_new; + extern Ptr_gtk_button_new gttk_gtk_button_new; typedef void (*Ptr_gtk_button_set_relief)(GtkButton *button, GtkReliefStyle newstyle); - extern Ptr_gtk_button_set_relief GtkTtk_gtk_button_set_relief; + extern Ptr_gtk_button_set_relief gttk_gtk_button_set_relief; typedef GtkWidget* (*Ptr_gtk_check_button_new)(void); - extern Ptr_gtk_check_button_new GtkTtk_gtk_check_button_new; + extern Ptr_gtk_check_button_new gttk_gtk_check_button_new; typedef GtkWidget* (*Ptr_gtk_combo_box_entry_new)(void); - extern Ptr_gtk_combo_box_entry_new GtkTtk_gtk_combo_box_entry_new; + extern Ptr_gtk_combo_box_entry_new gttk_gtk_combo_box_entry_new; typedef GtkWidget* (*Ptr_gtk_combo_box_new)(void); - extern Ptr_gtk_combo_box_new GtkTtk_gtk_combo_box_new; + extern Ptr_gtk_combo_box_new gttk_gtk_combo_box_new; typedef void (*Ptr_gtk_container_add)(GtkContainer *container, GtkWidget *widget); - extern Ptr_gtk_container_add GtkTtk_gtk_container_add; + extern Ptr_gtk_container_add gttk_gtk_container_add; typedef void (*Ptr_gtk_disable_setlocale)(void); - extern Ptr_gtk_disable_setlocale GtkTtk_gtk_disable_setlocale; + extern Ptr_gtk_disable_setlocale gttk_gtk_disable_setlocale; typedef GtkWidget* (*Ptr_gtk_entry_new)(void); - extern Ptr_gtk_entry_new GtkTtk_gtk_entry_new; + extern Ptr_gtk_entry_new gttk_gtk_entry_new; typedef GtkWidget* (*Ptr_gtk_fixed_new)(void); - extern Ptr_gtk_fixed_new GtkTtk_gtk_fixed_new; + extern Ptr_gtk_fixed_new gttk_gtk_fixed_new; typedef GtkWidget* (*Ptr_gtk_frame_new)(const gchar *label); - extern Ptr_gtk_frame_new GtkTtk_gtk_frame_new; + extern Ptr_gtk_frame_new gttk_gtk_frame_new; typedef GtkWidget* (*Ptr_gtk_hpaned_new)(void); - extern Ptr_gtk_hpaned_new GtkTtk_gtk_hpaned_new; + extern Ptr_gtk_hpaned_new gttk_gtk_hpaned_new; typedef GtkWidget* (*Ptr_gtk_hscale_new_with_range)(gdouble min, gdouble max, gdouble step); - extern Ptr_gtk_hscale_new_with_range GtkTtk_gtk_hscale_new_with_range; + extern Ptr_gtk_hscale_new_with_range gttk_gtk_hscale_new_with_range; typedef GtkWidget* (*Ptr_gtk_hscrollbar_new)(GtkAdjustment *); - extern Ptr_gtk_hscrollbar_new GtkTtk_gtk_hscrollbar_new; + extern Ptr_gtk_hscrollbar_new gttk_gtk_hscrollbar_new; typedef gboolean (*Ptr_gtk_init_check)(int *argc, char ***argv); - extern Ptr_gtk_init_check GtkTtk_gtk_init_check; + extern Ptr_gtk_init_check gttk_gtk_init_check; typedef GtkWidget* (*Ptr_gtk_notebook_new)(void); - extern Ptr_gtk_notebook_new GtkTtk_gtk_notebook_new; + extern Ptr_gtk_notebook_new gttk_gtk_notebook_new; typedef void (*Ptr_gtk_object_get)(GtkObject *object, const gchar *first_property_name, ...); - extern Ptr_gtk_object_get GtkTtk_gtk_object_get; + extern Ptr_gtk_object_get gttk_gtk_object_get; typedef void (*Ptr_gtk_paint_arrow)(GtkStyle*,GdkWindow*, GtkStateType, GtkShadowType, const GdkRectangle *, GtkWidget *, const gchar *, GtkArrowType, gboolean, gint , gint , gint , gint); - extern Ptr_gtk_paint_arrow GtkTtk_gtk_paint_arrow; + extern Ptr_gtk_paint_arrow gttk_gtk_paint_arrow; typedef void (*Ptr_gtk_paint_box)(GtkStyle*,GdkWindow*, GtkStateType, GtkShadowType, const GdkRectangle *, GtkWidget *, const gchar *, gint , gint , gint , gint); - extern Ptr_gtk_paint_box GtkTtk_gtk_paint_box; + extern Ptr_gtk_paint_box gttk_gtk_paint_box; typedef void (*Ptr_gtk_paint_box_gap)(GtkStyle*,GdkWindow*, GtkStateType, GtkShadowType, const GdkRectangle *, GtkWidget *, const gchar *, gint, gint, gint , gint, GtkPositionType, gint gap_x, gint gap_width); - extern Ptr_gtk_paint_box_gap GtkTtk_gtk_paint_box_gap; + extern Ptr_gtk_paint_box_gap gttk_gtk_paint_box_gap; typedef void (*Ptr_gtk_paint_check)(GtkStyle*,GdkWindow*, GtkStateType, GtkShadowType, const GdkRectangle *, GtkWidget *, const gchar *, gint , gint , gint , gint); - extern Ptr_gtk_paint_check GtkTtk_gtk_paint_check; + extern Ptr_gtk_paint_check gttk_gtk_paint_check; typedef void (*Ptr_gtk_paint_extension)(GtkStyle *, GdkWindow *, GtkStateType, GtkShadowType, const GdkRectangle *, GtkWidget *, const gchar *, gint, gint, gint, gint, GtkPositionType); - extern Ptr_gtk_paint_extension GtkTtk_gtk_paint_extension; + extern Ptr_gtk_paint_extension gttk_gtk_paint_extension; typedef void (*Ptr_gtk_paint_flat_box)(GtkStyle*,GdkWindow*, GtkStateType, GtkShadowType, const GdkRectangle *, GtkWidget *, const gchar *, gint , gint , gint , gint); - extern Ptr_gtk_paint_flat_box GtkTtk_gtk_paint_flat_box; + extern Ptr_gtk_paint_flat_box gttk_gtk_paint_flat_box; typedef void (*Ptr_gtk_paint_focus)(GtkStyle *style, GdkWindow *window, GtkStateType state_type, GdkRectangle *area, GtkWidget *widget, const gchar *detail, gint x, gint y, gint width, gint height); - extern Ptr_gtk_paint_focus GtkTtk_gtk_paint_focus; + extern Ptr_gtk_paint_focus gttk_gtk_paint_focus; typedef void (*Ptr_gtk_paint_handle)(GtkStyle*,GdkWindow*, GtkStateType, GtkShadowType, const GdkRectangle *, GtkWidget *, const gchar *, gint , gint , gint , gint, GtkOrientation); - extern Ptr_gtk_paint_handle GtkTtk_gtk_paint_handle; + extern Ptr_gtk_paint_handle gttk_gtk_paint_handle; typedef void (*Ptr_gtk_paint_option)(GtkStyle*,GdkWindow*, GtkStateType, GtkShadowType, const GdkRectangle *, GtkWidget *, const gchar *, gint , gint , gint , gint); - extern Ptr_gtk_paint_option GtkTtk_gtk_paint_option; + extern Ptr_gtk_paint_option gttk_gtk_paint_option; typedef void (*Ptr_gtk_paint_resize_grip)(GtkStyle*,GdkWindow*, GtkStateType, const GdkRectangle *, GtkWidget *, const gchar *, GdkWindowEdge, gint , gint , gint , gint); - extern Ptr_gtk_paint_resize_grip GtkTtk_gtk_paint_resize_grip; + extern Ptr_gtk_paint_resize_grip gttk_gtk_paint_resize_grip; typedef void (*Ptr_gtk_paint_shadow)(GtkStyle*,GdkWindow*, GtkStateType, GtkShadowType, const GdkRectangle *, GtkWidget *, const gchar *, gint , gint , gint , gint); - extern Ptr_gtk_paint_shadow GtkTtk_gtk_paint_shadow; + extern Ptr_gtk_paint_shadow gttk_gtk_paint_shadow; typedef void (*Ptr_gtk_paint_slider)(GtkStyle*,GdkWindow*, GtkStateType, GtkShadowType, const GdkRectangle *, GtkWidget *, const gchar *, gint , gint , gint , gint, GtkOrientation); - extern Ptr_gtk_paint_slider GtkTtk_gtk_paint_slider; + extern Ptr_gtk_paint_slider gttk_gtk_paint_slider; typedef GtkWidget* (*Ptr_gtk_progress_bar_new)(void); - extern Ptr_gtk_progress_bar_new GtkTtk_gtk_progress_bar_new; + extern Ptr_gtk_progress_bar_new gttk_gtk_progress_bar_new; typedef void (*Ptr_gtk_progress_bar_set_bar_style)(GtkProgressBar *pbar, GtkProgressBarStyle style); - extern Ptr_gtk_progress_bar_set_bar_style GtkTtk_gtk_progress_bar_set_bar_style; + extern Ptr_gtk_progress_bar_set_bar_style gttk_gtk_progress_bar_set_bar_style; typedef void (*Ptr_gtk_progress_bar_set_fraction)(GtkProgressBar *pbar, gdouble fraction); - extern Ptr_gtk_progress_bar_set_fraction GtkTtk_gtk_progress_bar_set_fraction; + extern Ptr_gtk_progress_bar_set_fraction gttk_gtk_progress_bar_set_fraction; typedef void (*Ptr_gtk_progress_bar_set_orientation)(GtkProgressBar *pbar, GtkProgressBarOrientation orientation); - extern Ptr_gtk_progress_bar_set_orientation GtkTtk_gtk_progress_bar_set_orientation; + extern Ptr_gtk_progress_bar_set_orientation gttk_gtk_progress_bar_set_orientation; typedef GtkAdjustment * (*Ptr_gtk_range_get_adjustment)(GtkRange *range); - extern Ptr_gtk_range_get_adjustment GtkTtk_gtk_range_get_adjustment; + extern Ptr_gtk_range_get_adjustment gttk_gtk_range_get_adjustment; typedef gchar** (*Ptr_gtk_rc_get_default_files)(void); - extern Ptr_gtk_rc_get_default_files GtkTtk_gtk_rc_get_default_files; + extern Ptr_gtk_rc_get_default_files gttk_gtk_rc_get_default_files; typedef GtkStyle * (*Ptr_gtk_rc_get_style)(GtkWidget*); - extern Ptr_gtk_rc_get_style GtkTtk_gtk_rc_get_style; + extern Ptr_gtk_rc_get_style gttk_gtk_rc_get_style; typedef gchar* (*Ptr_gtk_rc_get_theme_dir)(void); - extern Ptr_gtk_rc_get_theme_dir GtkTtk_gtk_rc_get_theme_dir; + extern Ptr_gtk_rc_get_theme_dir gttk_gtk_rc_get_theme_dir; typedef gboolean (*Ptr_gtk_rc_reparse_all_for_settings)(GtkSettings *settings, gboolean force_load); - extern Ptr_gtk_rc_reparse_all_for_settings GtkTtk_gtk_rc_reparse_all_for_settings; + extern Ptr_gtk_rc_reparse_all_for_settings gttk_gtk_rc_reparse_all_for_settings; typedef void (*Ptr_gtk_rc_reset_styles)(GtkSettings *settings); - extern Ptr_gtk_rc_reset_styles GtkTtk_gtk_rc_reset_styles; + extern Ptr_gtk_rc_reset_styles gttk_gtk_rc_reset_styles; typedef void (*Ptr_gtk_rc_set_default_files)(gchar **filenames); - extern Ptr_gtk_rc_set_default_files GtkTtk_gtk_rc_set_default_files; + extern Ptr_gtk_rc_set_default_files gttk_gtk_rc_set_default_files; typedef GtkSettings * (*Ptr_gtk_settings_get_default)(void); - extern Ptr_gtk_settings_get_default GtkTtk_gtk_settings_get_default; + extern Ptr_gtk_settings_get_default gttk_gtk_settings_get_default; typedef GtkWidget* (*Ptr_gtk_statusbar_new)(void); - extern Ptr_gtk_statusbar_new GtkTtk_gtk_statusbar_new; + extern Ptr_gtk_statusbar_new gttk_gtk_statusbar_new; typedef void (*Ptr_gtk_style_apply_default_background)(GtkStyle *style, GdkWindow *window, gboolean set_bg, GtkStateType state_type, GdkRectangle *area, gint x, gint y, gint width, gint height); - extern Ptr_gtk_style_apply_default_background GtkTtk_gtk_style_apply_default_background; + extern Ptr_gtk_style_apply_default_background gttk_gtk_style_apply_default_background; typedef GtkStyle* (*Ptr_gtk_style_attach)(GtkStyle *, GdkWindow *); - extern Ptr_gtk_style_attach GtkTtk_gtk_style_attach; + extern Ptr_gtk_style_attach gttk_gtk_style_attach; typedef gboolean (*Ptr_gtk_style_lookup_color)(GtkStyle *style, const gchar *color_name, GdkColor *color); - extern Ptr_gtk_style_lookup_color GtkTtk_gtk_style_lookup_color; + extern Ptr_gtk_style_lookup_color gttk_gtk_style_lookup_color; typedef GtkWidget* (*Ptr_gtk_toolbar_new)(void); - extern Ptr_gtk_toolbar_new GtkTtk_gtk_toolbar_new; + extern Ptr_gtk_toolbar_new gttk_gtk_toolbar_new; typedef GtkWidget* (*Ptr_gtk_vpaned_new)(void); - extern Ptr_gtk_vpaned_new GtkTtk_gtk_vpaned_new; + extern Ptr_gtk_vpaned_new gttk_gtk_vpaned_new; typedef GtkWidget* (*Ptr_gtk_vscale_new_with_range)(gdouble min, gdouble max, gdouble step); - extern Ptr_gtk_vscale_new_with_range GtkTtk_gtk_vscale_new_with_range; + extern Ptr_gtk_vscale_new_with_range gttk_gtk_vscale_new_with_range; typedef GtkWidget* (*Ptr_gtk_vscrollbar_new)(GtkAdjustment *); - extern Ptr_gtk_vscrollbar_new GtkTtk_gtk_vscrollbar_new; + extern Ptr_gtk_vscrollbar_new gttk_gtk_vscrollbar_new; typedef void (*Ptr_gtk_widget_destroy)(GtkWidget *); - extern Ptr_gtk_widget_destroy GtkTtk_gtk_widget_destroy; + extern Ptr_gtk_widget_destroy gttk_gtk_widget_destroy; typedef void (*Ptr_gtk_widget_realize)(GtkWidget *); - extern Ptr_gtk_widget_realize GtkTtk_gtk_widget_realize; + extern Ptr_gtk_widget_realize gttk_gtk_widget_realize; typedef void (*Ptr_gtk_widget_set_size_request)(GtkWidget *widget, gint width, gint height); - extern Ptr_gtk_widget_set_size_request GtkTtk_gtk_widget_set_size_request; + extern Ptr_gtk_widget_set_size_request gttk_gtk_widget_set_size_request; typedef void (*Ptr_gtk_widget_size_request)(GtkWidget *widget, GtkRequisition *requisition); - extern Ptr_gtk_widget_size_request GtkTtk_gtk_widget_size_request; + extern Ptr_gtk_widget_size_request gttk_gtk_widget_size_request; typedef void (*Ptr_gtk_widget_style_get)(GtkWidget *, const gchar *first_property_name, ...); - extern Ptr_gtk_widget_style_get GtkTtk_gtk_widget_style_get; + extern Ptr_gtk_widget_style_get gttk_gtk_widget_style_get; typedef GtkWidget* (*Ptr_gtk_window_new)(GtkWindowType); - extern Ptr_gtk_window_new GtkTtk_gtk_window_new; + extern Ptr_gtk_window_new gttk_gtk_window_new; typedef void (*Ptr_xlib_rgb_init)(Display *display, Screen *screen); - extern Ptr_xlib_rgb_init GtkTtk_xlib_rgb_init; + extern Ptr_xlib_rgb_init gttk_xlib_rgb_init; } -extern int GtkTtk_InitialiseSymbols_gdk(Tcl_Interp *interp, Tcl_Obj *file_name); -#define GTKTTK_LAST_SYMBOL_gdk GtkTtk_gdk_x11_screen_lookup_visual -extern int GtkTtk_InitialiseSymbols_gdk_pixbuf(Tcl_Interp *interp, Tcl_Obj *file_name); -#define GTKTTK_LAST_SYMBOL_gdk_pixbuf GtkTtk_gdk_pixbuf_unref -extern int GtkTtk_InitialiseSymbols_gdk_pixbuf_xlib(Tcl_Interp *interp, Tcl_Obj *file_name); -#define GTKTTK_LAST_SYMBOL_gdk_pixbuf_xlib GtkTtk_xlib_rgb_init -extern int GtkTtk_InitialiseSymbols_glib(Tcl_Interp *interp, Tcl_Obj *file_name); -#define GTKTTK_LAST_SYMBOL_glib GtkTtk_g_strfreev -extern int GtkTtk_InitialiseSymbols_gobject(Tcl_Interp *interp, Tcl_Obj *file_name); -#define GTKTTK_LAST_SYMBOL_gobject GtkTtk_g_object_unref -extern int GtkTtk_InitialiseSymbols_gtk(Tcl_Interp *interp, Tcl_Obj *file_name); -#define GTKTTK_LAST_SYMBOL_gtk GtkTtk_gtk_window_new +extern int gttk_InitialiseSymbols_gdk(Tcl_Interp *interp, Tcl_Obj *file_name); +#define GTTK_LAST_SYMBOL_gdk gttk_gdk_x11_screen_lookup_visual +extern int gttk_InitialiseSymbols_gdk_pixbuf(Tcl_Interp *interp, Tcl_Obj *file_name); +#define GTTK_LAST_SYMBOL_gdk_pixbuf gttk_gdk_pixbuf_unref +extern int gttk_InitialiseSymbols_gdk_pixbuf_xlib(Tcl_Interp *interp, Tcl_Obj *file_name); +#define GTTK_LAST_SYMBOL_gdk_pixbuf_xlib gttk_xlib_rgb_init +extern int gttk_InitialiseSymbols_glib(Tcl_Interp *interp, Tcl_Obj *file_name); +#define GTTK_LAST_SYMBOL_glib gttk_g_strfreev +extern int gttk_InitialiseSymbols_gobject(Tcl_Interp *interp, Tcl_Obj *file_name); +#define GTTK_LAST_SYMBOL_gobject gttk_g_object_unref +extern int gttk_InitialiseSymbols_gtk(Tcl_Interp *interp, Tcl_Obj *file_name); +#define GTTK_LAST_SYMBOL_gtk gttk_gtk_window_new -#else /* GTKTTK_LOAD_GTK_DYNAMICALLY */ +#else /* GTTK_LOAD_GTK_DYNAMICALLY */ -#define GtkTtk_g_free \ +#define gttk_g_free \ g_free -#define GtkTtk_g_hash_table_get_keys \ +#define gttk_g_hash_table_get_keys \ g_hash_table_get_keys -#define GtkTtk_g_malloc \ +#define gttk_g_malloc \ g_malloc -#define GtkTtk_g_malloc0 \ +#define gttk_g_malloc0 \ g_malloc0 -#define GtkTtk_g_object_get \ +#define gttk_g_object_get \ g_object_get -#define GtkTtk_g_object_unref \ +#define gttk_g_object_unref \ g_object_unref -#define GtkTtk_g_option_context_add_main_entries \ +#define gttk_g_option_context_add_main_entries \ g_option_context_add_main_entries -#define GtkTtk_g_option_context_new \ +#define gttk_g_option_context_new \ g_option_context_new -#define GtkTtk_g_strfreev \ +#define gttk_g_strfreev \ g_strfreev -#define GtkTtk_gdk_color_to_string \ +#define gttk_gdk_color_to_string \ gdk_color_to_string -#define GtkTtk_gdk_display_get_default \ +#define gttk_gdk_display_get_default \ gdk_display_get_default -#define GtkTtk_gdk_display_get_screen \ +#define gttk_gdk_display_get_screen \ gdk_display_get_screen -#define GtkTtk_gdk_drawable_set_colormap \ +#define gttk_gdk_drawable_set_colormap \ gdk_drawable_set_colormap -#define GtkTtk_gdk_gc_new \ +#define gttk_gdk_gc_new \ gdk_gc_new -#define GtkTtk_gdk_pixbuf_get_from_drawable \ +#define gttk_gdk_pixbuf_get_from_drawable \ gdk_pixbuf_get_from_drawable -#define GtkTtk_gdk_pixbuf_new \ +#define gttk_gdk_pixbuf_new \ gdk_pixbuf_new -#define GtkTtk_gdk_pixbuf_unref \ +#define gttk_gdk_pixbuf_unref \ gdk_pixbuf_unref -#define GtkTtk_gdk_pixbuf_xlib_render_to_drawable \ +#define gttk_gdk_pixbuf_xlib_render_to_drawable \ gdk_pixbuf_xlib_render_to_drawable -#define GtkTtk_gdk_pixmap_foreign_new_for_screen \ +#define gttk_gdk_pixmap_foreign_new_for_screen \ gdk_pixmap_foreign_new_for_screen -#define GtkTtk_gdk_pixmap_new \ +#define gttk_gdk_pixmap_new \ gdk_pixmap_new -#define GtkTtk_gdk_x11_colormap_foreign_new \ +#define gttk_gdk_x11_colormap_foreign_new \ gdk_x11_colormap_foreign_new -#define GtkTtk_gdk_x11_lookup_xdisplay \ +#define gttk_gdk_x11_lookup_xdisplay \ gdk_x11_lookup_xdisplay -#define GtkTtk_gdk_x11_screen_lookup_visual \ +#define gttk_gdk_x11_screen_lookup_visual \ gdk_x11_screen_lookup_visual -#define GtkTtk_gtk_adjustment_new \ +#define gttk_gtk_adjustment_new \ gtk_adjustment_new -#define GtkTtk_gtk_adjustment_set_value \ +#define gttk_gtk_adjustment_set_value \ gtk_adjustment_set_value -#define GtkTtk_gtk_arrow_new \ +#define gttk_gtk_arrow_new \ gtk_arrow_new -#define GtkTtk_gtk_border_free \ +#define gttk_gtk_border_free \ gtk_border_free -#define GtkTtk_gtk_button_get_relief \ +#define gttk_gtk_button_get_relief \ gtk_button_get_relief -#define GtkTtk_gtk_button_new \ +#define gttk_gtk_button_new \ gtk_button_new -#define GtkTtk_gtk_button_set_relief \ +#define gttk_gtk_button_set_relief \ gtk_button_set_relief -#define GtkTtk_gtk_check_button_new \ +#define gttk_gtk_check_button_new \ gtk_check_button_new -#define GtkTtk_gtk_combo_box_entry_new \ +#define gttk_gtk_combo_box_entry_new \ gtk_combo_box_entry_new -#define GtkTtk_gtk_combo_box_new \ +#define gttk_gtk_combo_box_new \ gtk_combo_box_new -#define GtkTtk_gtk_container_add \ +#define gttk_gtk_container_add \ gtk_container_add -#define GtkTtk_gtk_disable_setlocale \ +#define gttk_gtk_disable_setlocale \ gtk_disable_setlocale -#define GtkTtk_gtk_entry_new \ +#define gttk_gtk_entry_new \ gtk_entry_new -#define GtkTtk_gtk_fixed_new \ +#define gttk_gtk_fixed_new \ gtk_fixed_new -#define GtkTtk_gtk_frame_new \ +#define gttk_gtk_frame_new \ gtk_frame_new -#define GtkTtk_gtk_hpaned_new \ +#define gttk_gtk_hpaned_new \ gtk_hpaned_new -#define GtkTtk_gtk_hscale_new_with_range \ +#define gttk_gtk_hscale_new_with_range \ gtk_hscale_new_with_range -#define GtkTtk_gtk_hscrollbar_new \ +#define gttk_gtk_hscrollbar_new \ gtk_hscrollbar_new -#define GtkTtk_gtk_init_check \ +#define gttk_gtk_init_check \ gtk_init_check -#define GtkTtk_gtk_notebook_new \ +#define gttk_gtk_notebook_new \ gtk_notebook_new -#define GtkTtk_gtk_object_get \ +#define gttk_gtk_object_get \ gtk_object_get -#define GtkTtk_gtk_paint_arrow \ +#define gttk_gtk_paint_arrow \ gtk_paint_arrow -#define GtkTtk_gtk_paint_box \ +#define gttk_gtk_paint_box \ gtk_paint_box -#define GtkTtk_gtk_paint_box_gap \ +#define gttk_gtk_paint_box_gap \ gtk_paint_box_gap -#define GtkTtk_gtk_paint_check \ +#define gttk_gtk_paint_check \ gtk_paint_check -#define GtkTtk_gtk_paint_extension \ +#define gttk_gtk_paint_extension \ gtk_paint_extension -#define GtkTtk_gtk_paint_flat_box \ +#define gttk_gtk_paint_flat_box \ gtk_paint_flat_box -#define GtkTtk_gtk_paint_focus \ +#define gttk_gtk_paint_focus \ gtk_paint_focus -#define GtkTtk_gtk_paint_handle \ +#define gttk_gtk_paint_handle \ gtk_paint_handle -#define GtkTtk_gtk_paint_option \ +#define gttk_gtk_paint_option \ gtk_paint_option -#define GtkTtk_gtk_paint_resize_grip \ +#define gttk_gtk_paint_resize_grip \ gtk_paint_resize_grip -#define GtkTtk_gtk_paint_shadow \ +#define gttk_gtk_paint_shadow \ gtk_paint_shadow -#define GtkTtk_gtk_paint_slider \ +#define gttk_gtk_paint_slider \ gtk_paint_slider -#define GtkTtk_gtk_progress_bar_new \ +#define gttk_gtk_progress_bar_new \ gtk_progress_bar_new -#define GtkTtk_gtk_progress_bar_set_bar_style \ +#define gttk_gtk_progress_bar_set_bar_style \ gtk_progress_bar_set_bar_style -#define GtkTtk_gtk_progress_bar_set_fraction \ +#define gttk_gtk_progress_bar_set_fraction \ gtk_progress_bar_set_fraction -#define GtkTtk_gtk_progress_bar_set_orientation \ +#define gttk_gtk_progress_bar_set_orientation \ gtk_progress_bar_set_orientation -#define GtkTtk_gtk_range_get_adjustment \ +#define gttk_gtk_range_get_adjustment \ gtk_range_get_adjustment -#define GtkTtk_gtk_rc_get_default_files \ +#define gttk_gtk_rc_get_default_files \ gtk_rc_get_default_files -#define GtkTtk_gtk_rc_get_style \ +#define gttk_gtk_rc_get_style \ gtk_rc_get_style -#define GtkTtk_gtk_rc_get_theme_dir \ +#define gttk_gtk_rc_get_theme_dir \ gtk_rc_get_theme_dir -#define GtkTtk_gtk_rc_reparse_all_for_settings \ +#define gttk_gtk_rc_reparse_all_for_settings \ gtk_rc_reparse_all_for_settings -#define GtkTtk_gtk_rc_reset_styles \ +#define gttk_gtk_rc_reset_styles \ gtk_rc_reset_styles -#define GtkTtk_gtk_rc_set_default_files \ +#define gttk_gtk_rc_set_default_files \ gtk_rc_set_default_files -#define GtkTtk_gtk_settings_get_default \ +#define gttk_gtk_settings_get_default \ gtk_settings_get_default -#define GtkTtk_gtk_statusbar_new \ +#define gttk_gtk_statusbar_new \ gtk_statusbar_new -#define GtkTtk_gtk_style_apply_default_background \ +#define gttk_gtk_style_apply_default_background \ gtk_style_apply_default_background -#define GtkTtk_gtk_style_attach \ +#define gttk_gtk_style_attach \ gtk_style_attach -#define GtkTtk_gtk_style_lookup_color \ +#define gttk_gtk_style_lookup_color \ gtk_style_lookup_color -#define GtkTtk_gtk_toolbar_new \ +#define gttk_gtk_toolbar_new \ gtk_toolbar_new -#define GtkTtk_gtk_vpaned_new \ +#define gttk_gtk_vpaned_new \ gtk_vpaned_new -#define GtkTtk_gtk_vscale_new_with_range \ +#define gttk_gtk_vscale_new_with_range \ gtk_vscale_new_with_range -#define GtkTtk_gtk_vscrollbar_new \ +#define gttk_gtk_vscrollbar_new \ gtk_vscrollbar_new -#define GtkTtk_gtk_widget_destroy \ +#define gttk_gtk_widget_destroy \ gtk_widget_destroy -#define GtkTtk_gtk_widget_realize \ +#define gttk_gtk_widget_realize \ gtk_widget_realize -#define GtkTtk_gtk_widget_set_size_request \ +#define gttk_gtk_widget_set_size_request \ gtk_widget_set_size_request -#define GtkTtk_gtk_widget_size_request \ +#define gttk_gtk_widget_size_request \ gtk_widget_size_request -#define GtkTtk_gtk_widget_style_get \ +#define gttk_gtk_widget_style_get \ gtk_widget_style_get -#define GtkTtk_gtk_window_new \ +#define gttk_gtk_window_new \ gtk_window_new -#define GtkTtk_xlib_rgb_init \ +#define gttk_xlib_rgb_init \ xlib_rgb_init -#endif /* GTKTTK_LOAD_GTK_DYNAMICALLY */ +#endif /* GTTK_LOAD_GTK_DYNAMICALLY */ -#endif /* _GTKTTK_SYMBOLS */ +#endif /* _GTTK_SYMBOLS */ diff --git a/generic/gtkTtk_TkHeaders.h b/generic/gttk_TkHeaders.h similarity index 74% rename from generic/gtkTtk_TkHeaders.h rename to generic/gttk_TkHeaders.h index a23dbb2..c19a053 100644 --- a/generic/gtkTtk_TkHeaders.h +++ b/generic/gttk_TkHeaders.h @@ -1,8 +1,8 @@ /* - * gtkTtk_TkHeaders.h + * gttk_TkHeaders.h * ---------------------- * - * This file is part of the gtkTtk package, a Tk/Tile based theme that uses + * This file is part of the gttk package, a Tk/Tile based theme that uses * Gtk/GNOME for drawing. * * Copyright (C) 2004-2008 by: @@ -13,8 +13,8 @@ * Aghia Paraskevi, 153 10, Athens, Greece. */ -#ifndef __GTKTTK_TK_HEADERS -#define __GTKTTK_TK_HEADERS +#ifndef __GTTK_TK_HEADERS +#define __GTTK_TK_HEADERS #ifdef USE_TK_STUBS /* @@ -31,4 +31,4 @@ #include #endif -#endif /* __GTKTTK_TK_HEADERS */ +#endif /* __GTTK_TK_HEADERS */ diff --git a/generic/gtkTtk_ToolButton.cpp b/generic/gttk_ToolButton.cpp similarity index 73% rename from generic/gtkTtk_ToolButton.cpp rename to generic/gttk_ToolButton.cpp index 4b3e581..c15444c 100644 --- a/generic/gtkTtk_ToolButton.cpp +++ b/generic/gttk_ToolButton.cpp @@ -1,8 +1,8 @@ /* - * gtkTtk_ToolButton.cpp + * gttk_ToolButton.cpp * ----------------------- * - * This file is part of the gtkTtk package, a Tk/Tile based theme that uses + * This file is part of the gttk package, a Tk/Tile based theme that uses * Gtk/GNOME for drawing. * * Copyright (C) 2004-2008 by: @@ -13,9 +13,9 @@ * Aghia Paraskevi, 153 10, Athens, Greece. */ -#include "gtkTtk_Utilities.h" -#include "gtkTtk_TkHeaders.h" -#include "gtkTtk_WidgetDefaults.h" +#include "gttk_Utilities.h" +#include "gttk_TkHeaders.h" +#include "gttk_WidgetDefaults.h" typedef struct { Tcl_Obj *defaultStateObj; @@ -31,13 +31,13 @@ static void ToolButtonElementGeometry( void *clientData, void *elementRecord, Tk_Window tkwin, int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr) { - GTKTTK_WIDGET_CACHE_DEFINITION; + GTTK_WIDGET_CACHE_DEFINITION; gint focus_width; gint focus_pad; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - GtkWidget *widget = GtkTtk_GetButton(wc); - GTKTTK_ENSURE_WIDGET_OK; - GtkTtk_gtk_widget_style_get(widget, + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GtkWidget *widget = gttk_GetButton(wc); + GTTK_ENSURE_WIDGET_OK; + gttk_gtk_widget_style_get(widget, "focus-line-width", &focus_width, "focus-padding", &focus_pad, NULL); *paddingPtr = Ttk_UniformPadding(PushButtonUniformPadding + @@ -48,7 +48,7 @@ static void ToolButtonElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned state) { - GTKTTK_GTK_DRAWABLE_DEFINITIONS; + GTTK_GTK_DRAWABLE_DEFINITIONS; gint width, height; gint x, y; gint border_width; @@ -59,44 +59,44 @@ static void ToolButtonElementDraw( gboolean interior_focus; gint focus_width; gint focus_pad; - GTKTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; - GtkWidget *toolbar = GtkTtk_GetToolBar(wc); - GtkWidget *widget = GtkTtk_GetToolButton(wc); + GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE; + GtkWidget *toolbar = gttk_GetToolBar(wc); + GtkWidget *widget = gttk_GetToolButton(wc); ToolButtonElement *bd = (ToolButtonElement *) elementRecord; GtkButton *button = (GtkButton *) widget; - GTKTTK_ENSURE_WIDGET_OK; - GTKTTK_STYLE_FROM_WIDGET; - GTKTTK_DRAWABLE_FROM_WIDGET; - GTKTTK_DEFAULT_BACKGROUND; - GtkTtk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, - GTKTTK_SECTION_BUTTONS | GTKTTK_SECTION_ALL); - GTKTTK_WIDGET_SET_FOCUS(widget); - GTKTTK_WIDGET_SET_DEFAULT(widget, bd->defaultStateObj); - // GtkTtk_StateInfo(state, gtkState, gtkShadow, tkwin, widget); + GTTK_ENSURE_WIDGET_OK; + GTTK_STYLE_FROM_WIDGET; + GTTK_DRAWABLE_FROM_WIDGET; + GTTK_DEFAULT_BACKGROUND; + gttk_StateShadowTableLookup(NULL, state, gtkState, gtkShadow, + GTTK_SECTION_BUTTONS | GTTK_SECTION_ALL); + GTTK_WIDGET_SET_FOCUS(widget); + GTTK_WIDGET_SET_DEFAULT(widget, bd->defaultStateObj); + // gttk_StateInfo(state, gtkState, gtkShadow, tkwin, widget); /* Make the button relief to what suggested by the toolbar... */ - GtkTtk_gtk_widget_style_get(toolbar, "button-relief", &button_relief,NULL); - if (button_relief != GtkTtk_gtk_button_get_relief(button)) { - GtkTtk_gtk_button_set_relief(button, button_relief); + gttk_gtk_widget_style_get(toolbar, "button-relief", &button_relief,NULL); + if (button_relief != gttk_gtk_button_get_relief(button)) { + gttk_gtk_button_set_relief(button, button_relief); } /* * The following was taken from GTK+ button drawing code. */ border_width = ((GtkContainer*) widget)->border_width; - GtkTtk_gtk_widget_style_get(widget, + gttk_gtk_widget_style_get(widget, "default-border", &tmp_border, "default-outside-border", &tmp_outside_border, "interior-focus", &interior_focus, NULL); if (tmp_border) { default_border = *tmp_border; - GtkTtk_gtk_border_free(tmp_border); + gttk_gtk_border_free(tmp_border); } if (tmp_outside_border) { default_outside_border = *tmp_outside_border; - GtkTtk_gtk_border_free(tmp_outside_border); + gttk_gtk_border_free(tmp_outside_border); } - GtkTtk_gtk_widget_style_get(widget, + gttk_gtk_widget_style_get(widget, "focus-line-width", &focus_width, "focus-padding", &focus_pad, NULL); @@ -106,7 +106,7 @@ static void ToolButtonElementDraw( height = b.height - border_width * 2; if (has_default && button->relief == GTK_RELIEF_NORMAL) { - GtkTtk_gtk_paint_box(style, gdkDrawable, GTK_STATE_NORMAL, GTK_SHADOW_IN, + gttk_gtk_paint_box(style, gdkDrawable, GTK_STATE_NORMAL, GTK_SHADOW_IN, NULL, widget, "buttondefault", x, y, width, height); x += default_border.left; y += default_border.top; @@ -128,7 +128,7 @@ static void ToolButtonElementDraw( if (button->relief != GTK_RELIEF_NONE || (state & TTK_STATE_PRESSED) || (state & TTK_STATE_ACTIVE) ) { - GtkTtk_gtk_paint_box(style, gdkDrawable, gtkState, gtkShadow, NULL, + gttk_gtk_paint_box(style, gdkDrawable, gtkState, gtkShadow, NULL, widget, "button", x, y, width, height); } @@ -137,7 +137,7 @@ static void ToolButtonElementDraw( gint child_displacement_y; gboolean displace_focus; - GtkTtk_gtk_widget_style_get(widget, + gttk_gtk_widget_style_get(widget, "child-displacement-y", &child_displacement_y, "child-displacement-x", &child_displacement_x, "displace-focus", &displace_focus, NULL); @@ -159,13 +159,13 @@ static void ToolButtonElementDraw( y += child_displacement_y; } - GtkTtk_gtk_paint_focus(style, gdkDrawable, gtkState, NULL, widget, + gttk_gtk_paint_focus(style, gdkDrawable, gtkState, NULL, widget, "button", x, y, width, height); } - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height, b.x, b.y); - GTKTTK_CLEANUP_GTK_DRAWABLE; + GTTK_CLEANUP_GTK_DRAWABLE; } static Ttk_ElementSpec ToolButtonElementSpec = { @@ -186,8 +186,8 @@ TTK_BEGIN_LAYOUT(ToolbuttonLayout) TTK_NODE("Toolbutton.label", TTK_FILL_BOTH))) TTK_END_LAYOUT -int GtkTtk_Init_ToolButton(Tcl_Interp *interp, - GtkTtk_WidgetCache **wc, Ttk_Theme themePtr) +int gttk_Init_ToolButton(Tcl_Interp *interp, + gttk_WidgetCache **wc, Ttk_Theme themePtr) { /* * Register elements: @@ -200,4 +200,4 @@ int GtkTtk_Init_ToolButton(Tcl_Interp *interp, */ Ttk_RegisterLayout(themePtr, "TToolbutton", ToolbuttonLayout); return TCL_OK; -}; /* GtkTtk_Init_ToolButton */ +}; /* gttk_Init_ToolButton */ diff --git a/generic/gtkTtk_TreeView.cpp b/generic/gttk_TreeView.cpp similarity index 72% rename from generic/gtkTtk_TreeView.cpp rename to generic/gttk_TreeView.cpp index 33695f5..2de0894 100644 --- a/generic/gtkTtk_TreeView.cpp +++ b/generic/gttk_TreeView.cpp @@ -1,8 +1,8 @@ /* - * gtkTtk_TreeView.cpp + * gttk_TreeView.cpp * --------------------- * - * This file is part of the gtkTtk package, a Tk/Tile based theme that uses + * This file is part of the gttk package, a Tk/Tile based theme that uses * Gtk/GNOME for drawing. * * Copyright (C) 2004-2008 by: @@ -13,9 +13,9 @@ * Aghia Paraskevi, 153 10, Athens, Greece. */ -#include "gtkTtk_Utilities.h" -#include "gtkTtk_TkHeaders.h" -#include "gtkTtk_WidgetDefaults.h" +#include "gttk_Utilities.h" +#include "gttk_TkHeaders.h" +#include "gttk_WidgetDefaults.h" #define ITEM_LAYOUT "Item" #define CELL_LAYOUT "Cell" @@ -31,16 +31,16 @@ */ static Ttk_StateTable treeview_field_statemap[] = { -#ifdef GTKTTK_GTK_VERSION_3 +#ifdef GTTK_GTK_VERSION_3 {QStyle::Style_Enabled|QStyle::Style_Down, TTK_STATE_PRESSED, 0}, {QStyle::Style_Enabled, TTK_STATE_ACTIVE, 0}, {QStyle::Style_Enabled, 0, 0} -#endif /* GTKTTK_GTK_VERSION_3 */ -#ifdef GTKTTK_GTK_VERSION_4 +#endif /* GTTK_GTK_VERSION_3 */ +#ifdef GTTK_GTK_VERSION_4 {QStyle::State_Enabled|QStyle::State_Sunken, TTK_STATE_PRESSED, 0}, {QStyle::State_Enabled, TTK_STATE_ACTIVE, 0}, {QStyle::State_Enabled, 0, 0} -#endif /* GTKTTK_GTK_VERSION_4 */ +#endif /* GTTK_GTK_VERSION_4 */ }; typedef struct { @@ -55,7 +55,7 @@ static void TreeViewFieldElementGeometry( void *clientData, void *elementRecord, Tk_Window tkwin, int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr) { - if (!GtkTtk_GtkInitialised()) NO_GTK_STYLE_ENGINE; + if (!gttk_GtkInitialised()) NO_GTK_STYLE_ENGINE; *paddingPtr = Ttk_UniformPadding(0); } @@ -63,39 +63,39 @@ static void TreeViewFieldElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned state) { - if (!GtkTtk_GtkInitialised()) NO_GTK_STYLE_ENGINE; - NULL_PROXY_WIDGET(GtkTtk_QWidget_Widget); - Tcl_MutexLock(>kTtkMutex); + if (!gttk_GtkInitialised()) NO_GTK_STYLE_ENGINE; + NULL_PROXY_WIDGET(gttk_QWidget_Widget); + Tcl_MutexLock(>tkMutex); QPixmap pixmap(b.width, b.height); QPainter painter(&pixmap); - GTKTTK_PAINT_BACKGROUND_BASE(b.width, b.height); - GTKTTK_SET_FOCUS(state); -#ifdef GTKTTK_GTK_VERSION_3 - QStyle::SFlags sflags =GtkTtk_StateTableLookup(treeview_field_statemap, state); + GTTK_PAINT_BACKGROUND_BASE(b.width, b.height); + GTTK_SET_FOCUS(state); +#ifdef GTTK_GTK_VERSION_3 + QStyle::SFlags sflags =gttk_StateTableLookup(treeview_field_statemap, state); sflags |= QStyle::Style_Horizontal; - wc->GtkTtk_Style->drawPrimitive(QStyle::PE_GroupBoxFrame, &painter, + wc->gttk_Style->drawPrimitive(QStyle::PE_GroupBoxFrame, &painter, QRect(0, 0, b.width, b.height), qApp->palette().active(), sflags, QStyleOption(/*lineWidth*/1, /*midLineWidth*/0, /*frameShape*/QFrame::StyledPanel, /*frameShadow*/QFrame::Sunken)); - wc->GtkTtk_Style->drawPrimitive(QStyle::PE_PanelLineEdit, &painter, + wc->gttk_Style->drawPrimitive(QStyle::PE_PanelLineEdit, &painter, QRect(0, 0, b.width, b.height), qApp->palette().active(), sflags, QStyleOption(1,1)); -#endif /* GTKTTK_GTK_VERSION_3 */ -#ifdef GTKTTK_GTK_VERSION_4 +#endif /* GTTK_GTK_VERSION_3 */ +#ifdef GTTK_GTK_VERSION_4 QStyleOptionFrame option; option.rect = QRect(0, 0, b.width, b.height); option.lineWidth = 1; option.state |= - (QStyle::StateFlag) GtkTtk_StateTableLookup(treeview_field_statemap, state); - wc->GtkTtk_Style->drawPrimitive(QStyle::PE_FrameGroupBox, &option, + (QStyle::StateFlag) gttk_StateTableLookup(treeview_field_statemap, state); + wc->gttk_Style->drawPrimitive(QStyle::PE_FrameGroupBox, &option, &painter); -#endif /* GTKTTK_GTK_VERSION_4 */ - GTKTTK_CLEAR_FOCUS(state); +#endif /* GTTK_GTK_VERSION_4 */ + GTTK_CLEAR_FOCUS(state); // printf("x=%d, y=%d, w=%d, h=%d\n", b.x, b.y, b.width, b.height); - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height, b.x, b.y); - Tcl_MutexUnlock(>kTtkMutex); + Tcl_MutexUnlock(>tkMutex); } static Ttk_ElementSpec TreeViewFieldElementSpec = { @@ -115,16 +115,16 @@ static Ttk_ElementSpec TreeViewFieldElementSpec = { */ static Ttk_StateTable treeview_client_statemap[] = { -#ifdef GTKTTK_GTK_VERSION_3 +#ifdef GTTK_GTK_VERSION_3 {QStyle::Style_Enabled|QStyle::Style_Down, TTK_STATE_PRESSED, 0}, {QStyle::Style_Enabled, TTK_STATE_ACTIVE, 0}, {QStyle::Style_Enabled, 0, 0} -#endif /* GTKTTK_GTK_VERSION_3 */ -#ifdef GTKTTK_GTK_VERSION_4 +#endif /* GTTK_GTK_VERSION_3 */ +#ifdef GTTK_GTK_VERSION_4 {QStyle::State_Enabled|QStyle::State_Sunken, TTK_STATE_PRESSED, 0}, {QStyle::State_Enabled, TTK_STATE_ACTIVE, 0}, {QStyle::State_Enabled, 0, 0} -#endif /* GTKTTK_GTK_VERSION_4 */ +#endif /* GTTK_GTK_VERSION_4 */ }; typedef struct { @@ -139,7 +139,7 @@ static void TreeViewClientElementGeometry( void *clientData, void *elementRecord, Tk_Window tkwin, int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr) { - if (!GtkTtk_GtkInitialised()) NO_GTK_STYLE_ENGINE; + if (!gttk_GtkInitialised()) NO_GTK_STYLE_ENGINE; *paddingPtr = Ttk_UniformPadding(0); } @@ -147,37 +147,37 @@ static void TreeViewClientElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned state) { - if (!GtkTtk_GtkInitialised()) NO_GTK_STYLE_ENGINE; - NULL_PROXY_WIDGET(GtkTtk_QWidget_Widget); - Tcl_MutexLock(>kTtkMutex); + if (!gttk_GtkInitialised()) NO_GTK_STYLE_ENGINE; + NULL_PROXY_WIDGET(gttk_QWidget_Widget); + Tcl_MutexLock(>tkMutex); QPixmap pixmap(b.width, b.height); QPainter painter(&pixmap); - GTKTTK_PAINT_BACKGROUND_BASE(b.width, b.height); + GTTK_PAINT_BACKGROUND_BASE(b.width, b.height); #if 0 -#ifdef GTKTTK_GTK_VERSION_3 +#ifdef GTTK_GTK_VERSION_3 QStyle::SFlags sflags = - GtkTtk_StateTableLookup(treeview_client_statemap, state); + gttk_StateTableLookup(treeview_client_statemap, state); sflags |= QStyle::Style_Horizontal; - wc->GtkTtk_Style->drawPrimitive(QStyle::PE_GroupBoxFrame, &painter, + wc->gttk_Style->drawPrimitive(QStyle::PE_GroupBoxFrame, &painter, QRect(0, 0, b.width, b.height), qApp->palette().active(), sflags, QStyleOption(/*lineWidth*/1, /*midLineWidth*/0, /*frameShape*/QFrame::StyledPanel, /*frameShadow*/QFrame::Sunken)); -#endif /* GTKTTK_GTK_VERSION_3 */ -#ifdef GTKTTK_GTK_VERSION_4 +#endif /* GTTK_GTK_VERSION_3 */ +#ifdef GTTK_GTK_VERSION_4 QStyleOptionFrame option; option.rect = QRect(0, 0, b.width, b.height); option.lineWidth = 1; option.state |= (QStyle::StateFlag) - GtkTtk_StateTableLookup(treeview_client_statemap, state); - wc->GtkTtk_Style->drawPrimitive(QStyle::PE_FrameGroupBox, &option, + gttk_StateTableLookup(treeview_client_statemap, state); + wc->gttk_Style->drawPrimitive(QStyle::PE_FrameGroupBox, &option, &painter); -#endif /* GTKTTK_GTK_VERSION_4 */ +#endif /* GTTK_GTK_VERSION_4 */ #endif // printf("x=%d, y=%d, w=%d, h=%d\n", b.x, b.y, b.width, b.height); - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height, b.x, b.y); - Tcl_MutexUnlock(>kTtkMutex); + Tcl_MutexUnlock(>tkMutex); } static Ttk_ElementSpec TreeViewClientElementSpec = { @@ -197,16 +197,16 @@ static Ttk_ElementSpec TreeViewClientElementSpec = { */ static Ttk_StateTable treeheading_border_statemap[] = { -#ifdef GTKTTK_GTK_VERSION_3 +#ifdef GTTK_GTK_VERSION_3 {QStyle::Style_Enabled|QStyle::Style_Down, TTK_STATE_PRESSED, 0}, {QStyle::Style_Enabled, TTK_STATE_ACTIVE, 0}, {QStyle::Style_Enabled, 0, 0} -#endif /* GTKTTK_GTK_VERSION_3 */ -#ifdef GTKTTK_GTK_VERSION_4 +#endif /* GTTK_GTK_VERSION_3 */ +#ifdef GTTK_GTK_VERSION_4 {QStyle::State_Enabled|QStyle::State_Sunken, TTK_STATE_PRESSED, 0}, {QStyle::State_Enabled, TTK_STATE_ACTIVE, 0}, {QStyle::State_Enabled, 0, 0} -#endif /* GTKTTK_GTK_VERSION_4 */ +#endif /* GTTK_GTK_VERSION_4 */ }; typedef struct { @@ -221,7 +221,7 @@ static void TreeHeadingBorderElementGeometry( void *clientData, void *elementRecord, Tk_Window tkwin, int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr) { - if (!GtkTtk_GtkInitialised()) NO_GTK_STYLE_ENGINE; + if (!gttk_GtkInitialised()) NO_GTK_STYLE_ENGINE; *paddingPtr = Ttk_UniformPadding(TreeViewUniformPadding); } @@ -229,31 +229,31 @@ static void TreeHeadingBorderElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned state) { - if (!GtkTtk_GtkInitialised()) NO_GTK_STYLE_ENGINE; - NULL_PROXY_WIDGET(GtkTtk_QWidget_Widget); - Tcl_MutexLock(>kTtkMutex); + if (!gttk_GtkInitialised()) NO_GTK_STYLE_ENGINE; + NULL_PROXY_WIDGET(gttk_QWidget_Widget); + Tcl_MutexLock(>tkMutex); QPixmap pixmap(b.width, b.height); QPainter painter(&pixmap); - GTKTTK_PAINT_BACKGROUND(b.width, b.height); -#ifdef GTKTTK_GTK_VERSION_3 - QStyle::SFlags sflags = GtkTtk_StateTableLookup(treeheading_border_statemap, + GTTK_PAINT_BACKGROUND(b.width, b.height); +#ifdef GTTK_GTK_VERSION_3 + QStyle::SFlags sflags = gttk_StateTableLookup(treeheading_border_statemap, state); sflags |= QStyle::Style_Horizontal; - wc->GtkTtk_Style->drawPrimitive(QStyle::PE_HeaderSection, &painter, + wc->gttk_Style->drawPrimitive(QStyle::PE_HeaderSection, &painter, QRect(0, 0, b.width, b.height), qApp->palette().active(), sflags); -#endif /* GTKTTK_GTK_VERSION_3 */ -#ifdef GTKTTK_GTK_VERSION_4 +#endif /* GTTK_GTK_VERSION_3 */ +#ifdef GTTK_GTK_VERSION_4 QStyleOptionHeader option; option.rect = QRect(0, 0, b.width, b.height); option.state |= - (QStyle::StateFlag) GtkTtk_StateTableLookup(treeview_client_statemap, state); - wc->GtkTtk_Style->drawControl(QStyle::CE_HeaderSection, &option, + (QStyle::StateFlag) gttk_StateTableLookup(treeview_client_statemap, state); + wc->gttk_Style->drawControl(QStyle::CE_HeaderSection, &option, &painter); -#endif /* GTKTTK_GTK_VERSION_4 */ +#endif /* GTTK_GTK_VERSION_4 */ // printf("x=%d, y=%d, w=%d, h=%d\n", b.x, b.y, b.width, b.height); - GtkTtk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, + gttk_CopyGtkPixmapOnToDrawable(gdkDrawable, d, tkwin, 0, 0, b.width, b.height, b.x, b.y); - Tcl_MutexUnlock(>kTtkMutex); + Tcl_MutexUnlock(>tkMutex); } static Ttk_ElementSpec TreeHeadingBorderElementSpec = { @@ -301,8 +301,8 @@ TTK_BEGIN_LAYOUT(RowLayout) TTK_NODE("Treeitem.row", TTK_FILL_BOTH) TTK_END_LAYOUT -int GtkTtk_Init_TreeView(Tcl_Interp *interp, - GtkTtk_WidgetCache **wc, Ttk_Theme themePtr) +int gttk_Init_TreeView(Tcl_Interp *interp, + gttk_WidgetCache **wc, Ttk_Theme themePtr) { /* * Register elements: @@ -323,4 +323,4 @@ int GtkTtk_Init_TreeView(Tcl_Interp *interp, Ttk_RegisterLayout(themePtr, ROW_LAYOUT, RowLayout); return TCL_OK; -}; /* GtkTtk_Init_TreeView */ +}; /* gttk_Init_TreeView */ diff --git a/generic/gtkTtk_Utilities.cpp b/generic/gttk_Utilities.cpp similarity index 59% rename from generic/gtkTtk_Utilities.cpp rename to generic/gttk_Utilities.cpp index 19224f3..294a54c 100644 --- a/generic/gtkTtk_Utilities.cpp +++ b/generic/gttk_Utilities.cpp @@ -1,8 +1,8 @@ /* - * gtkTtk_Utilities.cpp + * gttk_Utilities.cpp * ---------------------- * - * This file is part of the gtkTtk package, a Tk/Tile based theme that uses + * This file is part of the gttk package, a Tk/Tile based theme that uses * Gtk/GNOME for drawing. * * Copyright (C) 2004-2008 by: @@ -13,176 +13,176 @@ * Aghia Paraskevi, 153 10, Athens, Greece. */ -#include "gtkTtk_GtkHeaders.h" -#include "gtkTtk_TkHeaders.h" -extern gboolean GtkTtk_GtkInitialisedFlag; -extern GtkWidget *GtkTtk_GtkWindow; +#include "gttk_GtkHeaders.h" +#include "gttk_TkHeaders.h" +extern gboolean gttk_GtkInitialisedFlag; +extern GtkWidget *gttk_GtkWindow; -int GtkTtk_GtkInitialised(void) { - return GtkTtk_GtkInitialisedFlag; -}; /* GtkTtk_GtkInitialised */ +int gttk_GtkInitialised(void) { + return gttk_GtkInitialisedFlag; +}; /* gttk_GtkInitialised */ -GtkWidget *GtkTtk_GetGtkWindow(void) { - return GtkTtk_GtkWindow; -}; /* GtkTtk_GetGtkWindow */ +GtkWidget *gttk_GetGtkWindow(void) { + return gttk_GtkWindow; +}; /* gttk_GetGtkWindow */ -GtkStyle *GtkTtk_GetGtkWindowStyle(GtkWidget *gtkWindow) { +GtkStyle *gttk_GetGtkWindowStyle(GtkWidget *gtkWindow) { if (gtkWindow) { return gtkWindow->style; } return NULL; -}; /* GtkTtk_GetGtkWindowStyle */ +}; /* gttk_GetGtkWindowStyle */ -GtkStyle *GtkTtk_GetGtkStyle(void) { - return GtkTtk_GetGtkWindowStyle(GtkTtk_GetGtkWindow()); -}; /* GtkTtk_GetGtkStyle */ +GtkStyle *gttk_GetGtkStyle(void) { + return gttk_GetGtkWindowStyle(gttk_GetGtkWindow()); +}; /* gttk_GetGtkStyle */ -void GtkTtk_InitialiseGtkWidget(GtkTtk_WidgetCache* wc, GtkWidget* widget) { +void gttk_InitialiseGtkWidget(gttk_WidgetCache* wc, GtkWidget* widget) { // GtkStyle *style; if (!wc || !widget) return; if (!wc->protoLayout) { - wc->protoLayout = GtkTtk_gtk_fixed_new(); - GtkTtk_gtk_container_add((GtkContainer*)(wc->gtkWindow), wc->protoLayout); + wc->protoLayout = gttk_gtk_fixed_new(); + gttk_gtk_container_add((GtkContainer*)(wc->gtkWindow), wc->protoLayout); } if (!wc->protoLayout) return; - GtkTtk_gtk_container_add((GtkContainer*)(wc->protoLayout), widget); - GtkTtk_gtk_widget_realize(widget); - // style = GtkTtk_gtk_rc_get_style(widget); - // if (style) GtkTtk_gtk_style_attach(style, -}; /* GtkTtk_InitialiseGtkWidget */ + gttk_gtk_container_add((GtkContainer*)(wc->protoLayout), widget); + gttk_gtk_widget_realize(widget); + // style = gttk_gtk_rc_get_style(widget); + // if (style) gttk_gtk_style_attach(style, +}; /* gttk_InitialiseGtkWidget */ -#define GTKTTK_CHECK_WIDGET(widget, allocator_function) \ +#define GTTK_CHECK_WIDGET(widget, allocator_function) \ if (!wc) return 0; \ if (!wc->widget) { \ wc->widget = allocator_function; \ - GtkTtk_InitialiseGtkWidget(wc, wc->widget); \ + gttk_InitialiseGtkWidget(wc, wc->widget); \ return wc->widget; \ } \ return wc->widget; -GtkWidget *GtkTtk_GetArrow(GtkTtk_WidgetCache* wc) { - GTKTTK_CHECK_WIDGET(gtkArrow, - GtkTtk_gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_NONE)); -}; /* GtkTtk_GetButton */ +GtkWidget *gttk_GetArrow(gttk_WidgetCache* wc) { + GTTK_CHECK_WIDGET(gtkArrow, + gttk_gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_NONE)); +}; /* gttk_GetButton */ -GtkWidget *GtkTtk_GetButton(GtkTtk_WidgetCache* wc) { - GTKTTK_CHECK_WIDGET(gtkButton, GtkTtk_gtk_button_new()); -}; /* GtkTtk_GetButton */ +GtkWidget *gttk_GetButton(gttk_WidgetCache* wc) { + GTTK_CHECK_WIDGET(gtkButton, gttk_gtk_button_new()); +}; /* gttk_GetButton */ -GtkWidget *GtkTtk_GetCheckButton(GtkTtk_WidgetCache* wc) { - GTKTTK_CHECK_WIDGET(gtkCheckButton, GtkTtk_gtk_check_button_new()); -}; /* GtkTtk_GetCheckButton */ +GtkWidget *gttk_GetCheckButton(gttk_WidgetCache* wc) { + GTTK_CHECK_WIDGET(gtkCheckButton, gttk_gtk_check_button_new()); +}; /* gttk_GetCheckButton */ -GtkWidget *GtkTtk_GetRadioButton(GtkTtk_WidgetCache* wc) { - return GtkTtk_GetCheckButton(wc); -}; /* GtkTtk_GetRadioButton */ +GtkWidget *gttk_GetRadioButton(gttk_WidgetCache* wc) { + return gttk_GetCheckButton(wc); +}; /* gttk_GetRadioButton */ -GtkWidget *GtkTtk_GetToolBar(GtkTtk_WidgetCache* wc) { - GTKTTK_CHECK_WIDGET(gtkToolBar, GtkTtk_gtk_toolbar_new()); -}; /* GtkTtk_GetToolBar */ +GtkWidget *gttk_GetToolBar(gttk_WidgetCache* wc) { + GTTK_CHECK_WIDGET(gtkToolBar, gttk_gtk_toolbar_new()); +}; /* gttk_GetToolBar */ -GtkWidget *GtkTtk_GetToolButton(GtkTtk_WidgetCache* wc) { - GTKTTK_CHECK_WIDGET(gtkToolButton, GtkTtk_gtk_button_new()); -}; /* GtkTtk_GetToolButton */ +GtkWidget *gttk_GetToolButton(gttk_WidgetCache* wc) { + GTTK_CHECK_WIDGET(gtkToolButton, gttk_gtk_button_new()); +}; /* gttk_GetToolButton */ -GtkWidget *GtkTtk_GetFrame(GtkTtk_WidgetCache* wc) { - GTKTTK_CHECK_WIDGET(gtkFrame, GtkTtk_gtk_frame_new(NULL)); -}; /* GtkTtk_GetFrame */ +GtkWidget *gttk_GetFrame(gttk_WidgetCache* wc) { + GTTK_CHECK_WIDGET(gtkFrame, gttk_gtk_frame_new(NULL)); +}; /* gttk_GetFrame */ -GtkWidget *GtkTtk_GetEntry(GtkTtk_WidgetCache* wc) { - GTKTTK_CHECK_WIDGET(gtkEntry, GtkTtk_gtk_entry_new()); -}; /* GtkTtk_GetEntry */ +GtkWidget *gttk_GetEntry(gttk_WidgetCache* wc) { + GTTK_CHECK_WIDGET(gtkEntry, gttk_gtk_entry_new()); +}; /* gttk_GetEntry */ -GtkWidget *GtkTtk_GetCombobox(GtkTtk_WidgetCache* wc) { - GTKTTK_CHECK_WIDGET(gtkCombobox, GtkTtk_gtk_combo_box_new()); -}; /* GtkTtk_GetComboboxEntry */ +GtkWidget *gttk_GetCombobox(gttk_WidgetCache* wc) { + GTTK_CHECK_WIDGET(gtkCombobox, gttk_gtk_combo_box_new()); +}; /* gttk_GetComboboxEntry */ -GtkWidget *GtkTtk_GetComboboxEntry(GtkTtk_WidgetCache* wc) { - GTKTTK_CHECK_WIDGET(gtkComboboxEntry, GtkTtk_gtk_combo_box_entry_new()); -}; /* GtkTtk_GetComboboxEntry */ +GtkWidget *gttk_GetComboboxEntry(gttk_WidgetCache* wc) { + GTTK_CHECK_WIDGET(gtkComboboxEntry, gttk_gtk_combo_box_entry_new()); +}; /* gttk_GetComboboxEntry */ -GtkWidget *GtkTtk_GetHScrollBar(GtkTtk_WidgetCache* wc) { +GtkWidget *gttk_GetHScrollBar(gttk_WidgetCache* wc) { GtkAdjustment *adjustment = (GtkAdjustment *) - GtkTtk_gtk_adjustment_new(0.0, 0.0, 1.0, 0, 0, 0); - GTKTTK_CHECK_WIDGET(gtkHScrollBar, GtkTtk_gtk_hscrollbar_new(adjustment)); -}; /* GtkTtk_GetHScrollBar */ + gttk_gtk_adjustment_new(0.0, 0.0, 1.0, 0, 0, 0); + GTTK_CHECK_WIDGET(gtkHScrollBar, gttk_gtk_hscrollbar_new(adjustment)); +}; /* gttk_GetHScrollBar */ -GtkWidget *GtkTtk_GetVScrollBar(GtkTtk_WidgetCache* wc) { +GtkWidget *gttk_GetVScrollBar(gttk_WidgetCache* wc) { GtkAdjustment *adjustment = (GtkAdjustment *) - GtkTtk_gtk_adjustment_new(0.0, 0.0, 1.0, 0, 0, 0); - GTKTTK_CHECK_WIDGET(gtkVScrollBar, GtkTtk_gtk_vscrollbar_new(adjustment)); -}; /* GtkTtk_GetVScrollBar */ + gttk_gtk_adjustment_new(0.0, 0.0, 1.0, 0, 0, 0); + GTTK_CHECK_WIDGET(gtkVScrollBar, gttk_gtk_vscrollbar_new(adjustment)); +}; /* gttk_GetVScrollBar */ -GtkWidget *GtkTtk_GetScrollBar(GtkTtk_WidgetCache* wc) { +GtkWidget *gttk_GetScrollBar(gttk_WidgetCache* wc) { if (wc->orientation == TTK_ORIENT_HORIZONTAL) { - return GtkTtk_GetHScrollBar(wc); + return gttk_GetHScrollBar(wc); } - return GtkTtk_GetVScrollBar(wc); -}; /* GtkTtk_GetScrollBar */ + return gttk_GetVScrollBar(wc); +}; /* gttk_GetScrollBar */ -GtkWidget *GtkTtk_GetHScale(GtkTtk_WidgetCache* wc) { - GTKTTK_CHECK_WIDGET(gtkHScale, GtkTtk_gtk_hscale_new_with_range(0,1,0.001)); -}; /* GtkTtk_GetHScale */ +GtkWidget *gttk_GetHScale(gttk_WidgetCache* wc) { + GTTK_CHECK_WIDGET(gtkHScale, gttk_gtk_hscale_new_with_range(0,1,0.001)); +}; /* gttk_GetHScale */ -GtkWidget *GtkTtk_GetVScale(GtkTtk_WidgetCache* wc) { - GTKTTK_CHECK_WIDGET(gtkVScale, GtkTtk_gtk_vscale_new_with_range(0,1,0.001)); -}; /* GtkTtk_GetVScale */ +GtkWidget *gttk_GetVScale(gttk_WidgetCache* wc) { + GTTK_CHECK_WIDGET(gtkVScale, gttk_gtk_vscale_new_with_range(0,1,0.001)); +}; /* gttk_GetVScale */ -GtkWidget *GtkTtk_GetScale(GtkTtk_WidgetCache* wc) { +GtkWidget *gttk_GetScale(gttk_WidgetCache* wc) { if (wc->orientation == TTK_ORIENT_HORIZONTAL) { - return GtkTtk_GetHScale(wc); + return gttk_GetHScale(wc); } - return GtkTtk_GetVScale(wc); -}; /* GtkTtk_GetScale */ + return gttk_GetVScale(wc); +}; /* gttk_GetScale */ -GtkWidget *GtkTtk_GetHProgressBar(GtkTtk_WidgetCache* wc) { - GTKTTK_CHECK_WIDGET(gtkHProgressBar, GtkTtk_gtk_progress_bar_new()); - GtkTtk_gtk_progress_bar_set_orientation( +GtkWidget *gttk_GetHProgressBar(gttk_WidgetCache* wc) { + GTTK_CHECK_WIDGET(gtkHProgressBar, gttk_gtk_progress_bar_new()); + gttk_gtk_progress_bar_set_orientation( (GtkProgressBar*) wc->gtkHProgressBar, GTK_PROGRESS_LEFT_TO_RIGHT); - GtkTtk_gtk_progress_bar_set_fraction( + gttk_gtk_progress_bar_set_fraction( (GtkProgressBar *) wc->gtkHProgressBar, 1); -}; /* GtkTtk_GetHProgressBar */ +}; /* gttk_GetHProgressBar */ -GtkWidget *GtkTtk_GetVProgressBar(GtkTtk_WidgetCache* wc) { - GTKTTK_CHECK_WIDGET(gtkVProgressBar, GtkTtk_gtk_progress_bar_new()); - GtkTtk_gtk_progress_bar_set_orientation( +GtkWidget *gttk_GetVProgressBar(gttk_WidgetCache* wc) { + GTTK_CHECK_WIDGET(gtkVProgressBar, gttk_gtk_progress_bar_new()); + gttk_gtk_progress_bar_set_orientation( (GtkProgressBar*) wc->gtkVProgressBar, GTK_PROGRESS_BOTTOM_TO_TOP); - GtkTtk_gtk_progress_bar_set_fraction( + gttk_gtk_progress_bar_set_fraction( (GtkProgressBar *) wc->gtkVProgressBar, 1); -}; /* GtkTtk_GetVProgressBar */ +}; /* gttk_GetVProgressBar */ -GtkWidget *GtkTtk_GetProgressBar(GtkTtk_WidgetCache* wc) { +GtkWidget *gttk_GetProgressBar(gttk_WidgetCache* wc) { if (wc->orientation == TTK_ORIENT_HORIZONTAL) { - return GtkTtk_GetHProgressBar(wc); + return gttk_GetHProgressBar(wc); } - return GtkTtk_GetVProgressBar(wc); -}; /* GtkTtk_GetProgressBar */ + return gttk_GetVProgressBar(wc); +}; /* gttk_GetProgressBar */ -GtkWidget *GtkTtk_GetStatusBar(GtkTtk_WidgetCache* wc) { - GTKTTK_CHECK_WIDGET(gtkStatusBar, GtkTtk_gtk_statusbar_new()); -}; /* GtkTtk_GetStatusBar */ +GtkWidget *gttk_GetStatusBar(gttk_WidgetCache* wc) { + GTTK_CHECK_WIDGET(gtkStatusBar, gttk_gtk_statusbar_new()); +}; /* gttk_GetStatusBar */ -GtkWidget *GtkTtk_GetHPaned(GtkTtk_WidgetCache* wc) { - GTKTTK_CHECK_WIDGET(gtkHPaned, GtkTtk_gtk_hpaned_new()); -}; /* GtkTtk_GetHPaned */ +GtkWidget *gttk_GetHPaned(gttk_WidgetCache* wc) { + GTTK_CHECK_WIDGET(gtkHPaned, gttk_gtk_hpaned_new()); +}; /* gttk_GetHPaned */ -GtkWidget *GtkTtk_GetVPaned(GtkTtk_WidgetCache* wc) { - GTKTTK_CHECK_WIDGET(gtkVPaned, GtkTtk_gtk_vpaned_new()); -}; /* GtkTtk_GetVPaned */ +GtkWidget *gttk_GetVPaned(gttk_WidgetCache* wc) { + GTTK_CHECK_WIDGET(gtkVPaned, gttk_gtk_vpaned_new()); +}; /* gttk_GetVPaned */ -GtkWidget *GtkTtk_GetPaned(GtkTtk_WidgetCache* wc) { +GtkWidget *gttk_GetPaned(gttk_WidgetCache* wc) { if (wc->orientation == TTK_ORIENT_HORIZONTAL) { - return GtkTtk_GetHPaned(wc); + return gttk_GetHPaned(wc); } - return GtkTtk_GetVPaned(wc); -}; /* GtkTtk_GetPaned */ + return gttk_GetVPaned(wc); +}; /* gttk_GetPaned */ -GtkWidget *GtkTtk_GetNotebook(GtkTtk_WidgetCache* wc) { - GTKTTK_CHECK_WIDGET(gtkNotebook, GtkTtk_gtk_notebook_new()); -}; /* GtkTtk_GetNotebook */ +GtkWidget *gttk_GetNotebook(gttk_WidgetCache* wc) { + GTTK_CHECK_WIDGET(gtkNotebook, gttk_gtk_notebook_new()); +}; /* gttk_GetNotebook */ -const char *GtkTtk_GtkStateStr(GtkStateType gtkState) { +const char *gttk_GtkStateStr(GtkStateType gtkState) { switch ((GtkStateType) gtkState) { case GTK_STATE_NORMAL: return "GTK_STATE_NORMAL"; case GTK_STATE_ACTIVE: return "GTK_STATE_ACTIVE"; @@ -191,8 +191,8 @@ const char *GtkTtk_GtkStateStr(GtkStateType gtkState) { case GTK_STATE_INSENSITIVE: return "GTK_STATE_INSENSITIVE"; } return "invalid!"; -}; /* GtkTtk_GtkStateStr */ -const char *GtkTtk_GtkShadowStr(GtkShadowType gtkShadow) { +}; /* gttk_GtkStateStr */ +const char *gttk_GtkShadowStr(GtkShadowType gtkShadow) { switch ((GtkShadowType) gtkShadow) { case GTK_SHADOW_NONE: return "GTK_SHADOW_NONE"; case GTK_SHADOW_IN: return "GTK_SHADOW_IN"; @@ -201,9 +201,9 @@ const char *GtkTtk_GtkShadowStr(GtkShadowType gtkShadow) { case GTK_SHADOW_ETCHED_OUT: return "GTK_SHADOW_ETCHED_OUT"; } return "invalid!"; -}; /* GtkTtk_GtkShadowStr */ +}; /* gttk_GtkShadowStr */ -void GtkTtk_StateInfo(int state, GtkStateType gtkState, +void gttk_StateInfo(int state, GtkStateType gtkState, GtkShadowType gtkShadow, Tk_Window tkwin, GtkWidget *widget) { printf("Widget: %s\n ", Tk_PathName(tkwin)); @@ -259,18 +259,18 @@ void GtkTtk_StateInfo(int state, GtkStateType gtkState, #endif /* TTK_STATE_USER7 */ printf(" state=%d\n", state); printf(" GTK state: %s, shadow: %s", - GtkTtk_GtkStateStr(gtkState), GtkTtk_GtkShadowStr(gtkShadow)); -#ifndef GTKTTK_LOAD_GTK_DYNAMICALLY + gttk_GtkStateStr(gtkState), gttk_GtkShadowStr(gtkShadow)); +#ifndef GTTK_LOAD_GTK_DYNAMICALLY if (widget) { printf(", focus: %d, default: %d", GTK_WIDGET_HAS_FOCUS(widget), GTK_WIDGET_HAS_DEFAULT(widget)); } -#endif /* GTKTTK_LOAD_GTK_DYNAMICALLY */ +#endif /* GTTK_LOAD_GTK_DYNAMICALLY */ printf("\n"); fflush(0); -}; /* GtkTtk_StateInfo */ +}; /* gttk_StateInfo */ -void GtkTtk_CopyGtkPixmapOnToDrawable(GdkPixmap *gdkDrawable, Drawable d, +void gttk_CopyGtkPixmapOnToDrawable(GdkPixmap *gdkDrawable, Drawable d, Tk_Window tkwin, int x, int y, int w, int h, int x1, int x2) { #ifdef __WIN32__ @@ -280,19 +280,19 @@ void GtkTtk_CopyGtkPixmapOnToDrawable(GdkPixmap *gdkDrawable, Drawable d, gcValues.graphics_exposures = False; GC gc = Tk_GetGC(tkwin, GCForeground | GCBackground | GCGraphicsExposures, &gcValues); - GdkGC *gdkGC = GtkTtk_gdk_gc_new(gdkDrawable); - HDC hdcSrc = GtkTtk_gdk_win32_hdc_get(gdkDrawable, gdkGC, gc_usage); + GdkGC *gdkGC = gttk_gdk_gc_new(gdkDrawable); + HDC hdcSrc = gdk_win32_hdc_get(gdkDrawable, gdkGC, gc_usage); /* Create a Tk Drawable from the HDC... */ TkWinDrawable gtkD; gtkD.type = TWD_WINDC; gtkD.winDC.hdc = hdcSrc; XCopyArea(Tk_Display(tkwin), (Drawable) >kD, d, gc, x, y, w, h, x1, x2); - GtkTtk_gdk_win32_hdc_release(gdkDrawable, gdkGC, gc_usage); - if (gdkGC) GtkTtk_g_object_unref(gdkGC); + gdk_win32_hdc_release(gdkDrawable, gdkGC, gc_usage); + if (gdkGC) gttk_g_object_unref(gdkGC); Tk_FreeGC(Tk_Display(tkwin), gc); #else -#ifdef GTKTTK_USE_XCOPY +#ifdef GTTK_USE_XCOPY XGCValues gcValues; gcValues.graphics_exposures = False; GC gc = Tk_GetGC(tkwin, GCForeground | GCBackground | GCGraphicsExposures, @@ -319,16 +319,16 @@ void GtkTtk_CopyGtkPixmapOnToDrawable(GdkPixmap *gdkDrawable, Drawable d, gcValues.graphics_exposures = False; GC gc = Tk_GetGC(tkwin, GCForeground | GCBackground | GCGraphicsExposures, &gcValues); - imgb = GtkTtk_gdk_pixbuf_new(GDK_COLORSPACE_RGB, true, 8, w, h); + imgb = gttk_gdk_pixbuf_new(GDK_COLORSPACE_RGB, true, 8, w, h); if (!imgb) { Tk_FreeGC(Tk_Display(tkwin), gc); return; } - imgb = GtkTtk_gdk_pixbuf_get_from_drawable(imgb, gdkDrawable, + imgb = gttk_gdk_pixbuf_get_from_drawable(imgb, gdkDrawable, NULL, x, y, 0, 0, w, h); - GtkTtk_gdk_pixbuf_xlib_render_to_drawable(imgb, d, gc, + gttk_gdk_pixbuf_xlib_render_to_drawable(imgb, d, gc, 0, 0, x1, x2, w, h, XLIB_RGB_DITHER_MAX, 0, 0); - GtkTtk_gdk_pixbuf_unref(imgb); + gttk_gdk_pixbuf_unref(imgb); Tk_FreeGC(Tk_Display(tkwin), gc); #endif @@ -339,37 +339,37 @@ void GtkTtk_CopyGtkPixmapOnToDrawable(GdkPixmap *gdkDrawable, Drawable d, GtkStyle *style = NULL; \ GdkScreen *screen = NULL; \ GdkColormap *cmap = NULL; \ - screen = GtkTtk_gdk_display_get_screen(wc->gdkDisplay, \ + screen = gttk_gdk_display_get_screen(wc->gdkDisplay, \ Tk_ScreenNumber(tkwin)); \ printf("Widget: %s, d=%d, p=%p\n", Tk_PathName(tkwin), d, \ gdk_xid_table_lookup((XID) d));fflush(0); \ - gdkDrawable = GtkTtk_gdk_pixmap_foreign_new_for_screen(screen, d, \ + gdkDrawable = gttk_gdk_pixmap_foreign_new_for_screen(screen, d, \ Tk_Width(tkwin), Tk_Height(tkwin), \ DefaultDepthOfScreen(Tk_Screen(tkwin))); \ if (!gdkDrawable) return; \ - GdkVisual *visual = GtkTtk_gdk_x11_screen_lookup_visual(screen, + GdkVisual *visual = gttk_gdk_x11_screen_lookup_visual(screen, XVisualIDFromVisual(Tk_Visual(tkwin))); \ - cmap = GtkTtk_gdk_x11_colormap_foreign_new(visual, Tk_Colormap(tkwin)); \ - GtkTtk_gdk_drawable_set_colormap(gdkDrawable, cmap);\ + cmap = gttk_gdk_x11_colormap_foreign_new(visual, Tk_Colormap(tkwin)); \ + gttk_gdk_drawable_set_colormap(gdkDrawable, cmap);\ printf("d=%d, gdkDrawable=%p, XID=%d, p=%p\n", d, gdkDrawable, \ gdk_x11_drawable_get_xid(gdkDrawable), \ gdk_xid_table_lookup((XID) d));fflush(0); */ #endif -}; /* GtkTtk_CopyGtkPixmapOnToDrawable */ +}; /* gttk_CopyGtkPixmapOnToDrawable */ -void GtkTtk_StoreStyleNameLowers(GtkTtk_WidgetCache *wc) { -}; /* GtkTtk_StoreStyleName */ +void gttk_StoreStyleNameLowers(gttk_WidgetCache *wc) { +}; /* gttk_StoreStyleName */ -bool GtkTtk_ThemeIs(GtkTtk_WidgetCache *wc, const char* name) { +bool gttk_ThemeIs(gttk_WidgetCache *wc, const char* name) { return false; -}; /* GtkTtk_ThemeIs */ +}; /* gttk_ThemeIs */ /* - * GtkTtk_StateTableLookup -- + * gttk_StateTableLookup -- * Look up an index from a statically allocated state table. */ -unsigned int GtkTtk_StateTableLookup(Ttk_StateTable *map, unsigned int state) { +unsigned int gttk_StateTableLookup(Ttk_StateTable *map, unsigned int state) { return Ttk_StateTableLookup(map, state); int value = 0; while (map->onBits || map->offBits) { @@ -377,7 +377,7 @@ unsigned int GtkTtk_StateTableLookup(Ttk_StateTable *map, unsigned int state) { ++map; } return value; -}; /* GtkTtk_StateTableLookup */ +}; /* gttk_StateTableLookup */ /* * GTK_STATE_NORMAL: State during normal operation. @@ -406,32 +406,32 @@ unsigned int GtkTtk_StateTableLookup(Ttk_StateTable *map, unsigned int state) { * TTK_STATE_INVALID * TTK_STATE_READONLY */ -unsigned int GtkTtk_StateShadowTableLookup(GtkTtk_StateTable *map, +unsigned int gttk_StateShadowTableLookup(gttk_StateTable *map, unsigned int state, GtkStateType& gtkState, GtkShadowType& gtkShadow, unsigned int section) { - static GtkTtk_StateTable default_map[] = { + static gttk_StateTable default_map[] = { /* Section for: Buttons */ /* Section common to all widgets */ {GTK_STATE_ACTIVE, GTK_SHADOW_NONE, 0, - TTK_STATE_ACTIVE, 0, GTKTTK_SECTION_ALL}, + TTK_STATE_ACTIVE, 0, GTTK_SECTION_ALL}, {GTK_STATE_INSENSITIVE, GTK_SHADOW_NONE, 0, - TTK_STATE_DISABLED, 0, GTKTTK_SECTION_ALL}, + TTK_STATE_DISABLED, 0, GTTK_SECTION_ALL}, {GTK_STATE_PRELIGHT, GTK_SHADOW_NONE, 0, - TTK_STATE_FOCUS, 0, GTKTTK_SECTION_ALL}, + TTK_STATE_FOCUS, 0, GTTK_SECTION_ALL}, {GTK_STATE_SELECTED, GTK_SHADOW_NONE, 0, - TTK_STATE_PRESSED, 0, GTKTTK_SECTION_ALL}, + TTK_STATE_PRESSED, 0, GTTK_SECTION_ALL}, {GTK_STATE_SELECTED, GTK_SHADOW_NONE, 0, - TTK_STATE_SELECTED, 0, GTKTTK_SECTION_ALL}, + TTK_STATE_SELECTED, 0, GTTK_SECTION_ALL}, {GTK_STATE_NORMAL, GTK_SHADOW_NONE, 0, - TTK_STATE_BACKGROUND, 0, GTKTTK_SECTION_ALL}, + TTK_STATE_BACKGROUND, 0, GTTK_SECTION_ALL}, {GTK_STATE_NORMAL, GTK_SHADOW_NONE, 0, - TTK_STATE_ALTERNATE, 0, GTKTTK_SECTION_ALL}, + TTK_STATE_ALTERNATE, 0, GTTK_SECTION_ALL}, {GTK_STATE_INSENSITIVE, GTK_SHADOW_NONE, 0, - TTK_STATE_INVALID, 0, GTKTTK_SECTION_ALL}, + TTK_STATE_INVALID, 0, GTTK_SECTION_ALL}, {GTK_STATE_INSENSITIVE, GTK_SHADOW_NONE, 0, - TTK_STATE_READONLY, 0, GTKTTK_SECTION_ALL}, + TTK_STATE_READONLY, 0, GTTK_SECTION_ALL}, {GTK_STATE_NORMAL, GTK_SHADOW_NONE, 0, - 0, 0, GTKTTK_SECTION_ALL} + 0, 0, GTTK_SECTION_ALL} }; unsigned int value = 0; gtkState = GTK_STATE_NORMAL; @@ -439,7 +439,7 @@ unsigned int GtkTtk_StateShadowTableLookup(GtkTtk_StateTable *map, if (!map) { map = default_map; /* Instead of writting huge tables, do some checks here... */ - if (section & GTKTTK_SECTION_STEPPERS) { + if (section & GTTK_SECTION_STEPPERS) { gtkShadow = GTK_SHADOW_OUT; if (state & TTK_STATE_DISABLED) { gtkState = GTK_STATE_INSENSITIVE; @@ -450,24 +450,26 @@ unsigned int GtkTtk_StateShadowTableLookup(GtkTtk_StateTable *map, gtkState = GTK_STATE_PRELIGHT; } map = NULL; /* Do not search the table */ - } else if (section & GTKTTK_SECTION_BUTTONS || - section & GTKTTK_SECTION_ENTRY || - section & GTKTTK_SECTION_SCROLLBAR) { + } else if (section & GTTK_SECTION_BUTTONS || + section & GTTK_SECTION_ENTRY || + section & GTTK_SECTION_SCROLLBAR) { /* Whether the button is drawn pressed or not, is defined by shadow. */ if (state & TTK_STATE_PRESSED || state & TTK_STATE_SELECTED) { gtkShadow = GTK_SHADOW_IN; } else { gtkShadow = GTK_SHADOW_OUT; - // if (state & TTK_STATE_DISABLED || state & TTK_STATE_READONLY) - // gtkState = GTK_STATE_INSENSITIVE; + if (state & TTK_STATE_DISABLED || state & TTK_STATE_READONLY) + gtkState = GTK_STATE_INSENSITIVE; // else if (state & TTK_STATE_ACTIVE) gtkState = GTK_STATE_PRELIGHT; // else if (state & TTK_STATE_FOCUS) gtkState = GTK_STATE_ACTIVE; } + if ((section & GTTK_SECTION_ENTRY) && (state & TTK_STATE_FOCUS)) + gtkState = GTK_STATE_ACTIVE; if ((state & TTK_STATE_ACTIVE) && (!(state & TTK_STATE_PRESSED) && !(state & TTK_STATE_SELECTED))) { gtkState = GTK_STATE_PRELIGHT; } else { - if (!(section & GTKTTK_SECTION_SCROLLBAR) && + if (!(section & GTTK_SECTION_SCROLLBAR) && state & TTK_STATE_DISABLED || state & TTK_STATE_READONLY) gtkState = GTK_STATE_INSENSITIVE; else if (state & TTK_STATE_PRESSED) gtkState = GTK_STATE_ACTIVE; @@ -475,7 +477,7 @@ unsigned int GtkTtk_StateShadowTableLookup(GtkTtk_StateTable *map, gtkState = GTK_STATE_INSENSITIVE; } map = NULL; /* Do not search the table */ - } else if (section & GTKTTK_SECTION_TROUGH) { + } else if (section & GTTK_SECTION_TROUGH) { if (state & TTK_STATE_PRESSED) { gtkState = GTK_STATE_ACTIVE; } else { @@ -483,13 +485,13 @@ unsigned int GtkTtk_StateShadowTableLookup(GtkTtk_StateTable *map, } gtkShadow = GTK_SHADOW_IN; map = NULL; /* Do not search the table */ - } else if (section & GTKTTK_SECTION_SASH) { + } else if (section & GTTK_SECTION_SASH) { if (state & TTK_STATE_DISABLED || state & TTK_STATE_READONLY) gtkState = GTK_STATE_INSENSITIVE; else if (state & TTK_STATE_FOCUS) gtkState = GTK_STATE_SELECTED; else if (state & TTK_STATE_ACTIVE) gtkState = GTK_STATE_PRELIGHT; map = NULL; /* Do not search the table */ - } else if (section & GTKTTK_SECTION_TABS) { + } else if (section & GTTK_SECTION_TABS) { gtkState = GTK_STATE_ACTIVE; gtkShadow = GTK_SHADOW_OUT; if (state & TTK_STATE_DISABLED || state & TTK_STATE_READONLY) @@ -510,9 +512,9 @@ unsigned int GtkTtk_StateShadowTableLookup(GtkTtk_StateTable *map, gtkShadow = map->shadow; } return (map)? map->value : value; -}; /* GtkTtk_StateShadowTableLookup */ +}; /* gttk_StateShadowTableLookup */ -double GtkTtk_ValueFromSlider(GtkTtk_WidgetCache *wc, Tk_Window tkwin, +double gttk_ValueFromSlider(gttk_WidgetCache *wc, Tk_Window tkwin, Ttk_Box b) { double value = 0.0; double ww = Tk_Width(tkwin), wh = Tk_Height(tkwin), dx = 0.0, x; @@ -529,4 +531,4 @@ double GtkTtk_ValueFromSlider(GtkTtk_WidgetCache *wc, Tk_Window tkwin, if (value > 1.0) value = 1.0; // printf("ww:%f, b.x:%d, x:%f, dx:%f, v:%f\n", ww, b.x, x, dx, value); return value; -}; /* GtkTtk_ValueFromSlider */ +}; /* gttk_ValueFromSlider */ diff --git a/generic/gttk_Utilities.h b/generic/gttk_Utilities.h new file mode 100644 index 0000000..917b104 --- /dev/null +++ b/generic/gttk_Utilities.h @@ -0,0 +1,193 @@ +/* + * gttk_Utilities.h + * ---------------------- + * + * This file is part of the gttk package, a Tk/Tile based theme that uses + * Gtk/GNOME for drawing. + * + * Copyright (C) 2004-2008 by: + * Georgios Petasis, petasis@iit.demokritos.gr, + * Software and Knowledge Engineering Laboratory, + * Institute of Informatics and Telecommunications, + * National Centre for Scientific Research (NCSR) "Demokritos", + * Aghia Paraskevi, 153 10, Athens, Greece. + */ + +#include "gttk_GtkHeaders.h" +#include "gttk_Elements.h" +#include + +#define NO_GTK_STYLE_ENGINE {/*printf("NULL qApp\n");fflush(NULL);*/return;} + +#define GTTK_ENSURE_GTK_STYLE_ENGINE_ACTIVE \ + if (!gttk_GtkInitialised()) return; + +#define GTTK_ENSURE_WIDGET_OK \ + if (!widget) return; + +#define GTTK_ATTACH_STYLE_TO_WIDGET \ + style = gttk_gtk_style_attach(style, widget->window); + +#define GTTK_WIDGET_CACHE_DEFINITION \ + gttk_WidgetCache *wc = (gttk_WidgetCache *) clientData; + +#define GTTK_ORIENTATION_DEFINITION \ + int orientation = wc->orientation; + +#define GTTK_GTK_DRAWABLE_DEFINITIONS \ + gttk_WidgetCache *wc = (gttk_WidgetCache *) clientData; \ + GdkPixmap *gdkDrawable = NULL; \ + GtkStyle *style = NULL; \ + GtkStateType gtkState = GTK_STATE_NORMAL; \ + GtkShadowType gtkShadow = GTK_SHADOW_NONE; + +#define GTTK_SETUP_GTK_DRAWABLE \ + GTTK_SETUP_GTK_DRAWABLE_PIXMAP_SIZE(b.width, b.height) + +#define GTTK_SETUP_GTK_DRAWABLE_PIXMAP_SIZE(pw, ph) \ + if (!wc) return; \ + style = gttk_GetGtkWindowStyle(wc->gtkWindow); \ + if (!style) return; \ + gdkDrawable = gttk_gdk_pixmap_new(wc->gtkWindow->window, pw, ph, -1); \ + style = gttk_GetGtkWindowStyle(wc->gtkWindow); + +#define GTTK_STYLE_BACKGROUND_DEFAULT \ + if (wc && wc->gtkWindow) style = gttk_GetGtkWindowStyle(wc->gtkWindow); \ + if (!style) return; + +#define GTTK_STYLE_FROM_WIDGET \ + style = gttk_GetGtkWindowStyle(widget); \ + if (!style) style = gttk_GetGtkWindowStyle(wc->gtkWindow); \ + if (!style) return; + +#define GTTK_DRAWABLE_FROM_WIDGET_SIZE(pw, ph) \ + gdkDrawable = gttk_gdk_pixmap_new(widget->window, pw, ph, -1); + +#define GTTK_DRAWABLE_FROM_WIDGET \ + GTTK_DRAWABLE_FROM_WIDGET_SIZE(b.width, b.height) + +// #define GTTK_DRAWABLE_FROM_WIDGET \ +// gdkDrawable = gdk_pixmap_foreign_new(Tk_WindowId(tkwin)); \ +// GdkColormap gdkColormap = gdk_x11_colormap_foreign_new(gdkx_visual_get(Tk_Visual(tkwin)), Tk_Colormap(tkwin)); \ +// gdk_drawable_set_colormap(gdkDrawable, gdkColormap); + +#define GTTK_DEFAULT_BACKGROUND_SIZE(pw, ph) \ + gttk_gtk_style_apply_default_background(style, gdkDrawable, TRUE, \ + gtkState, NULL, 0, 0, pw, ph); + +#define GTTK_DEFAULT_BACKGROUND \ + GTTK_DEFAULT_BACKGROUND_SIZE(b.width, b.height) + +#define GTTK_CLEANUP_GTK_DRAWABLE \ + if (gdkDrawable) gttk_g_object_unref(gdkDrawable); + +#define GTTK_SETUP_STATE_SHADOW(statemap, shadowmap) \ + gtkState = (GtkStateType) \ + gttk_StateTableLookup(statemap, state); \ + gtkShadow = (GtkShadowType) \ + gttk_StateTableLookup(shadowmap, state); + +#define GTTK_SETUP_WIDGET_SIZE(width, height) \ + gttk_gtk_widget_set_size_request(widget, width, height); + +#define GTTK_GET_WIDGET_SIZE(widthPtr, heightPtr) \ + if (widget) { \ + GtkRequisition size; \ + gttk_gtk_widget_size_request(widget, &size); \ + widthPtr = size.width; \ + heightPtr = size.height; \ + } + +#define GTTK_WIDGET_SETUP_DEFAULT(obj) \ + int defaultState = TTK_BUTTON_DEFAULT_DISABLED; \ + int has_default = (defaultState == TTK_BUTTON_DEFAULT_ACTIVE); \ + /*Ttk_GetButtonDefaultStateFromObj(NULL, obj, &defaultState);*/ + +#ifdef GTTK_LOAD_GTK_DYNAMICALLY + +#define GTTK_WIDGET_SET_FOCUS(widget) + +#define GTTK_WIDGET_SET_DEFAULT(widget, obj) \ + int defaultState = TTK_BUTTON_DEFAULT_DISABLED; \ + int has_default = (defaultState == TTK_BUTTON_DEFAULT_ACTIVE); + +#else /* GTTK_LOAD_GTK_DYNAMICALLY */ + +#define GTTK_WIDGET_SET_FOCUS(widget) \ + if (state & TTK_STATE_FOCUS) { \ + GTK_WIDGET_SET_FLAGS(widget, GTK_HAS_FOCUS); \ + } else { \ + GTK_WIDGET_UNSET_FLAGS(widget, GTK_HAS_FOCUS); \ + } + +#define GTTK_WIDGET_SET_DEFAULT(widget, obj) \ + int defaultState = TTK_BUTTON_DEFAULT_DISABLED; \ + int has_default = (defaultState == TTK_BUTTON_DEFAULT_ACTIVE); \ + /*Ttk_GetButtonDefaultStateFromObj(NULL, obj, &defaultState);*/ \ + if (has_default) { \ + GTK_WIDGET_SET_FLAGS(widget, GTK_HAS_DEFAULT); \ + } else { \ + GTK_WIDGET_UNSET_FLAGS(widget, GTK_HAS_DEFAULT); \ + } +#endif /* GTTK_LOAD_GTK_DYNAMICALLY */ + +#define GTTK_DEBUG_PRINT_BOX \ + printf("x=%d, y=%d, w=%d, h=%d\n", b.x, b.y, b.width, b.height); \ + fflush(0); + +#define GTTK_DEBUG_PRINT_TK_WIDGET \ + printf("Widget: %s,p=%p\n", Tk_PathName(tkwin), tkwin); \ + fflush(0); + +#define GTTK_GTKBORDER_TO_PADDING(border) \ + Ttk_MakePadding(border.left, border.top, border.right, border.bottom) + +TCL_DECLARE_MUTEX(gttkMutex); + +/* Global Symbols */ + +/* Helper Functions */ +extern int gttk_GtkInitialised(void); +extern GtkWidget *gttk_GetGtkWindow(void); +extern GtkStyle *gttk_GetGtkWindowStyle(GtkWidget *gtkWindow); +extern GtkStyle *gttk_GetGtkStyle(void); + +extern unsigned int gttk_StateTableLookup(Ttk_StateTable *, unsigned int); +extern void gttk_CopyGtkPixmapOnToDrawable(GdkPixmap *, Drawable, Tk_Window, + int, int, int, int, int, int); +extern void gttk_StateInfo(int, GtkStateType, + GtkShadowType, Tk_Window, GtkWidget *widget = NULL); + +extern GtkWidget *gttk_GetArrow(gttk_WidgetCache* wc); +extern GtkWidget *gttk_GetButton(gttk_WidgetCache* wc); +extern GtkWidget *gttk_GetCheckButton(gttk_WidgetCache* wc); +extern GtkWidget *gttk_GetRadioButton(gttk_WidgetCache* wc); +extern GtkWidget *gttk_GetToolBar(gttk_WidgetCache* wc); +extern GtkWidget *gttk_GetToolButton(gttk_WidgetCache* wc); +extern GtkWidget *gttk_GetFrame(gttk_WidgetCache* wc); +extern GtkWidget *gttk_GetEntry(gttk_WidgetCache* wc); +extern GtkWidget *gttk_GetCombobox(gttk_WidgetCache* wc); +extern GtkWidget *gttk_GetComboboxEntry(gttk_WidgetCache* wc); +extern GtkWidget *gttk_GetHScrollBar(gttk_WidgetCache* wc); +extern GtkWidget *gttk_GetVScrollBar(gttk_WidgetCache* wc); +extern GtkWidget *gttk_GetScrollBar(gttk_WidgetCache* wc); +extern GtkWidget *gttk_GetHScale(gttk_WidgetCache* wc); +extern GtkWidget *gttk_GetVScale(gttk_WidgetCache* wc); +extern GtkWidget *gttk_GetScale(gttk_WidgetCache* wc); +extern GtkWidget *gttk_GetHProgressBar(gttk_WidgetCache* wc); +extern GtkWidget *gttk_GetVProgressBar(gttk_WidgetCache* wc); +extern GtkWidget *gttk_GetProgressBar(gttk_WidgetCache* wc); +extern GtkWidget *gttk_GetStatusBar(gttk_WidgetCache* wc); +extern GtkWidget *gttk_GetPaned(gttk_WidgetCache* wc); +extern GtkWidget *gttk_GetNotebook(gttk_WidgetCache* wc); +#if 0 +extern void gttk_StoreStyleNameLowers(gttk_WidgetCache *wc); +extern bool gttk_ThemeIs(gttk_WidgetCache *wc, const char* name); +extern void gttk_SetFocus(bool focus); +#endif + +extern unsigned int gttk_StateShadowTableLookup(gttk_StateTable*, + unsigned int, GtkStateType&, GtkShadowType&, + unsigned int section = GTTK_SECTION_ALL); +extern double gttk_ValueFromSlider(gttk_WidgetCache *wc, Tk_Window tkwin, + Ttk_Box b); diff --git a/generic/gtkTtk_WidgetDefaults.h b/generic/gttk_WidgetDefaults.h similarity index 92% rename from generic/gtkTtk_WidgetDefaults.h rename to generic/gttk_WidgetDefaults.h index 5d1b688..f265b2f 100644 --- a/generic/gtkTtk_WidgetDefaults.h +++ b/generic/gttk_WidgetDefaults.h @@ -1,8 +1,8 @@ /* - * gtkTtk_WidgetDefaults.h + * gttk_WidgetDefaults.h * ------------------------- * - * This file is part of the gtkTtk package, a Tk/Tile based theme that uses + * This file is part of the gttk package, a Tk/Tile based theme that uses * Gtk/GNOME for drawing. * * Copyright (C) 2004-2008 by: diff --git a/generic/tileGtk_Symbols.cpp b/generic/tileGtk_Symbols.cpp deleted file mode 100644 index 3f62d77..0000000 --- a/generic/tileGtk_Symbols.cpp +++ /dev/null @@ -1,61 +0,0 @@ -/* - * tileGtk_Symbols.cpp - * ------------------------ - * - * This file is part of the Tile-Gtk package, a Tk/Tile based theme that uses - * Gtk/GNOME for drawing. - * - * Copyright (C) 2004-2012 by: - * Georgios Petasis, petasis@iit.demokritos.gr, - * Software and Knowledge Engineering Laboratory, - * Institute of Informatics and Telecommunications, - * National Centre for Scientific Research (NCSR) "Demokritos", - * Aghia Paraskevi, 153 10, Athens, Greece. - */ -/* THIS FILE IS AUTOMATICALLY GENERATED - DO NOT EDIT! */ -#include "tileGtk_Symbols.h" -#ifdef TILEGTK_LOAD_GTK_DYNAMICALLY -#if (TCL_MAJOR_VERSION >= 8) && (TCL_MINOR_VERSION >= 6) -#define LOAD_SYMBOLS_WITH_TCL -#endif - -#ifndef LOAD_SYMBOLS_WITH_TCL -#include -#endif - -Ptr_g_malloc TileGtk_g_malloc = 0; -Ptr_g_malloc0 TileGtk_g_malloc0 = 0; - -int TileGtk_InitialiseSymbols_glib(Tcl_Interp *interp, Tcl_Obj *file_name) { -#ifdef LOAD_SYMBOLS_WITH_TCL - Tcl_LoadHandle loadHandle; - int status; - status = Tcl_LoadFile(interp, file_name, NULL, 0, NULL, &loadHandle); - if (status != TCL_OK) return status; - TileGtk_g_malloc = (Ptr_g_malloc) Tcl_FindSymbol(interp, loadHandle, "g_malloc"); - if (TileGtk_g_malloc == NULL) return TCL_ERROR; - TileGtk_g_malloc0 = (Ptr_g_malloc0) Tcl_FindSymbol(interp, loadHandle, "g_malloc0"); - if (TileGtk_g_malloc0 == NULL) return TCL_ERROR; -#else - const char *fname = Tcl_GetString(file_name); - GModule *m = g_module_open(fname, G_MODULE_BIND_LAZY); - if (!m) { - Tcl_SetResult(interp, (char *) "cannot open module: ", TCL_STATIC); - Tcl_AppendResult(interp, fname, (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "g_malloc", (gpointer *) &TileGtk_g_malloc)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "g_malloc", (char *) NULL); - return TCL_ERROR; - } - if (!g_module_symbol(m, "g_malloc0", (gpointer *) &TileGtk_g_malloc0)) { - Tcl_SetResult(interp, (char *) "cannot find symbol: ", TCL_STATIC); - Tcl_AppendResult(interp, (char *) "g_malloc0", (char *) NULL); - return TCL_ERROR; - } -#endif - return TCL_OK; -}; /* TileGtk_InitialiseSymbols_glib */ - -#endif /* TILEGTK_LOAD_GTK_DYNAMICALLY */ diff --git a/generic/tileGtk_Symbols.h b/generic/tileGtk_Symbols.h deleted file mode 100644 index a748456..0000000 --- a/generic/tileGtk_Symbols.h +++ /dev/null @@ -1,52 +0,0 @@ -/* - * tileGtk_Symbols.h - * -------------------- - * - * This file is part of the Tile-Gtk package, a Tk/Tile based theme that uses - * Gtk/GNOME for drawing. - * - * Copyright (C) 2004-2012 by: - * Georgios Petasis, petasis@iit.demokritos.gr, - * Software and Knowledge Engineering Laboratory, - * Institute of Informatics and Telecommunications, - * National Centre for Scientific Research (NCSR) "Demokritos", - * Aghia Paraskevi, 153 10, Athens, Greece. - */ -/* THIS FILE IS AUTOMATICALLY GENERATED - DO NOT EDIT! */ -#ifndef _TILEGTK_SYMBOLS -#define _TILEGTK_SYMBOLS -#include "tcl.h" -#ifdef LOAD_SYMBOLS_WITH_TCL -#else -#include -#endif -#include -#include -#include -#ifndef __WIN32__ -#include -#include -#else -#include -#endif - -#ifdef TILEGTK_LOAD_GTK_DYNAMICALLY -extern "C" { - typedef gpointer (*Ptr_g_malloc)(gsize n_bytes); - extern Ptr_g_malloc TileGtk_g_malloc; - typedef gpointer (*Ptr_g_malloc0)(gsize n_bytes); - extern Ptr_g_malloc0 TileGtk_g_malloc0; -} - -extern int TileGtk_InitialiseSymbols_glib(Tcl_Interp *interp, Tcl_Obj *file_name); -#define TILEGTK_LAST_SYMBOL_glib TileGtk_g_malloc0 - -#else /* TILEGTK_LOAD_GTK_DYNAMICALLY */ - -#define TileGtk_g_malloc \ - g_malloc -#define TileGtk_g_malloc0 \ - g_malloc0 -#endif /* TILEGTK_LOAD_GTK_DYNAMICALLY */ - -#endif /* _TILEGTK_SYMBOLS */ diff --git a/generic/tkMacros.h b/generic/tkMacros.h index 3f548da..22dc3c3 100644 --- a/generic/tkMacros.h +++ b/generic/tkMacros.h @@ -2,7 +2,7 @@ * tkMacros.h * ---------------------- * - * This file is part of the gtkTtk package, a Tk/Tile based theme that uses + * This file is part of the gttk package, a Tk/Tile based theme that uses * Gtk/GNOME for drawing. * * Copyright (C) 2004-2008 by: @@ -13,8 +13,8 @@ * Aghia Paraskevi, 153 10, Athens, Greece. */ -#ifndef __GTKTTK_TK_MACROS -#define __GTKTTK_TK_MACROS +#ifndef __GTTK_TK_MACROS +#define __GTTK_TK_MACROS typedef struct { long flags; @@ -73,4 +73,4 @@ typedef struct Tk_FakeWmInfo { #define Tk_RealToplevelWindow(tkwin) ((((Tk_FakeWmInfo *) (((Tk_FakeWin *) (tkwin))->dummy16))->wrapperPtr)->window) -#endif /* __GTKTTK_TK_MACROS */ +#endif /* __GTTK_TK_MACROS */ diff --git a/gtkTtk.gif b/gtkTtk.gif deleted file mode 100644 index cd146b6..0000000 Binary files a/gtkTtk.gif and /dev/null differ diff --git a/gttk/__init__.py b/gttk/__init__.py new file mode 100644 index 0000000..20ec9f9 --- /dev/null +++ b/gttk/__init__.py @@ -0,0 +1,112 @@ +""" +Author: RedFantom +License: GNU GPLv3 +Copyright (c) 2020 RedFantom +""" +import contextlib +import os +import sys +from tempfile import gettempdir +import tkinter as tk +from typing import Optional, Tuple + + +@contextlib.contextmanager +def chdir(target): + cwd = os.getcwd() + try: + os.chdir(target) + yield + finally: + os.chdir(cwd) + + +class GTTK(object): + """ + Class representing the GTTK extension + """ + + FOLDER = os.path.abspath(os.path.dirname(__file__)) + + def __init__(self, window: tk.Tk, theme: Optional[str] = None, theme_dir_prefix: Optional[str] = None, + temp_dir: str = gettempdir()): + """ + Initialize gttk and load it into a window + + :param window: Window with Tk/Tcl interpreter to load gttk for + :param theme: GTK theme to set upon initialisation + :param theme_dir_prefix: Prefix to the theme directory. If not + given, defaults to the current working directory. If this + has the special value "LIB", the script will use the + site-packages directory where it is installed. + :param temp_dir: Absolute path to temporary files directory that + may be used by the library + """ + self.tk = window.tk + folder = os.path.dirname(os.path.abspath(__file__)) + + if theme_dir_prefix is not None: + if theme_dir_prefix == "LIB": + os.environ["GTK_DATA_PREFIX"] = folder + elif os.path.exists(theme_dir_prefix): + os.environ["GTK_DATA_PREFIX"] = theme_dir_prefix + else: # Invalid directory specified, throw error here as GTK will fail silently + raise FileNotFoundError("Specified theme directory prefix does not exist: {}".format(theme_dir_prefix)) + + # Create loaders.cache on win32 platforms to find pixbuf loaders properly + if "win" in sys.platform: + target = os.path.join(temp_dir, "loaders.cache") + source = os.path.join(folder, "lib", "gdk-pixbuf-2.0", "2.10.0", "loaders.cache") + with open(os.path.join(source)) as fi, open(target, "w") as fo: + cache = fi.read() + # loaders.cache uses double \ everywhere + abspath = (os.path.join(folder, "lib", ) + "\\").replace("\\", "\\\\") + cache_w_abspaths = cache.replace("lib\\\\", abspath) + fo.write(cache_w_abspaths) + # Set GDK_PIXBUF_MODULE_FILE to the path of the new cache file + # GDK_PIXBUF_MODULEDIR does not do anything for plain GDK! + os.environ["GDK_PIXBUF_MODULE_FILE"] = target + + # Set GTK_EXE_PREFIX on win32 to ensure theme engine loading + os.environ["GTK_EXE_PREFIX"] = folder + + with chdir(folder): + # Evaluate pkgIndex.tcl, Tcl does not handle \ as a pathsep, so with / + self.tk.eval("set dir {0}; source {0}/pkgIndex.tcl".format(folder.replace("\\", "/"))) + self.tk.call("package", "require", "ttk::theme::gttk") + + if theme is not None: + self.set_gtk_theme(theme) + + def get_themes_directory(self) -> str: + """Return the directory in which GTK looks for installed themes""" + return self.tk.call("ttk::theme::gttk::gtkDirectory", "theme") + + def get_default_files(self) -> Tuple[str]: + """Return the files that GTK parses by default at start-up""" + return self.tk.call("ttk::theme::gttk::gtkDirectory", "default_files") + + def get_current_theme(self) -> str: + """Return the name of the currently active GTK theme""" + return self.tk.call("ttk::theme::gttk::currentThemeName") + + def get_module_path(self) -> str: + """Return the name of the module path (theme engines)""" + return self.tk.call("ttk::theme::gttk::gtkDirectory", "module") + + def get_gtk_enum_value(self, value: int) -> str: + """ + Return a value of a the GtkPositionType enum + + TODO: Extend gttk_GtkEnum in gttk_Init.cpp for more enums + """ + return self.tk.call("ttk::theme::gttk::gtkEnum", "GtkPositionType", 0) + + def get_theme_colour(self, name: str) -> str: + return self.tk.call("ttk::theme::gttk::currentThemeColour", name) + + def get_theme_colour_keys(self) -> Tuple[str]: + return self.tk.call("ttk::theme::gttk::currentThemeColourKeys") + + def set_gtk_theme(self, theme: str): + self.tk.call("ttk::theme::gttk::setGtkTheme", theme) diff --git a/library/gtkTtk.tcl b/gttk/gttk.tcl similarity index 93% rename from library/gtkTtk.tcl rename to gttk/gttk.tcl index d9c6cb6..472c907 100644 --- a/library/gtkTtk.tcl +++ b/gttk/gttk.tcl @@ -1,4 +1,4 @@ -namespace eval ttk::theme::gtkTtk { +namespace eval ttk::theme::gttk { variable PreviewInterp {} variable System variable StyleToRc @@ -143,7 +143,7 @@ namespace eval ttk::theme::gtkTtk { variable GtkHScrollbar variable GtkVScrollbar if {![info exists theme]} {return} - ttk::style theme use gtkTtk + ttk::style theme use gttk # puts "============================================================" # puts "Current Gtk Theme: [currentThemeName] ($theme)" # puts "Tab alignment: [getStyleHint -SH_TabBar_Alignment]" @@ -232,7 +232,7 @@ namespace eval ttk::theme::gtkTtk { proc updateStyles {} { # puts [currentThemeColourKeys] - ttk::style theme settings gtkTtk { + ttk::style theme settings gttk { ttk::style configure . \ -background [currentThemeColour bg(NORMAL)] \ -foreground [currentThemeColour fg(NORMAL)] \ @@ -337,7 +337,7 @@ namespace eval ttk::theme::gtkTtk { bg(NORMAL)] ttk::style configure Vertical.Sash -background [currentThemeColour \ bg(NORMAL)] - };# ttk::style theme settings gtkTtk + };# ttk::style theme settings gttk # puts "\nPixel Metric Information:" # foreach pm {PM_TabBarTabOverlap PM_TabBarTabHSpace @@ -380,7 +380,7 @@ namespace eval ttk::theme::gtkTtk { };# kdeLocate_kdeglobals ## updateColourPalette: - # This procedure will be called from gtkTtk core each time a message is + # This procedure will be called from gttk core each time a message is # received from KDE to change the palette used. proc updateColourPalette {} { return @@ -457,7 +457,7 @@ namespace eval ttk::theme::gtkTtk { };# updateColourPalette ## kdeStyleChangeNotification: - # This procedure will be called from gtkTtk core each time a message is + # This procedure will be called from gttk core each time a message is # received from KDE to change the style used. proc kdeStyleChangeNotification {} { return @@ -491,7 +491,7 @@ namespace eval ttk::theme::gtkTtk { ## applyStyle: # This procedure can be used to apply any available GTK+ style. # Ths "style" parameter must be a string from the style names returned by - # ttk::theme::gtkTtk::availableStyles. + # ttk::theme::gttk::availableStyles. proc applyStyle {style} { variable StyleToRc variable System @@ -502,7 +502,7 @@ namespace eval ttk::theme::gtkTtk { ## In order to force a style update, we need to create an rc file, and force ## GTK to load it... ## - set rc [file normalize $System(TEMP)/gtkrc.gtkTtk-[pid]] + set rc [file normalize $System(TEMP)/gtkrc.gttk-[pid]] set fd [open $rc w] puts $fd {# -- THEME AUTO-WRITTEN DO NOT EDIT} puts $fd "include \"$StyleToRc($style)\"" @@ -526,7 +526,7 @@ namespace eval ttk::theme::gtkTtk { };# applyStyle ## kdePaletteChangeNotification: - # This procedure will be called from gtkTtk core each time a message is + # This procedure will be called from gttk core each time a message is # received from KDE to change the palette used. proc kdePaletteChangeNotification {} { return @@ -542,7 +542,7 @@ namespace eval ttk::theme::gtkTtk { };# kdeGetColourHex ## createThemeConfigurationPanel: - # This method will create a configuration panel for the gtkTtk theme in the + # This method will create a configuration panel for the gttk theme in the # provided frame widget. proc createThemeConfigurationPanel {dlgFrame} { ## The first element in our panel, is a combobox, with all the available @@ -551,11 +551,11 @@ namespace eval ttk::theme::gtkTtk { ttk::combobox $dlgFrame.style_selection.style -state readonly $dlgFrame.style_selection.style set [currentThemeName] bind $dlgFrame.style_selection.style <> \ - {%W set [ttk::theme::gtkTtk::currentThemeName]} + {%W set [ttk::theme::gttk::currentThemeName]} bind $dlgFrame.style_selection.style \ - {%W configure -values [ttk::theme::gtkTtk::availableStyles]} + {%W configure -values [ttk::theme::gttk::availableStyles]} ttk::button $dlgFrame.style_selection.apply -text Apply -command \ - "ttk::theme::gtkTtk::applyStyle \[$dlgFrame.style_selection.style get\]" + "ttk::theme::gttk::applyStyle \[$dlgFrame.style_selection.style get\]" grid $dlgFrame.style_selection.style $dlgFrame.style_selection.apply \ -padx 2 -sticky snew grid columnconfigure $dlgFrame.style_selection 0 -weight 1 @@ -572,7 +572,7 @@ namespace eval ttk::theme::gtkTtk { -text {Preview Unavailable!}] -fill both -expand 1 } else { frame $dlgFrame.preview.container -container 1 -height 250 -width 400 - ## Create a slave interpreter, and load gtkTtk. Widgets in this interp + ## Create a slave interpreter, and load gttk. Widgets in this interp ## may be of a different widget style! set PreviewInterp [interp create] interp eval $PreviewInterp {package require Tk} @@ -582,17 +582,17 @@ namespace eval ttk::theme::gtkTtk { if {[catch {package require Ttk}]} { package require tile } - ttk::setTheme gtkTtk - # package require ttk::theme::gtkTtk - ttk::theme::gtkTtk::applyStyle \{[currentThemeName]\} + ttk::setTheme gttk + # package require ttk::theme::gttk + ttk::theme::gttk::applyStyle \{[currentThemeName]\} toplevel .widgets -height 250 -width 400 \ -use [winfo id $dlgFrame.preview.container] - ttk::theme::gtkTtk::selectStyleDlg_previewWidgets .widgets + ttk::theme::gttk::selectStyleDlg_previewWidgets .widgets " bind $dlgFrame.preview.container \ - "ttk::theme::gtkTtk::destroyThemeConfigurationPanel" + "ttk::theme::gttk::destroyThemeConfigurationPanel" bind $dlgFrame.style_selection.style <> \ - {ttk::theme::gtkTtk::updateThemeConfigurationPanel [%W get]} + {ttk::theme::gttk::updateThemeConfigurationPanel [%W get]} } pack $dlgFrame.preview.container -padx 0 -pady 0 -fill both -expand 1 pack $dlgFrame.preview -fill both -expand 1 -padx 2 -pady 2 @@ -606,7 +606,7 @@ namespace eval ttk::theme::gtkTtk { proc updateThemeConfigurationPanel {style} { variable PreviewInterp - interp eval $PreviewInterp "ttk::theme::gtkTtk::applyStyle \{$style\}" + interp eval $PreviewInterp "ttk::theme::gttk::applyStyle \{$style\}" };# updateThemeConfigurationPanel proc selectStyleDlg_previewWidgets {{win {}}} { @@ -626,15 +626,15 @@ namespace eval ttk::theme::gtkTtk { ## Add a set of radiobuttons to the left... ttk::labelframe $tab1.panedwindow.buttons -text " Button Group " ttk::radiobutton $tab1.panedwindow.buttons.b1 -text "Radio button" \ - -variable ttk::theme::gtkTtk::temp(selectionVariable) -value 1 + -variable ttk::theme::gttk::temp(selectionVariable) -value 1 ttk::radiobutton $tab1.panedwindow.buttons.b2 -text "Radio button" \ - -variable ttk::theme::gtkTtk::temp(selectionVariable) -value 2 + -variable ttk::theme::gttk::temp(selectionVariable) -value 2 ttk::radiobutton $tab1.panedwindow.buttons.b3 -text "Radio button" \ - -variable ttk::theme::gtkTtk::temp(selectionVariable) -value 3 + -variable ttk::theme::gttk::temp(selectionVariable) -value 3 ttk::separator $tab1.panedwindow.buttons.sep -orient horizontal ttk::checkbutton $tab1.panedwindow.buttons.b4 -text "Checkbox" $tab1.panedwindow.buttons.b4 state selected - set ttk::theme::gtkTtk::temp(selectionVariable) 1 + set ttk::theme::gttk::temp(selectionVariable) 1 grid $tab1.panedwindow.buttons.b1 -sticky snew -padx 2 -pady 2 grid $tab1.panedwindow.buttons.b2 -sticky snew -padx 2 -pady 2 grid $tab1.panedwindow.buttons.b3 -sticky snew -padx 2 -pady 2 @@ -645,15 +645,15 @@ namespace eval ttk::theme::gtkTtk { ## Add a set of other widgets (like progress, combo, scale, etc). ttk::frame $tab1.panedwindow.widgets ttk::progressbar $tab1.panedwindow.widgets.progress -orient horizontal \ - -maximum 100 -variable ttk::theme::gtkTtk::temp(progress) + -maximum 100 -variable ttk::theme::gttk::temp(progress) grid $tab1.panedwindow.widgets.progress -sticky snew -padx 2 -pady 2 ttk::scale $tab1.panedwindow.widgets.scale -orient horizontal -from 0 \ - -to 100 -variable ttk::theme::gtkTtk::temp(progress) - set ttk::theme::gtkTtk::temp(progress) 70 + -to 100 -variable ttk::theme::gttk::temp(progress) + set ttk::theme::gttk::temp(progress) 70 grid $tab1.panedwindow.widgets.scale -sticky snew -padx 2 -pady 2 ttk::entry $tab1.panedwindow.widgets.entry -textvariable \ - ttk::theme::gtkTtk::temp(entry) - set ttk::theme::gtkTtk::temp(entry) {Entry Widget} + ttk::theme::gttk::temp(entry) + set ttk::theme::gttk::temp(entry) {Entry Widget} grid $tab1.panedwindow.widgets.entry -sticky snew -padx 2 -pady 2 ttk::button $tab1.panedwindow.widgets.button -text Button grid $tab1.panedwindow.widgets.button -sticky snew -padx 2 -pady 2 diff --git a/library/GenarateSymbols.tcl b/library/GenerateSymbols.tcl similarity index 90% rename from library/GenarateSymbols.tcl rename to library/GenerateSymbols.tcl index ebe1af9..ecaa4b4 100644 --- a/library/GenarateSymbols.tcl +++ b/library/GenerateSymbols.tcl @@ -340,21 +340,21 @@ set sources [file dirname $HomeDir]/generic ## Force the following symbols to exist! ## foreach s {g_malloc0 g_malloc} { - set Symbols(GtkTtk_$s) 1 + set Symbols(gttk_$s) 1 } proc process {data} { global Symbols set skip {[^)(\",=]+} foreach lib {gtk gdk xlib g} { - foreach s [regexp -inline -all "GtkTtk_${lib}_${skip}\\\s*\\\(" $data] { + foreach s [regexp -inline -all "gttk_${lib}_${skip}\\\s*\\\(" $data] { set Symbols([string trim $s { ()}]) 1 } } } foreach file [lsort [glob -directory $sources -type f *]] { - if {[string match *gtkTtk_Symbols* $file ]} continue + if {[string match *gttk_Symbols* $file ]} continue set fd [open $file] fconfigure $fd -encoding utf-8 set data [read $fd] @@ -364,7 +364,7 @@ foreach file [lsort [glob -directory $sources -type f *]] { ## Remove definitions... foreach s {g_new0} { - unset -nocomplain Symbols(GtkTtk_$s) + unset -nocomplain Symbols(gttk_$s) } switch $::tcl_platform(platform) { @@ -379,20 +379,20 @@ switch $::tcl_platform(platform) { } } foreach s $not_native { - unset -nocomplain Symbols(GtkTtk_$s) + unset -nocomplain Symbols(gttk_$s) } ## -## Generate file gtkTtk_Symbols.cpp +## Generate file gttk_Symbols.cpp ## -set fc [open $sources/gtkTtk_Symbols.cpp w] +set fc [open $sources/gttk_Symbols.cpp w] fconfigure $fc -encoding iso8859-1 puts $fc \ {/* - * gtkTtk_Symbols.cpp + * gttk_Symbols.cpp * ------------------------ * - * This file is part of the GtkTtk package, a ttk based theme that uses + * This file is part of the gttk package, a ttk based theme that uses * Gtk/GNOME for drawing. * * Copyright (C) 2004-2012 by: @@ -403,8 +403,8 @@ puts $fc \ * Aghia Paraskevi, 153 10, Athens, Greece. */ /* THIS FILE IS AUTOMATICALLY GENERATED - DO NOT EDIT! */ -#include "gtkTtk_Symbols.h" -#ifdef GTKTTK_LOAD_GTK_DYNAMICALLY +#include "gttk_Symbols.h" +#ifdef GTTK_LOAD_GTK_DYNAMICALLY #if (TCL_MAJOR_VERSION >= 8) && (TCL_MINOR_VERSION >= 6) #define LOAD_SYMBOLS_WITH_TCL #endif @@ -415,17 +415,17 @@ puts $fc \ } ## -## Generate file gtkTtk_Symbols.h +## Generate file gttk_Symbols.h ## -set fd [open $sources/gtkTtk_Symbols.h w] +set fd [open $sources/gttk_Symbols.h w] fconfigure $fd -encoding iso8859-1 puts $fd \ {/* - * gtkTtk_Symbols.h + * gttk_Symbols.h * -------------------- * - * This file is part of the GtkTtk package, a ttk based theme that uses + * This file is part of the gttk package, a ttk based theme that uses * Gtk/GNOME for drawing. * * Copyright (C) 2004-2012 by: @@ -436,8 +436,8 @@ puts $fd \ * Aghia Paraskevi, 153 10, Athens, Greece. */ /* THIS FILE IS AUTOMATICALLY GENERATED - DO NOT EDIT! */ -#ifndef _GTKTTK_SYMBOLS -#define _GTKTTK_SYMBOLS +#ifndef _GTTK_SYMBOLS +#define _GTTK_SYMBOLS #include "tcl.h" #ifdef LOAD_SYMBOLS_WITH_TCL #else @@ -453,7 +453,7 @@ puts $fd \ #include #endif -#ifdef GTKTTK_LOAD_GTK_DYNAMICALLY} +#ifdef GTTK_LOAD_GTK_DYNAMICALLY} puts $fd "extern \"C\" \{" if {1} { @@ -466,7 +466,7 @@ if {1} { puts $fc "Ptr_$gtk_s $symbol = 0;" lappend GTKSymbols($lib) $gtk_s; #puts $fd "/*\n * $symbol: Stub for [string range $symbol 7 end]\n */" - #puts $fd "${symbol}() {\n GTKTTK_ENSURE\n}; /* $symbol */\n" + #puts $fd "${symbol}() {\n GTTK_ENSURE\n}; /* $symbol */\n" } } @@ -475,17 +475,17 @@ puts $fd "\}\n" proc initialise_lib {lib} { global fc fd GTKSymbols puts $fd "extern int\ - GtkTtk_InitialiseSymbols_${lib}(Tcl_Interp *interp, Tcl_Obj *file_name);" + gttk_InitialiseSymbols_${lib}(Tcl_Interp *interp, Tcl_Obj *file_name);" puts $fc "\nint\ - GtkTtk_InitialiseSymbols_${lib}(Tcl_Interp *interp, Tcl_Obj *file_name) \{" + gttk_InitialiseSymbols_${lib}(Tcl_Interp *interp, Tcl_Obj *file_name) \{" puts $fc "#ifdef LOAD_SYMBOLS_WITH_TCL" puts $fc " Tcl_LoadHandle loadHandle;" puts $fc " int status;" puts $fc " status = Tcl_LoadFile(interp, file_name, NULL, 0, NULL, &loadHandle);" puts $fc " if (status != TCL_OK) return status;" foreach s $GTKSymbols($lib) { - puts $fc " GtkTtk_$s = (Ptr_$s) Tcl_FindSymbol(interp, loadHandle, \"$s\");" - puts $fc " if (GtkTtk_$s == NULL) return TCL_ERROR;" + puts $fc " gttk_$s = (Ptr_$s) Tcl_FindSymbol(interp, loadHandle, \"$s\");" + puts $fc " if (gttk_$s == NULL) return TCL_ERROR;" } puts $fc "#else" puts $fc " const char *fname = Tcl_GetString(file_name);" @@ -496,15 +496,15 @@ proc initialise_lib {lib} { puts $fc " return TCL_ERROR;" puts $fc " }" foreach s $GTKSymbols($lib) { - puts $fc " if (!g_module_symbol(m, \"$s\", (gpointer *) &GtkTtk_$s)) {" + puts $fc " if (!g_module_symbol(m, \"$s\", (gpointer *) >tk_$s)) {" puts $fc " Tcl_SetResult(interp, (char *) \"cannot find symbol: \", TCL_STATIC);" puts $fc " Tcl_AppendResult(interp, (char *) \"$s\", (char *) NULL);" puts $fc " return TCL_ERROR;" puts $fc " }" } puts $fc "#endif" - puts $fc " return TCL_OK;\n\}; /* GtkTtk_InitialiseSymbols_${lib} */\n" - puts $fd "#define GTKTTK_LAST_SYMBOL_$lib GtkTtk_$s" + puts $fc " return TCL_OK;\n\}; /* gttk_InitialiseSymbols_${lib} */\n" + puts $fd "#define GTTK_LAST_SYMBOL_$lib gttk_$s" };# initialise_lib foreach lib [lsort [array names GTKSymbols]] { initialise_lib $lib @@ -512,7 +512,7 @@ foreach lib [lsort [array names GTKSymbols]] { puts $fd { -#else /* GTKTTK_LOAD_GTK_DYNAMICALLY */ +#else /* GTTK_LOAD_GTK_DYNAMICALLY */ } ## @@ -526,11 +526,11 @@ if {1} { } puts $fd \ -{#endif /* GTKTTK_LOAD_GTK_DYNAMICALLY */ +{#endif /* GTTK_LOAD_GTK_DYNAMICALLY */ -#endif /* _GTKTTK_SYMBOLS */} +#endif /* _GTTK_SYMBOLS */} close $fd puts $fc \ -{#endif /* GTKTTK_LOAD_GTK_DYNAMICALLY */} +{#endif /* GTTK_LOAD_GTK_DYNAMICALLY */} close $fc diff --git a/library/pkgIndex.tcl b/library/pkgIndex.tcl deleted file mode 100644 index 381e000..0000000 --- a/library/pkgIndex.tcl +++ /dev/null @@ -1,2 +0,0 @@ -package ifneeded ttk::theme::gtkTtk 0.5 \ - [list load [file join $dir libgtkTtk0.5[info sharedlibextension]] gtkTtk] \ No newline at end of file diff --git a/screenshots/adwaita.png b/screenshots/adwaita.png new file mode 100644 index 0000000..d024aa5 Binary files /dev/null and b/screenshots/adwaita.png differ diff --git a/screenshots/yaru.png b/screenshots/yaru.png new file mode 100644 index 0000000..44785ed Binary files /dev/null and b/screenshots/yaru.png differ diff --git a/setup.py b/setup.py new file mode 100644 index 0000000..81bca7b --- /dev/null +++ b/setup.py @@ -0,0 +1,203 @@ +""" +Author: RedFantom +License: GNU GPLv3 +Copyright (c) 2020 RedFantom +""" +import sys + + +def read(file_name): + with open(file_name) as fi: + contents = fi.read() + return contents + + +def printf(*args, **kwargs): + kwargs.update({"flush": True}) + print(*args, **kwargs) + + +if "linux" in sys.platform: + try: + from skbuild import setup + from skbuild.command.build import build + except ImportError: + printf("scikit-build is required to build this project") + printf("install with `python -m pip install scikit-build`") + raise + + + class BuildCommand(build): + """ + Intercept the build command to build the required modules in ./build + + gttk depends on a library built from source. Building this library + requires the following to be installed, Ubuntu package names: + - libx11-dev + - libgtk2.0-dev + - libgdk-pixbuf2.0-dev + - tcl-dev + - tk-dev + """ + + def run(self): + build.run(self) + + kwargs = {"install_requires": ["scikit-build"], "cmdClass": {"build": BuildCommand}} + +elif "win" in sys.platform: + import os + import shutil + from setuptools import setup + import subprocess as sp + from typing import List, Optional + + dependencies = ["pango", "cmake", "gtk2", "glib2", "tk", "toolchain", "libffi"] + + for dep in dependencies: + printf("Installing dependency {}...".format(dep), end=" ") + sp.call(["pacman", "--needed", "--noconfirm", "-S", "mingw-w64-x86_64-{}".format(dep)], + stdout=sp.PIPE, stderr=sp.PIPE) + printf("Done.") + sp.call(["cmake", ".", "-G", "MinGW Makefiles"]) + sp.call(["mingw32-make"]) + + + class DependencyWalker(object): + """ + Walk the dependencies of a DLL file and find all DLL files + + DLL files are searched for in all the directories specified by + - The PATH environment variable + - The DLL_SEARCH_PATHS environment variable + """ + + EXCLUDE = ["MSVCRT140.dll", "VCRUNTIME140.dll"] + + def __init__(self, dll_file: str, dependencies_exe="deps\\dependencies.exe", specials=dict()): + if not os.path.exists(dependencies_exe): + printf("dependencies.exe is required to find all dependency DLLs") + raise FileNotFoundError("Invalid path specified for dependencies.exe") + self._exe = dependencies_exe + if not os.path.exists(dll_file): + raise FileNotFoundError("'{}' does not specify a valid path to first file".format(dll_file)) + self._dll_file = dll_file + self._dll_cache = {} + self._specials = specials + self.walked = {} + + @property + def dependency_dll_files(self) -> List[str]: + """Return a list of abspaths to the dependency DLL files""" + printf("Walking dependencies of {}".format(self._dll_file)) + dlls = [self._dll_file] + list(map(self._find_dll_abs_path, self._specials.keys())) + done = [] + while set(dlls) != set(done): # As long as not all dlls are done, keep searching + for dll in set(dlls) - set(done): # Go only over not-yet done DLLs + if dll is None: + done.append(None) + continue + printf("Looking for dependencies of {}".format(dll)) + p = sp.Popen([self._exe, "-imports", dll], stdout=sp.PIPE) + stdout, stderr = p.communicate() + new_dlls = self._parse_dependencies_output(stdout) + for new_dll in new_dlls: + p = self._find_dll_abs_path(new_dll) + if p is None: + continue + elif "system32" in p: + continue + elif p not in dlls: + dlls.append(p) + done.append(dll) + return list(set(dlls) - set((None,))) + + @staticmethod + def _parse_dependencies_output(output: bytes) -> List[str]: + """Parse the output of the dependencies.exe command""" + dlls: List[str] = list() + for line in map(str.strip, output.decode().split("\n")): + if not line.startswith("Import from module"): + continue + line = line[len("Import from module"):].strip(":").strip() + dlls.append(line) + return dlls + + def _find_dll_abs_path(self, dll_name: str) -> Optional[str]: + """Find the absolute path of a specific DLL file specified""" + if dll_name in self._dll_cache: + return self._dll_cache[dll_name] + printf("Looking for path of {}...".format(dll_name), end="") + for var in ("PATH", "DLL_SEARCH_DIRECTORIES"): + printf(".", end="") + val = os.environ.get(var, "") + for dir in val.split(";"): + if not os.path.exists(dir) and os.path.isdir(dir): + continue + if dir not in self.walked: + self.walked[dir] = list(os.walk(dir)) + for dirpath, subdirs, files in self.walked[dir]: + if dll_name in files: + p = os.path.join(dirpath, dll_name) + printf(" Found: {}".format(p)) + self._dll_cache[dll_name] = p + return p + printf("Not found.") + self._dll_cache[dll_name] = None + return None + + def copy_to_target(self, target: str): + for p in self.dependency_dll_files: + if os.path.basename(p) in self.EXCLUDE: + continue + elif os.path.basename(p) in self._specials: + t = os.path.join(target, *self._specials[os.path.basename(p)].split("/"), os.path.basename(p)) + d = os.path.dirname(t) + if not os.path.exists(d): + os.makedirs(d) + printf("Copying special {} -> {}".format(p, t)) + shutil.copyfile(p, t) + else: + printf("Copying {}".format(p)) + shutil.copyfile(p, os.path.join(target, os.path.basename(p))) + + specials={ + "libpixmap.dll": "lib/gtk-2.0/2.10.0/engines/", + "libwimp.dll": "lib/gtk-2.0/2.10.0/engines/", + "loaders.cache": "lib/gdk-pixbuf-2.0/2.10.0/"} # loaders.cache is used to specify abspaths to the loaders + specials.update({"libpixbufloader-{}.dll".format(fmt): "/lib/gdk-pixbuf-2.0/2.10.0/loaders/" + for fmt in ["ani", "bmp", "gif", "icns", "ico", "jpeg", "png", "pnm", "qtif", "svg", "tga", "tiff", "xbm", "xpm"]}) + DependencyWalker("libgttk.dll", specials=specials).copy_to_target("gttk") + + # If loaders.cache is not found, it must be generated + cache_file = os.path.join("gttk", specials["loaders.cache"], "loaders.cache") + if not os.path.exists(cache_file) or os.path.getsize(cache_file) < 1024: # Minimum expected file size + print("Creating loaders.cache file...") + with open("loaders.cache", "wb") as fo: + sp.call(["gdk-pixbuf-query-loaders"], stdout=fo) + shutil.copyfile("loaders.cache", cache_file) + with open(cache_file) as fi: + print("gdk-pixbuf-query-loaders gave {} lines of output".format(len(fi.readlines()))) + + kwargs = {"package_data": {"gttk": ["*.dll", "pkgIndex.tcl", "gttk.tcl"] + ["{}/{}".format(dir.strip("/"), base) for base, dir in specials.items()]}} + +else: + printf("Only Linux and Windows are currently supported by the build system") + printf("If you wish to help design a build method for your OS, please") + printf("contact the project author.") + raise RuntimeError("Unsupported platform") + +setup( + name="gttk", + version="v0.6.1", + packages=["gttk"], + description="GTK theme for Tkinter/ttk", + author="The gttk/tile-gtk/gttk authors", + url="https://github.com/RedFantom/python-gttk", + download_url="https://github.com/RedFantom/python-gttk/releases", + license="GNU GPLv3", + long_description_content_type="text/markdown", + long_description=read("README.md"), + zip_safe=False, + **kwargs +) diff --git a/tests/test_widgets.py b/tests/test_widgets.py new file mode 100644 index 0000000..24c3528 --- /dev/null +++ b/tests/test_widgets.py @@ -0,0 +1,66 @@ +""" +Author: RedFantom +License: GNU GPLv3 +Copyright (c) 2017-2018 RedFantom +""" +import sys +from unittest import TestCase +import tkinter as tk +from tkinter import ttk +from gttk import GTTK + + +def printf(string, end="\n"): + sys.__stdout__.write(string + end) + sys.__stdout__.flush() + + +class TestThemedWidgets(TestCase): + """ + Tkinter may crash if widgets are not configured properly in a theme. + Therefore, in addition to checking if all files for a theme exist + by loading it, this Test also tests every core ttk widget to see + if the widget can be successfully created with the theme data. + + When Tkinter crashes, it keeps the Global Interpreter Lock in place, + so the program actually has to be terminated with SIGTERM. + Therefore, this test only executes on UNIX. + """ + WIDGETS = [ + "Label", + "Treeview", + "Button", + "Frame", + "Notebook", + "Progressbar", + "Scrollbar", + "Scale", + "Entry", + "Combobox" + ] + + def setUp(self): + self.window = tk.Tk() + self.gttk = GTTK(self.window) + self.style = ttk.Style() + + def test_widget_creation(self): + try: + import signal + except ImportError: + pass + signal_available = "signal" in locals() and hasattr(locals()["signal"], "alarm") + theme = "gttk" + self.style.theme_use(theme) + for widget in self.WIDGETS: + if signal_available: + signal.alarm(5) + printf("Testing {}: {}".format(theme, widget), end=" - ") + getattr(ttk, widget)(self.window).pack() + self.window.update() + if signal_available: + signal.alarm(0) + printf("SUCCESS") + + def tearDown(self): + self.window.destroy() diff --git a/ttk-theme-chooser.png b/ttk-theme-chooser.png deleted file mode 100644 index df85859..0000000 Binary files a/ttk-theme-chooser.png and /dev/null differ pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy