TDE
/
rosegarden
6
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Compare commits

merge into: TDE:master
Branches Tags
TDE:r14.1.x
TDE:master
TDE:r14.0.x
TDE:v3.5.13-sru
...
pull from: TDE:r14.1.x
Branches Tags
TDE:r14.1.x
TDE:master
TDE:r14.0.x
TDE:v3.5.13-sru

23 Commits
master ... r14.1.x

Author SHA1 Message Date
TDE Gitea 1d49f9458e Merge translation files from master branch.
2 weeks ago
TDE Gitea 5daf082bbc Merge translation files from master branch.
2 weeks ago
Slávek Banko 0259ed4cef
Fix compatibility with C++17.
3 weeks ago
TDE Gitea 70ed18b3c2 Merge translation files from master branch.
1 month ago
TDE Gitea 73b0e0f7b9 Merge translation files from master branch.
1 month ago
Michele Calgaro d91402d763
Use centralized cmake version
2 months ago
Michele Calgaro 0adbbf7abc
cmake files: change keywords to lower case
2 months ago
Michele Calgaro 5b68b4621e
Remove unused files
3 months ago
Michele Calgaro 10e90628eb
Replace Qt with TQt
3 months ago
Michele Calgaro a3a855ce18
Use new TQ_METHOD, TQ_SIGNAL, TQ_SLOT defines
4 months ago
Michele Calgaro 0d651f25b2
Remove various '#define' strings - part 6
5 months ago
Michele Calgaro d226182192
Replaced various '#define' with actual strings - part 5
5 months ago
Michele Calgaro ec073d6411
Replaced various '#define' with actual strings - part 4
6 months ago
Michele Calgaro 6bee7afd95
Replaced various '#define' with actual strings - part 3
6 months ago
Slávek Banko d80f3b6c27
Raise the minimum required version of CMake to 3.5.
6 months ago
Michele Calgaro 5a84066555
Replace Qt with TQt
6 months ago
Michele Calgaro 7d34c9951c
Replace various tqtinterface's TQ_* defines with actual types
8 months ago
Michele Calgaro 6be0f33ee5
Replace TQ_*Focus* and TQ_Scale* defines
9 months ago
Michele Calgaro 45016a2fba
Drop TQT_BASE_OBJECT* defines
9 months ago
Michele Calgaro 4015988ca8
Drop TQT_TQ*_CONST defines
9 months ago
Michele Calgaro 3cf3782613
Drop TQT_TQ*_OBJECT defines
9 months ago
Michele Calgaro 3ef4ff2e06
Replace Q_OBJECT with TQ_OBJECT
10 months ago
Michele Calgaro 95194d38ad
Replace _OBJECT_NAME_STRING defines with actual strings. This relates to the merging of tqtinterface with tqt3.
10 months ago
359 changed files with 14464 additions and 4845 deletions
Show Stats

6
CMakeL10n.txt
Unescape View File

@ -9,7 +9,11 @@
#
#################################################
cmake_minimum_required( VERSION 3.1 )
##### set project version ########################
include( TDEVersion )
cmake_minimum_required( VERSION ${TDE_CMAKE_MINIMUM_VERSION} )
##### include our cmake modules #################

52
CMakeLists.txt
Unescape View File

@ -9,7 +9,12 @@
#
#################################################
cmake_minimum_required( VERSION 3.1 )
##### set project version ########################
include( TDEVersion )
cmake_minimum_required( VERSION ${TDE_CMAKE_MINIMUM_VERSION} )
tde_set_project_version( )
##### general package setup #####################
@ -31,21 +36,21 @@ include( FindPkgConfig )
##### set up versioning #########################
# Mark as advanced
MARK_AS_ADVANCED(EXECUTABLE_OUTPUT_PATH
mark_as_advanced(EXECUTABLE_OUTPUT_PATH
LIBRARY_OUTPUT_PATH
CMAKE_BACKWARDS_COMPATIBILITY)
# Rosegarden version string
SET (VERSION_MAJOR "1")
SET (VERSION_MINOR "7")
SET (VERSION_PATCH "0")
set (VERSION_MAJOR "1")
set (VERSION_MINOR "7")
set (VERSION_PATCH "0")
# comment out the next line for a public release
#SET (VERSION_SUFFIX "svn")
SET (PACKAGE_VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH})
IF(VERSION_SUFFIX)
SET (PACKAGE_VERSION "${PACKAGE_VERSION}-${VERSION_SUFFIX}")
ENDIF(VERSION_SUFFIX)
ADD_DEFINITIONS(-D'VERSION="${PACKAGE_VERSION}"')
#set (VERSION_SUFFIX "svn")
set (PACKAGE_VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH})
if(VERSION_SUFFIX)
set (PACKAGE_VERSION "${PACKAGE_VERSION}-${VERSION_SUFFIX}")
endif(VERSION_SUFFIX)
add_definitions(-D'VERSION="${PACKAGE_VERSION}"')
##### include our cmake modules #################
@ -53,11 +58,6 @@ ADD_DEFINITIONS(-D'VERSION="${PACKAGE_VERSION}"')
include( TDEMacros )
##### set version number ########################
tde_set_project_version( )
##### setup install paths #######################
include( TDESetupPaths )
@ -78,15 +78,15 @@ option( WANT_LIRC "Include LIRC (Linux Infrared Remote Control) support" OFF
option( WANT_PCH "Use precompiled headers" OFF )
option( WANT_TEST "Perform unit tests" OFF )
IF(WANT_TEST)
ENABLE_TESTING()
ENDIF(WANT_TEST)
if(WANT_TEST)
enable_testing()
endif(WANT_TEST)
IF(NOT WANT_SOUND)
SET(WANT_JACK OFF)
SET(WANT_DSSI OFF)
ADD_DEFINITIONS(-DNO_SOUND)
ENDIF(NOT WANT_SOUND)
if(NOT WANT_SOUND)
set(WANT_JACK OFF)
set(WANT_DSSI OFF)
add_definitions(-DNO_SOUND)
endif(NOT WANT_SOUND)
##### configure checks ##########################
@ -117,5 +117,5 @@ tde_conditional_add_project_translations( BUILD_TRANSLATIONS )
configure_file( config.h.cmake config.h @ONLY )
# create and install the version file
FILE(WRITE "${CMAKE_BINARY_DIR}/version.txt" "${PACKAGE_VERSION}\n")
INSTALL( FILES "${CMAKE_BINARY_DIR}/version.txt" DESTINATION ${DATA_INSTALL_DIR}/rosegarden )
file(WRITE "${CMAKE_BINARY_DIR}/version.txt" "${PACKAGE_VERSION}\n")
install( FILES "${CMAKE_BINARY_DIR}/version.txt" DESTINATION ${DATA_INSTALL_DIR}/rosegarden )

340
ConfigureChecks.cmake
Unescape View File

@ -30,93 +30,93 @@ endif( )
# Initialize some variables
SET(HAVE_XFT FALSE)
SET(HAVE_ALSA FALSE)
SET(HAVE_JACK FALSE)
SET(HAVE_DSSI FALSE)
SET(HAVE_LIBLO FALSE)
SET(HAVE_LIBLRDF FALSE)
SET(HAVE_LADSPA FALSE)
SET(HAVE_LIRC FALSE)
SET(HAVE_FFTW3F FALSE)
set(HAVE_XFT FALSE)
set(HAVE_ALSA FALSE)
set(HAVE_JACK FALSE)
set(HAVE_DSSI FALSE)
set(HAVE_LIBLO FALSE)
set(HAVE_LIBLRDF FALSE)
set(HAVE_LADSPA FALSE)
set(HAVE_LIRC FALSE)
set(HAVE_FFTW3F FALSE)
# Check for Xft
PKG_CHECK_MODULES(XFT xft>=2.1.0)
IF(XFT_FOUND)
ADD_DEFINITIONS(-DHAVE_XFT)
SET(HAVE_XFT TRUE)
SET(XFT_LIBS ${XFT_LIBRARIES})
#MESSAGE("XFT_LIBS: ${XFT_LIBS}")
LIST(APPEND XFT_LIB_DIR ${XFT_LIBRARY_DIRS} ${XFT_LIBDIR})
#MESSAGE("XFT_LIB_DIR: ${XFT_LIB_DIR}")
LIST(APPEND XFT_INC_DIR ${XFT_INCLUDE_DIRS} ${XFT_INCLUDEDIR})
#MESSAGE("XFT_INC_DIR: ${XFT_INC_DIR}")
ENDIF(XFT_FOUND)
IF(WANT_SOUND)
pkg_check_modules(XFT xft>=2.1.0)
if(XFT_FOUND)
add_definitions(-DHAVE_XFT)
set(HAVE_XFT TRUE)
set(XFT_LIBS ${XFT_LIBRARIES})
#message("XFT_LIBS: ${XFT_LIBS}")
list(APPEND XFT_LIB_DIR ${XFT_LIBRARY_DIRS} ${XFT_LIBDIR})
#message("XFT_LIB_DIR: ${XFT_LIB_DIR}")
list(APPEND XFT_INC_DIR ${XFT_INCLUDE_DIRS} ${XFT_INCLUDEDIR})
#message("XFT_INC_DIR: ${XFT_INC_DIR}")
endif(XFT_FOUND)
if(WANT_SOUND)
# Check for ALSA 1.0
PKG_CHECK_MODULES(ALSA REQUIRED alsa>=1.0)
IF(ALSA_FOUND)
SET(HAVE_ALSA TRUE)
ADD_DEFINITIONS(-DHAVE_ALSA)
SET(ALSA_LIBS ${ALSA_LIBRARIES})
#MESSAGE("ALSA_LIBS: ${ALSA_LIBS}")
LIST(APPEND ALSA_LIB_DIR ${ALSA_LIBRARY_DIRS} ${ALSA_LIBDIR} )
#MESSAGE("ALSA_LIB_DIR: ${ALSA_LIB_DIR}")
LIST(APPEND ALSA_INC_DIR ${ALSA_INCLUDE_DIRS} ${ALSA_INCLUDEDIR})
#MESSAGE("ALSA_INC_DIR: ${ALSA_INC_DIR}")
ELSE(ALSA_FOUND)
MESSAGE(FATAL_ERROR "Please install the required package. Aborting")
ENDIF(ALSA_FOUND)
IF(WANT_JACK)
PKG_CHECK_MODULES(JACK jack>=0.77)
IF(JACK_FOUND)
ADD_DEFINITIONS(-DHAVE_LIBJACK)
SET(HAVE_JACK TRUE)
SET(JACK_LIBS ${JACK_LIBRARIES})
#MESSAGE("JACK_LIBS: ${JACK_LIBS}")
LIST(APPEND JACK_LIB_DIR ${JACK_LIBDIR} ${JACK_LIBRARY_DIRS})
#MESSAGE("JACK_LIB_DIR: ${JACK_LIB_DIR}")
LIST(APPEND JACK_INC_DIR ${JACK_INCLUDEDIR} ${JACK_INCLUDE_DIRS})
#MESSAGE("JACK_INC_DIR: ${JACK_INC_DIR}")
ENDIF(JACK_FOUND)
ENDIF(WANT_JACK)
IF(WANT_DSSI)
PKG_CHECK_MODULES(DSSI dssi>=0.4)
IF(DSSI_FOUND)
ADD_DEFINITIONS(-DHAVE_DSSI)
SET(HAVE_DSSI TRUE)
LIST(APPEND DSSI_INC_DIR ${DSSI_INCLUDE_DIRS} ${DSSI_INCLUDEDIR})
#MESSAGE("DSSI_INC_DIR: ${DSSI_INC_DIR}")
ENDIF(DSSI_FOUND)
ENDIF(WANT_DSSI)
PKG_CHECK_MODULES(LIBLO liblo>=0.7)
IF(LIBLO_FOUND)
ADD_DEFINITIONS(-DHAVE_LIBLO)
SET(HAVE_LIBLO TRUE)
SET(LIBLO_LIBS ${LIBLO_LIBRARIES})
#MESSAGE("LIBLO_LIBS: ${LIBLO_LIBS}")
LIST(APPEND LIBLO_LIB_DIR ${LIBLO_LIBDIR} ${LIBLO_LIBRARY_DIRS})
#MESSAGE("LIBLO_LIB_DIR: ${LIBLO_LIB_DIR}")
LIST(APPEND LIBLO_INC_DIR ${LIBLO_INCLUDEDIR} ${LIBLO_INCLUDE_DIRS})
#MESSAGE("LIBLO_INC_DIR: ${LIBLO_INC_DIR}")
ENDIF(LIBLO_FOUND)
PKG_CHECK_MODULES(LRDF lrdf>=0.3)
IF(LRDF_FOUND)
SET(HAVE_LIBLRDF TRUE)
ADD_DEFINITIONS(-DHAVE_LIBLRDF)
SET(LRDF_LIBS ${LRDF_LIBRARIES})
#MESSAGE("LRDF_LIBS: ${LRDF_LIBS}")
LIST(APPEND LRDF_LIB_DIR ${LRDF_LIBDIR} ${LRDF_LIBRARY_DIRS})
#MESSAGE("LRDF_LIB_DIR: ${LRDF_LIB_DIR}")
LIST(APPEND LRDF_INC_DIR ${LRDF_INCLUDEDIR} ${LRDF_INCLUDE_DIRS})
#MESSAGE("LRDF_INC_DIR: ${LRDF_INC_DIR}")
ENDIF(LRDF_FOUND)
pkg_check_modules(ALSA REQUIRED alsa>=1.0)
if(ALSA_FOUND)
set(HAVE_ALSA TRUE)
add_definitions(-DHAVE_ALSA)
set(ALSA_LIBS ${ALSA_LIBRARIES})
#message("ALSA_LIBS: ${ALSA_LIBS}")
list(APPEND ALSA_LIB_DIR ${ALSA_LIBRARY_DIRS} ${ALSA_LIBDIR} )
#message("ALSA_LIB_DIR: ${ALSA_LIB_DIR}")
list(APPEND ALSA_INC_DIR ${ALSA_INCLUDE_DIRS} ${ALSA_INCLUDEDIR})
#message("ALSA_INC_DIR: ${ALSA_INC_DIR}")
else(ALSA_FOUND)
message(FATAL_ERROR "Please install the required package. Aborting")
endif(ALSA_FOUND)
if(WANT_JACK)
pkg_check_modules(JACK jack>=0.77)
if(JACK_FOUND)
add_definitions(-DHAVE_LIBJACK)
set(HAVE_JACK TRUE)
set(JACK_LIBS ${JACK_LIBRARIES})
#message("JACK_LIBS: ${JACK_LIBS}")
list(APPEND JACK_LIB_DIR ${JACK_LIBDIR} ${JACK_LIBRARY_DIRS})
#message("JACK_LIB_DIR: ${JACK_LIB_DIR}")
list(APPEND JACK_INC_DIR ${JACK_INCLUDEDIR} ${JACK_INCLUDE_DIRS})
#message("JACK_INC_DIR: ${JACK_INC_DIR}")
endif(JACK_FOUND)
endif(WANT_JACK)
if(WANT_DSSI)
pkg_check_modules(DSSI dssi>=0.4)
if(DSSI_FOUND)
add_definitions(-DHAVE_DSSI)
set(HAVE_DSSI TRUE)
list(APPEND DSSI_INC_DIR ${DSSI_INCLUDE_DIRS} ${DSSI_INCLUDEDIR})
#message("DSSI_INC_DIR: ${DSSI_INC_DIR}")
endif(DSSI_FOUND)
endif(WANT_DSSI)
pkg_check_modules(LIBLO liblo>=0.7)
if(LIBLO_FOUND)
add_definitions(-DHAVE_LIBLO)
set(HAVE_LIBLO TRUE)
set(LIBLO_LIBS ${LIBLO_LIBRARIES})
#message("LIBLO_LIBS: ${LIBLO_LIBS}")
list(APPEND LIBLO_LIB_DIR ${LIBLO_LIBDIR} ${LIBLO_LIBRARY_DIRS})
#message("LIBLO_LIB_DIR: ${LIBLO_LIB_DIR}")
list(APPEND LIBLO_INC_DIR ${LIBLO_INCLUDEDIR} ${LIBLO_INCLUDE_DIRS})
#message("LIBLO_INC_DIR: ${LIBLO_INC_DIR}")
endif(LIBLO_FOUND)
pkg_check_modules(LRDF lrdf>=0.3)
if(LRDF_FOUND)
set(HAVE_LIBLRDF TRUE)
add_definitions(-DHAVE_LIBLRDF)
set(LRDF_LIBS ${LRDF_LIBRARIES})
#message("LRDF_LIBS: ${LRDF_LIBS}")
list(APPEND LRDF_LIB_DIR ${LRDF_LIBDIR} ${LRDF_LIBRARY_DIRS})
#message("LRDF_LIB_DIR: ${LRDF_LIB_DIR}")
list(APPEND LRDF_INC_DIR ${LRDF_INCLUDEDIR} ${LRDF_INCLUDE_DIRS})
#message("LRDF_INC_DIR: ${LRDF_INC_DIR}")
endif(LRDF_FOUND)
##################################################################
# - Try to find LADSPA header
@ -124,115 +124,115 @@ IF(WANT_SOUND)
#
# LADSPA_FOUND - system has LADSPA
# LADSPA_INCLUDE_DIR - LADSPA header path
IF(LADSPA_INCLUDE_DIR)
SET(LADSPA_FIND_QUIETLY TRUE)
ENDIF(LADSPA_INCLUDE_DIR)
FIND_PATH(LADSPA_INCLUDE_DIR "ladspa.h"
if(LADSPA_INCLUDE_DIR)
set(LADSPA_FIND_QUIETLY TRUE)
endif(LADSPA_INCLUDE_DIR)
find_path(LADSPA_INCLUDE_DIR "ladspa.h"
/usr/include
/usr/local/include
)
IF(LADSPA_INCLUDE_DIR)
SET(LADSPA_FOUND TRUE)
ELSE(LADSPA_INCLUDE_DIR)
SET(LADSPA_FOUND FALSE)
SET(LADSPA_INCLUDE_DIR "")
ENDIF(LADSPA_INCLUDE_DIR)
IF(LADSPA_FOUND)
IF(NOT LADSPA_FIND_QUIETLY)
MESSAGE(STATUS "Found LADSPA: ${LADSPA_INCLUDE_DIR}")
ENDIF(NOT LADSPA_FIND_QUIETLY)
ELSE(LADSPA_FOUND)
IF(LADSPA_FIND_REQUIRED)
MESSAGE(FATAL_ERROR "Could not find LADSPA")
ENDIF(LADSPA_FIND_REQUIRED)
ENDIF(LADSPA_FOUND)
MARK_AS_ADVANCED(LADSPA_INCLUDE_DIR)
if(LADSPA_INCLUDE_DIR)
set(LADSPA_FOUND TRUE)
else(LADSPA_INCLUDE_DIR)
set(LADSPA_FOUND FALSE)
set(LADSPA_INCLUDE_DIR "")
endif(LADSPA_INCLUDE_DIR)
if(LADSPA_FOUND)
if(NOT LADSPA_FIND_QUIETLY)
message(STATUS "Found LADSPA: ${LADSPA_INCLUDE_DIR}")
endif(NOT LADSPA_FIND_QUIETLY)
else(LADSPA_FOUND)
if(LADSPA_FIND_REQUIRED)
message(FATAL_ERROR "Could not find LADSPA")
endif(LADSPA_FIND_REQUIRED)
endif(LADSPA_FOUND)
mark_as_advanced(LADSPA_INCLUDE_DIR)
##################################################################
IF(LADSPA_FOUND)
SET(HAVE_LADSPA TRUE)
ADD_DEFINITIONS(-DHAVE_LADSPA)
SET(LADSPA_INC_DIR ${LADSPA_INCLUDE_DIR})
ENDIF(LADSPA_FOUND)
ENDIF(WANT_SOUND)
PKG_CHECK_MODULES(FFTW3F REQUIRED fftw3f>=3.0.0)
IF(FFTW3F_FOUND)
ADD_DEFINITIONS(-DHAVE_FFTW3F)
SET(HAVE_FFTW3F TRUE)
SET(FFTW3F_LIBS ${FFTW3F_LIBRARIES})
#MESSAGE("FFTW3F_LIBS: ${FFTW3F_LIBS}")
LIST(APPEND FFTW3F_LIB_DIR ${FFTW3F_LIBDIR} ${FFTW3F_LIBRARY_DIRS})
#MESSAGE("FFTW3F_LIB_DIR: ${FFTW3F_LIB_DIR}")
LIST(APPEND FFTW3F_INC_DIR ${FFTW3F_INCLUDEDIR} ${FFTW3F_INCLUDE_DIRS})
#MESSAGE("FFTW3F_INC_DIR: ${FFTW3F_INC_DIR}")
ELSE(FFTW3F_FOUND)
MESSAGE(FATAL_ERROR "Please install the required package. Aborting")
ENDIF(FFTW3F_FOUND)
IF(WANT_LIRC)
FIND_PACKAGE(LIRC QUIET)
IF(LIRC_FOUND)
SET(HAVE_LIRC TRUE)
ADD_DEFINITIONS(-DHAVE_LIRC)
MESSAGE(STATUS "Found LIRC (${LIRC_LIBRARY})")
SET(LIRC_LIBS ${LIRC_LIBRARY})
SET(LIRC_INC_DIR ${LIRC_INCLUDE_DIR})
SET(LIRC_LIB_DIR ${LIRC_LIBRARY_DIR})
#MESSAGE("LIRC_LIBS: ${LIRC_LIBS}")
#MESSAGE("LIRC_LIB_DIR: ${LIRC_LIB_DIR}")
#MESSAGE("LIRC_INC_DIR: ${LIRC_INC_DIR}")
ENDIF(LIRC_FOUND)
ENDIF(WANT_LIRC)
if(LADSPA_FOUND)
set(HAVE_LADSPA TRUE)
add_definitions(-DHAVE_LADSPA)
set(LADSPA_INC_DIR ${LADSPA_INCLUDE_DIR})
endif(LADSPA_FOUND)
endif(WANT_SOUND)
pkg_check_modules(FFTW3F REQUIRED fftw3f>=3.0.0)
if(FFTW3F_FOUND)
add_definitions(-DHAVE_FFTW3F)
set(HAVE_FFTW3F TRUE)
set(FFTW3F_LIBS ${FFTW3F_LIBRARIES})
#message("FFTW3F_LIBS: ${FFTW3F_LIBS}")
list(APPEND FFTW3F_LIB_DIR ${FFTW3F_LIBDIR} ${FFTW3F_LIBRARY_DIRS})
#message("FFTW3F_LIB_DIR: ${FFTW3F_LIB_DIR}")
list(APPEND FFTW3F_INC_DIR ${FFTW3F_INCLUDEDIR} ${FFTW3F_INCLUDE_DIRS})
#message("FFTW3F_INC_DIR: ${FFTW3F_INC_DIR}")
else(FFTW3F_FOUND)
message(FATAL_ERROR "Please install the required package. Aborting")
endif(FFTW3F_FOUND)
if(WANT_LIRC)
find_package(LIRC QUIET)
if(LIRC_FOUND)
set(HAVE_LIRC TRUE)
add_definitions(-DHAVE_LIRC)
message(STATUS "Found LIRC (${LIRC_LIBRARY})")
set(LIRC_LIBS ${LIRC_LIBRARY})
set(LIRC_INC_DIR ${LIRC_INCLUDE_DIR})
set(LIRC_LIB_DIR ${LIRC_LIBRARY_DIR})
#message("LIRC_LIBS: ${LIRC_LIBS}")
#message("LIRC_LIB_DIR: ${LIRC_LIB_DIR}")
#message("LIRC_INC_DIR: ${LIRC_INC_DIR}")
endif(LIRC_FOUND)
endif(WANT_LIRC)
# Check GCC for PCH support
SET(USE_PCH FALSE)
IF(WANT_PCH)
FIND_PACKAGE(PCHSupport)
IF(PCHSupport_FOUND)
SET(USE_PCH TRUE)
ADD_DEFINITIONS(-DUSE_PCH)
MESSAGE(STATUS "Enabling precompiled headers for GCC ${gcc_compiler_version}")
ENDIF(PCHSupport_FOUND)
ENDIF(WANT_PCH)
set(USE_PCH FALSE)
if(WANT_PCH)
find_package(PCHSupport)
if(PCHSupport_FOUND)
set(USE_PCH TRUE)
add_definitions(-DUSE_PCH)
message(STATUS "Enabling precompiled headers for GCC ${gcc_compiler_version}")
endif(PCHSupport_FOUND)
endif(WANT_PCH)
# Check PTHREAD_MUTEX_RECURSIVE
INCLUDE(CheckCSourceCompiles)
CHECK_C_SOURCE_COMPILES(
include(CheckCSourceCompiles)
check_c_source_compiles(
"#include <pthread.h>
int main(int argc, char **argv) {
pthread_mutexattr_t attr;
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
return 0;
}" PTHREAD_HAS_MUTEX_RECURSIVE)
IF(PTHREAD_HAS_MUTEX_RECURSIVE)
ADD_DEFINITIONS(-DHAVE_PTHREAD_MUTEX_RECURSIVE)
ENDIF(PTHREAD_HAS_MUTEX_RECURSIVE)
if(PTHREAD_HAS_MUTEX_RECURSIVE)
add_definitions(-DHAVE_PTHREAD_MUTEX_RECURSIVE)
endif(PTHREAD_HAS_MUTEX_RECURSIVE)
# End of PTHREAD_MUTEX_RECURSIVE Test
SET(CMAKE_CXX_FLAGS_RELEASE "-O2 -w -fexceptions -DNDEBUG -include tqt.h")
SET(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g -Wall -fexceptions -DDEBUG -include tqt.h")
SET(CMAKE_CXX_FLAGS_DEBUG "-O0 -g3 -Wall -fexceptions -DDEBUG -include tqt.h")
set(CMAKE_CXX_FLAGS_RELEASE "-O2 -w -fexceptions -DNDEBUG -include tqt.h")
set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g -Wall -fexceptions -DDEBUG -include tqt.h")
set(CMAKE_CXX_FLAGS_DEBUG "-O0 -g3 -Wall -fexceptions -DDEBUG -include tqt.h")
MESSAGE(STATUS "Rosegarden ${PACKAGE_VERSION} will be built for install into ${CMAKE_INSTALL_PREFIX}")
message(STATUS "Rosegarden ${PACKAGE_VERSION} will be built for install into ${CMAKE_INSTALL_PREFIX}")
IF(WANT_DEBUG)
IF(WANT_FULLDBG)
MESSAGE(STATUS "Configured to compile including full debug information in the executables")
SET(CMAKE_BUILD_TYPE Debug CACHE STRING
if(WANT_DEBUG)
if(WANT_FULLDBG)
message(STATUS "Configured to compile including full debug information in the executables")
set(CMAKE_BUILD_TYPE Debug CACHE STRING
"Choose the type of build, options are: Debug Release RelWithDebInfo" FORCE)
ELSE(WANT_FULLDBG)
MESSAGE(STATUS "Configured to compile including debug information in the executables")
SET(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING
else(WANT_FULLDBG)
message(STATUS "Configured to compile including debug information in the executables")
set(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING
"Choose the type of build, options are: Debug Release RelWithDebInfo" FORCE)
ENDIF(WANT_FULLDBG)
ELSE(WANT_DEBUG)
MESSAGE(STATUS "Configured to compile for release without debug information")
SET(CMAKE_BUILD_TYPE Release CACHE STRING
endif(WANT_FULLDBG)
else(WANT_DEBUG)
message(STATUS "Configured to compile for release without debug information")
set(CMAKE_BUILD_TYPE Release CACHE STRING
"Choose the type of build, options are: Debug Release RelWithDebInfo" FORCE)
ENDIF(WANT_DEBUG)
MARK_AS_ADVANCED(CMAKE_BUILD_TYPE)
endif(WANT_DEBUG)
mark_as_advanced(CMAKE_BUILD_TYPE)
check_type_size( "int" SIZEOF_INT BUILTIN_TYPES_ONLY )
check_type_size( "long" SIZEOF_LONG BUILTIN_TYPES_ONLY )

1232
Doxyfile
View File

File diff suppressed because it is too large Load Diff

2
INSTALL
Unescape View File

@ -114,7 +114,7 @@ $ ccmake .
Dealing with Configuration Problems
-----------------------------------
To locate Qt, CMake searches for qmake in your execute path
To locate TQt, CMake searches for qmake in your execute path
($PATH). CMake does not use the TQTDIR environment variable. So make
sure that the first qmake found in the execution path is the one you
like to use.

4
TRANSLATORS
Unescape View File

@ -1,4 +0,0 @@
Please see the AUTHORS file for a list of translators.
If you'd like to translate Rosegarden into your language, contact us at
<rosegarden-devel@lists.sourceforge.net>

106
data/CMakeLists.txt
Unescape View File

@ -1,13 +1,13 @@
# Data directory
SET(DATADIR ${DATA_INSTALL_DIR}/rosegarden)
SET(ICONDIR ${ICON_INSTALL_DIR})
SET(MIMEDIR ${MIME_INSTALL_DIR}/audio)
SET(MENUDIR ${XDG_MENU_INSTALL_DIR})
set(DATADIR ${DATA_INSTALL_DIR}/rosegarden)
set(ICONDIR ${ICON_INSTALL_DIR})
set(MIMEDIR ${MIME_INSTALL_DIR}/audio)
set(MENUDIR ${XDG_MENU_INSTALL_DIR})
# Guitar chord files
FILE(GLOB CHORD_FILES chords/*.xml)
INSTALL(FILES ${CHORD_FILES} DESTINATION ${DATADIR}/chords)
file(GLOB CHORD_FILES chords/*.xml)
install(FILES ${CHORD_FILES} DESTINATION ${DATADIR}/chords)
# Desktop file
tde_create_translated_desktop( desktop/rosegarden.desktop )
@ -24,70 +24,70 @@ tde_create_translated_desktop(
)
# Icons
INSTALL(FILES pixmaps/icons/cc-hi16-rosegarden.xpm DESTINATION ${ICONDIR}/locolor/16x16/apps RENAME rosegarden.xpm)
INSTALL(FILES pixmaps/icons/rg-rwb-rose3-16x16.png DESTINATION ${ICONDIR}/hicolor/16x16/apps RENAME rosegarden.png)
INSTALL(FILES pixmaps/icons/cc-hi32-rosegarden.xpm DESTINATION ${ICONDIR}/locolor/32x32/apps RENAME rosegarden.xpm)
INSTALL(FILES pixmaps/icons/rg-rwb-rose3-32x32.png DESTINATION ${ICONDIR}/hicolor/32x32/apps RENAME rosegarden.png)
INSTALL(FILES pixmaps/icons/rg-rwb-rose3-48x48.png DESTINATION ${ICONDIR}/hicolor/48x48/apps RENAME rosegarden.png)
INSTALL(FILES pixmaps/icons/rg-rwb-rose3-64x64.png DESTINATION ${ICONDIR}/hicolor/64x64/apps RENAME rosegarden.png)
INSTALL(FILES pixmaps/icons/rg-rwb-rose3-128x128.png DESTINATION ${ICONDIR}/hicolor/128x128/apps RENAME rosegarden.png)
INSTALL(FILES pixmaps/icons/mm-mime-hi16-rosegarden.png DESTINATION ${ICONDIR}/hicolor/16x16/mimetypes RENAME x-rosegarden.png)
INSTALL(FILES pixmaps/icons/mm-mime-hi16-rosegarden.png DESTINATION ${ICONDIR}/locolor/16x16/mimetypes RENAME x-rosegarden.png)
INSTALL(FILES pixmaps/icons/mm-mime-hi32-rosegarden.png DESTINATION ${ICONDIR}/hicolor/32x32/mimetypes RENAME x-rosegarden.png)
INSTALL(FILES pixmaps/icons/mm-mime-hi32-rosegarden.png DESTINATION ${ICONDIR}/locolor/32x32/mimetypes RENAME x-rosegarden.png)
install(FILES pixmaps/icons/cc-hi16-rosegarden.xpm DESTINATION ${ICONDIR}/locolor/16x16/apps RENAME rosegarden.xpm)
install(FILES pixmaps/icons/rg-rwb-rose3-16x16.png DESTINATION ${ICONDIR}/hicolor/16x16/apps RENAME rosegarden.png)
install(FILES pixmaps/icons/cc-hi32-rosegarden.xpm DESTINATION ${ICONDIR}/locolor/32x32/apps RENAME rosegarden.xpm)
install(FILES pixmaps/icons/rg-rwb-rose3-32x32.png DESTINATION ${ICONDIR}/hicolor/32x32/apps RENAME rosegarden.png)
install(FILES pixmaps/icons/rg-rwb-rose3-48x48.png DESTINATION ${ICONDIR}/hicolor/48x48/apps RENAME rosegarden.png)
install(FILES pixmaps/icons/rg-rwb-rose3-64x64.png DESTINATION ${ICONDIR}/hicolor/64x64/apps RENAME rosegarden.png)
install(FILES pixmaps/icons/rg-rwb-rose3-128x128.png DESTINATION ${ICONDIR}/hicolor/128x128/apps RENAME rosegarden.png)
install(FILES pixmaps/icons/mm-mime-hi16-rosegarden.png DESTINATION ${ICONDIR}/hicolor/16x16/mimetypes RENAME x-rosegarden.png)
install(FILES pixmaps/icons/mm-mime-hi16-rosegarden.png DESTINATION ${ICONDIR}/locolor/16x16/mimetypes RENAME x-rosegarden.png)
install(FILES pixmaps/icons/mm-mime-hi32-rosegarden.png DESTINATION ${ICONDIR}/hicolor/32x32/mimetypes RENAME x-rosegarden.png)
install(FILES pixmaps/icons/mm-mime-hi32-rosegarden.png DESTINATION ${ICONDIR}/locolor/32x32/mimetypes RENAME x-rosegarden.png)
# styles
FILE(GLOB STYLES_FILES styles/*.xml)
INSTALL(FILES ${STYLES_FILES} DESTINATION ${DATADIR}/styles)
file(GLOB STYLES_FILES styles/*.xml)
install(FILES ${STYLES_FILES} DESTINATION ${DATADIR}/styles)
# presets
FILE(GLOB PRESETS_FILES presets/*.xml)
INSTALL(FILES ${PRESETS_FILES} DESTINATION ${DATADIR}/presets)
file(GLOB PRESETS_FILES presets/*.xml)
install(FILES ${PRESETS_FILES} DESTINATION ${DATADIR}/presets)
# fonts
FILE(GLOB PFA_FILES fonts/*.pfa)
INSTALL(FILES ${PFA_FILES} DESTINATION ${DATADIR}/fonts)
file(GLOB PFA_FILES fonts/*.pfa)
install(FILES ${PFA_FILES} DESTINATION ${DATADIR}/fonts)
FILE(GLOB XML_FILES fonts/mappings/*.xml)
INSTALL(FILES ${XML_FILES} DESTINATION ${DATADIR}/fonts/mappings)
file(GLOB XML_FILES fonts/mappings/*.xml)
install(FILES ${XML_FILES} DESTINATION ${DATADIR}/fonts/mappings)
FILE(GLOB XPM_FILES pixmaps/rg21/4/*.xpm)
INSTALL(FILES ${XPM_FILES} DESTINATION ${DATADIR}/fonts/rg21/4)
file(GLOB XPM_FILES pixmaps/rg21/4/*.xpm)
install(FILES ${XPM_FILES} DESTINATION ${DATADIR}/fonts/rg21/4)
FILE(GLOB XPM_FILES pixmaps/rg21/8/*.xpm)
INSTALL(FILES ${XPM_FILES} DESTINATION ${DATADIR}/fonts/rg21/8)
file(GLOB XPM_FILES pixmaps/rg21/8/*.xpm)
install(FILES ${XPM_FILES} DESTINATION ${DATADIR}/fonts/rg21/8)
FILE(GLOB XPM_FILES pixmaps/feta/4/*.xpm)
INSTALL(FILES ${XPM_FILES} DESTINATION ${DATADIR}/fonts/feta/4)
file(GLOB XPM_FILES pixmaps/feta/4/*.xpm)
install(FILES ${XPM_FILES} DESTINATION ${DATADIR}/fonts/feta/4)
FILE(GLOB XPM_FILES pixmaps/feta/6/*.xpm)
INSTALL(FILES ${XPM_FILES} DESTINATION ${DATADIR}/fonts/feta/6)
file(GLOB XPM_FILES pixmaps/feta/6/*.xpm)
install(FILES ${XPM_FILES} DESTINATION ${DATADIR}/fonts/feta/6)
FILE(GLOB XPM_FILES pixmaps/feta/8/*.xpm)
INSTALL(FILES ${XPM_FILES} DESTINATION ${DATADIR}/fonts/feta/8)
file(GLOB XPM_FILES pixmaps/feta/8/*.xpm)
install(FILES ${XPM_FILES} DESTINATION ${DATADIR}/fonts/feta/8)
FILE(GLOB XPM_FILES pixmaps/feta/10/*.xpm)
INSTALL(FILES ${XPM_FILES} DESTINATION ${DATADIR}/fonts/feta/10)
file(GLOB XPM_FILES pixmaps/feta/10/*.xpm)
install(FILES ${XPM_FILES} DESTINATION ${DATADIR}/fonts/feta/10)
FILE(GLOB XPM_FILES pixmaps/feta/12/*.xpm)
INSTALL(FILES ${XPM_FILES} DESTINATION ${DATADIR}/fonts/feta/12)
file(GLOB XPM_FILES pixmaps/feta/12/*.xpm)
install(FILES ${XPM_FILES} DESTINATION ${DATADIR}/fonts/feta/12)
# pixmaps
FILE(GLOB PIXMAP_FILES pixmaps/misc/*.xpm pixmaps/misc/*.png)
INSTALL(FILES ${PIXMAP_FILES} DESTINATION ${DATADIR}/pixmaps/misc)
file(GLOB PIXMAP_FILES pixmaps/misc/*.xpm pixmaps/misc/*.png)
install(FILES ${PIXMAP_FILES} DESTINATION ${DATADIR}/pixmaps/misc)
FILE(GLOB PIXMAP_FILES pixmaps/toolbar/*.xpm pixmaps/toolbar/*.png)
INSTALL(FILES ${PIXMAP_FILES} DESTINATION ${DATADIR}/pixmaps/toolbar)
file(GLOB PIXMAP_FILES pixmaps/toolbar/*.xpm pixmaps/toolbar/*.png)
install(FILES ${PIXMAP_FILES} DESTINATION ${DATADIR}/pixmaps/toolbar)
FILE(GLOB PIXMAP_FILES pixmaps/transport/*.xpm pixmaps/transport/*.png)
INSTALL(FILES ${PIXMAP_FILES} DESTINATION ${DATADIR}/pixmaps/transport)
file(GLOB PIXMAP_FILES pixmaps/transport/*.xpm pixmaps/transport/*.png)
install(FILES ${PIXMAP_FILES} DESTINATION ${DATADIR}/pixmaps/transport)
# Splash
INSTALL(FILES pixmaps/splash.png DESTINATION ${DATADIR}/pixmaps)
install(FILES pixmaps/splash.png DESTINATION ${DATADIR}/pixmaps)
# Examples
SET(EXAMPLE_FILES
set(EXAMPLE_FILES
examples/aveverum.rg
examples/aylindaamiga.rg
examples/bogus-surf-jam.rg
@ -117,12 +117,12 @@ SET(EXAMPLE_FILES
examples/vivaldi-cs3mv2.rg
examples/vivaldi_op44_11_1.rg )
INSTALL(FILES ${EXAMPLE_FILES} DESTINATION ${DATADIR}/examples)
INSTALL(FILES examples/autoload.rg DESTINATION ${DATADIR})
install(FILES ${EXAMPLE_FILES} DESTINATION ${DATADIR}/examples)
install(FILES examples/autoload.rg DESTINATION ${DATADIR})
# Library
FILE(GLOB RGD_FILES library/*.rgd)
INSTALL(FILES ${RGD_FILES} DESTINATION ${DATADIR}/library)
file(GLOB RGD_FILES library/*.rgd)
install(FILES ${RGD_FILES} DESTINATION ${DATADIR}/library)
# KDE LIRC Profile
INSTALL(FILES profile/rosegarden.profile.xml DESTINATION ${DATA_INSTALL_DIR}/profiles)
install(FILES profile/rosegarden.profile.xml DESTINATION ${DATA_INSTALL_DIR}/profiles)

12
doc/man/rosegarden.1
Unescape View File

@ -7,9 +7,9 @@ musical notation editor.
.SH SYNOPSIS
rosegarden [Qt-options] [TDE-options] [options] [File]
rosegarden [TQt-options] [TDE-options] [options] [File]
rosegardensequencer [Qt-options] [TDE-options] [playback_1 playback_2 capture_1 capture_2]
rosegardensequencer [TQt-options] [TDE-options] [playback_1 playback_2 capture_1 capture_2]
.SH DESCRIPTION
@ -32,8 +32,8 @@ rosegardensequencer is part of the rosegarden application, the part which knows
.BR \-\-help-tde
Show TDE specific options.
.BR \-\-help-qt
Show Qt specific options.
.BR \-\-help-tqt
Show TQt specific options.
.BR \-\-license
Show license information.
@ -63,7 +63,7 @@ rosegardensequencer is part of the rosegarden application, the part which knows
.SH OPTIONS
.BR \-g " " Use graphical mode>
.SH QT OPTIONS
.SH TQt OPTIONS
.BR \-\-bg, --background color
Sets the default background color and an application palette (light and dark shades are calculated).
@ -98,7 +98,7 @@ rosegardensequencer is part of the rosegarden application, the part which knows
Limits the number of colors allocated in the color cube on an 8-bit display, if the application is using the QApplication::ManyColor color specification.
.BR \-\-nograb
Tells Qt to never grab the mouse or the keyboard.
Tells TQt to never grab the mouse or the keyboard.
.BR \-\-noxim
Disable XIM.

46
src/CMakeLists.txt
Unescape View File

@ -96,7 +96,7 @@ tde_add_executable( rosegardensequencer AUTOMOC
target_link_libraries( rosegardensequencer dl )
ADD_DEPENDENCIES(rosegardensequencer RosegardenCommon-static)
add_dependencies(rosegardensequencer RosegardenCommon-static)
##### RosegardenExtended ############################
@ -136,19 +136,19 @@ tde_add_executable( rosegarden AUTOMOC
target_link_libraries( rosegarden dl )
target_link_libraries( rosegarden tdeprint-shared )
ADD_DEPENDENCIES(rosegarden RosegardenExtended-static)
ADD_DEPENDENCIES(rosegarden RosegardenSegmentCanvas-static)
ADD_DEPENDENCIES(rosegarden RosegardenCommands-static)
ADD_DEPENDENCIES(rosegarden RosegardenCommon-static)
ADD_DEPENDENCIES(rosegarden RosegardenExtended-static)
ADD_DEPENDENCIES(rosegarden RosegardenSegmentCanvas-static)
ADD_DEPENDENCIES(rosegarden RosegardenCommands-static)
ADD_DEPENDENCIES(rosegarden RosegardenCommon-static)
add_dependencies(rosegarden RosegardenExtended-static)
add_dependencies(rosegarden RosegardenSegmentCanvas-static)
add_dependencies(rosegarden RosegardenCommands-static)
add_dependencies(rosegarden RosegardenCommon-static)
add_dependencies(rosegarden RosegardenExtended-static)
add_dependencies(rosegarden RosegardenSegmentCanvas-static)
add_dependencies(rosegarden RosegardenCommands-static)
add_dependencies(rosegarden RosegardenCommon-static)
if( WANT_TEST )
include( TestFileList.txt )
CREATE_TEST_SOURCELIST(RosegardenTest
create_test_sourcelist(RosegardenTest
RosegardenTestDriver.cpp
${tests_SRCS}
# base/test/transpose.cpp
@ -161,18 +161,18 @@ if( WANT_TEST )
DESTINATION ${BIN_INSTALL_DIR}
)
ADD_DEPENDENCIES(RosegardenTestDriver RosegardenExtended-static)
ADD_DEPENDENCIES(RosegardenTestDriver RosegardenSegmentCanvas-static)
ADD_DEPENDENCIES(RosegardenTestDriver RosegardenCommands-static)
ADD_DEPENDENCIES(RosegardenTestDriver RosegardenCommon-static)
ADD_DEPENDENCIES(RosegardenTestDriver RosegardenExtended-static)
ADD_DEPENDENCIES(RosegardenTestDriver RosegardenSegmentCanvas-static)
ADD_DEPENDENCIES(RosegardenTestDriver RosegardenCommands-static)
ADD_DEPENDENCIES(RosegardenTestDriver RosegardenCommon-static)
FOREACH(currenttest ${tests_SRCS})
GET_FILENAME_COMPONENT(TestName ${currenttest} NAME_WE)
ADD_TEST(test/${TestName} RosegardenTestDriver test/${TestName})
ENDFOREACH(currenttest ${tests_SRCS})
add_dependencies(RosegardenTestDriver RosegardenExtended-static)
add_dependencies(RosegardenTestDriver RosegardenSegmentCanvas-static)
add_dependencies(RosegardenTestDriver RosegardenCommands-static)
add_dependencies(RosegardenTestDriver RosegardenCommon-static)
add_dependencies(RosegardenTestDriver RosegardenExtended-static)
add_dependencies(RosegardenTestDriver RosegardenSegmentCanvas-static)
add_dependencies(RosegardenTestDriver RosegardenCommands-static)
add_dependencies(RosegardenTestDriver RosegardenCommon-static)
foreach(currenttest ${tests_SRCS})
get_filename_component(TestName ${currenttest} NAME_WE)
add_test(test/${TestName} RosegardenTestDriver test/${TestName})
endforeach(currenttest ${tests_SRCS})
endif( WANT_TEST )

3
src/base/AnalysisTypes.h
Unescape View File

@ -27,6 +27,7 @@
#include <map>
#include <set>
#include <vector>
#include <functional>
#include "NotationTypes.h"
@ -157,7 +158,7 @@ protected:
typedef std::pair<double, ChordLabel> ChordPossibility;
typedef std::vector<ChordPossibility> HarmonyGuess;
typedef std::vector<std::pair<timeT, HarmonyGuess> > HarmonyGuessList;
struct cp_less : public std::binary_function<ChordPossibility, ChordPossibility, bool>
struct cp_less : public std::function<bool(ChordPossibility, ChordPossibility)>
{
bool operator()(ChordPossibility l, ChordPossibility r);
};

2
src/commands/edit/EventQuantizeCommand.h
Unescape View File

@ -41,7 +41,7 @@ class EventSelection;
class EventQuantizeCommand : public TQObject, public BasicCommand
{
Q_OBJECT
TQ_OBJECT
public:

16
src/commands/segment/AudioSegmentRescaleCommand.cpp
Unescape View File

@ -90,19 +90,19 @@ AudioSegmentRescaleCommand::~AudioSegmentRescaleCommand()
void
AudioSegmentRescaleCommand::connectProgressDialog(ProgressDialog *dlg)
{
TQObject::connect(m_stretcher, TQT_SIGNAL(setProgress(int)),
dlg->progressBar(), TQT_SLOT(setValue(int)));
TQObject::connect(dlg, TQT_SIGNAL(cancelClicked()),
m_stretcher, TQT_SLOT(slotStopTimestretch()));
TQObject::connect(m_stretcher, TQ_SIGNAL(setProgress(int)),
dlg->progressBar(), TQ_SLOT(setValue(int)));
TQObject::connect(dlg, TQ_SIGNAL(cancelClicked()),
m_stretcher, TQ_SLOT(slotStopTimestretch()));
}
void
AudioSegmentRescaleCommand::disconnectProgressDialog(ProgressDialog *dlg)
{
TQObject::disconnect(m_stretcher, TQT_SIGNAL(setProgress(int)),
dlg->progressBar(), TQT_SLOT(setValue(int)));
TQObject::disconnect(dlg, TQT_SIGNAL(cancelClicked()),
m_stretcher, TQT_SLOT(slotStopTimestretch()));
TQObject::disconnect(m_stretcher, TQ_SIGNAL(setProgress(int)),
dlg->progressBar(), TQ_SLOT(setValue(int)));
TQObject::disconnect(dlg, TQ_SIGNAL(cancelClicked()),
m_stretcher, TQ_SLOT(slotStopTimestretch()));
}
void

24
src/document/MultiViewCommandHistory.cpp
Unescape View File

@ -73,40 +73,40 @@ MultiViewCommandHistory::attachView(TDEActionCollection *collection)
TDEToolBarPopupAction *undo = dynamic_cast<TDEToolBarPopupAction*>(collection->action(KStdAction::stdName(KStdAction::Undo)));
if (undo) {
connect(undo, TQT_SIGNAL(activated()),
this, TQT_SLOT(slotUndo()));
connect(undo, TQ_SIGNAL(activated()),
this, TQ_SLOT(slotUndo()));
connect
(undo->popupMenu(),
TQT_SIGNAL(aboutToShow()),
TQ_SIGNAL(aboutToShow()),
this,
TQT_SLOT(slotUndoAboutToShow()));
TQ_SLOT(slotUndoAboutToShow()));
connect
(undo->popupMenu(),
TQT_SIGNAL(activated(int)),
TQ_SIGNAL(activated(int)),
this,
TQT_SLOT(slotUndoActivated(int)));
TQ_SLOT(slotUndoActivated(int)));
}
TDEToolBarPopupAction *redo = dynamic_cast<TDEToolBarPopupAction*>(collection->action(KStdAction::stdName(KStdAction::Redo)));
if (redo) {
connect(redo, TQT_SIGNAL(activated()),
this, TQT_SLOT(slotRedo()));
connect(redo, TQ_SIGNAL(activated()),
this, TQ_SLOT(slotRedo()));
connect
(redo->popupMenu(),
TQT_SIGNAL(aboutToShow()),
TQ_SIGNAL(aboutToShow()),
this,
TQT_SLOT(slotRedoAboutToShow()));
TQ_SLOT(slotRedoAboutToShow()));
connect
(redo->popupMenu(),
TQT_SIGNAL(activated(int)),
TQ_SIGNAL(activated(int)),
this,
TQT_SLOT(slotRedoActivated(int)));
TQ_SLOT(slotRedoActivated(int)));
}
m_views.insert(collection);

2
src/document/MultiViewCommandHistory.h
Unescape View File

@ -52,7 +52,7 @@ namespace Rosegarden
class MultiViewCommandHistory : public TQObject
{
Q_OBJECT
TQ_OBJECT
public:

44
src/document/RosegardenGUIDoc.cpp
Unescape View File

@ -135,11 +135,11 @@ RosegardenGUIDoc::RosegardenGUIDoc(TQWidget *parent,
m_viewList.setAutoDelete(false);
m_editViewList.setAutoDelete(false);
connect(m_commandHistory, TQT_SIGNAL(commandExecuted(KCommand *)),
this, TQT_SLOT(slotDocumentModified()));
connect(m_commandHistory, TQ_SIGNAL(commandExecuted(KCommand *)),
this, TQ_SLOT(slotDocumentModified()));
connect(m_commandHistory, TQT_SIGNAL(documentRestored()),
this, TQT_SLOT(slotDocumentRestored()));
connect(m_commandHistory, TQ_SIGNAL(documentRestored()),
this, TQ_SLOT(slotDocumentRestored()));
// autoload a new document
if (!skipAutoload)
@ -584,8 +584,8 @@ bool RosegardenGUIDoc::openDocument(const TQString& filename,
100,
(TQWidget*)parent());
connect(&progressDlg, TQT_SIGNAL(cancelClicked()),
&m_audioFileManager, TQT_SLOT(slotStopPreview()));
connect(&progressDlg, TQ_SIGNAL(cancelClicked()),
&m_audioFileManager, TQ_SLOT(slotStopPreview()));
progressDlg.setMinimumDuration(500);
progressDlg.setAutoReset(true); // we're re-using it for the preview generation
@ -686,8 +686,8 @@ bool RosegardenGUIDoc::openDocument(const TQString& filename,
// reuse the previous one
progressDlg.setLabel(i18n("Generating audio previews..."));
connect(&m_audioFileManager, TQT_SIGNAL(setProgress(int)),
progressDlg.progressBar(), TQT_SLOT(setValue(int)));
connect(&m_audioFileManager, TQ_SIGNAL(setProgress(int)),
progressDlg.progressBar(), TQ_SLOT(setValue(int)));
try {
// generate any audio previews after loading the files
m_audioFileManager.generatePreviews();
@ -1575,14 +1575,14 @@ RosegardenGUIDoc::xmlParse(TQString fileContents, TQString &errMsg,
RoseXmlHandler handler(this, elementCount, permanent);
if (progress) {
connect(&handler, TQT_SIGNAL(setProgress(int)),
progress->progressBar(), TQT_SLOT(setValue(int)));
connect(&handler, TQT_SIGNAL(setOperationName(TQString)),
progress, TQT_SLOT(slotSetOperationName(TQString)));
connect(&handler, TQT_SIGNAL(incrementProgress(int)),
progress->progressBar(), TQT_SLOT(advance(int)));
connect(progress, TQT_SIGNAL(cancelClicked()),
&handler, TQT_SLOT(slotCancel()));
connect(&handler, TQ_SIGNAL(setProgress(int)),
progress->progressBar(), TQ_SLOT(setValue(int)));
connect(&handler, TQ_SIGNAL(setOperationName(TQString)),
progress, TQ_SLOT(slotSetOperationName(TQString)));
connect(&handler, TQ_SIGNAL(incrementProgress(int)),
progress->progressBar(), TQ_SLOT(advance(int)));
connect(progress, TQ_SIGNAL(cancelClicked()),
&handler, TQ_SLOT(slotCancel()));
}
TQXmlInputSource source;
@ -2789,11 +2789,11 @@ RosegardenGUIDoc::finalizeAudioFile(InstrumentId iid)
progressDlg->setAutoReset(false);
progressDlg->show();
connect(progressDlg, TQT_SIGNAL(cancelClicked()),
&m_audioFileManager, TQT_SLOT(slotStopPreview()));
connect(progressDlg, TQ_SIGNAL(cancelClicked()),
&m_audioFileManager, TQ_SLOT(slotStopPreview()));
connect(&m_audioFileManager, TQT_SIGNAL(setProgress(int)),
progressDlg->progressBar(), TQT_SLOT(setValue(int)));
connect(&m_audioFileManager, TQ_SIGNAL(setProgress(int)),
progressDlg->progressBar(), TQ_SLOT(setValue(int)));
try {
m_audioFileManager.generatePreview(newAudioFile->getId());
@ -2923,7 +2923,7 @@ RosegardenGUIDoc::getTimers()
return list;
}
if (replyType != TQSTRING_OBJECT_NAME_STRING) {
if (replyType != "TQString") {
RG_DEBUG << "RosegardenGUIDoc::getTimers - "
<< "wrong reply type (" << replyType << ") from sequencer" << endl;
return list;
@ -2951,7 +2951,7 @@ RosegardenGUIDoc::getCurrentTimer()
return "";
}
if (replyType != TQSTRING_OBJECT_NAME_STRING) {
if (replyType != "TQString") {
RG_DEBUG << "RosegardenGUIDoc::getCurrentTimer - "
<< "wrong reply type (" << replyType << ") from sequencer" << endl;
return "";

2
src/document/RosegardenGUIDoc.h
Unescape View File

@ -86,7 +86,7 @@ static const int MERGE_KEEP_NEW_TIMINGS = (1 << 3);
class RosegardenGUIDoc : public TQObject
{
Q_OBJECT
TQ_OBJECT
public:

2
src/gui/application/LircClient.cpp
Unescape View File

@ -61,7 +61,7 @@ LircClient::LircClient(void)
}
m_socketNotifier = new TQSocketNotifier(m_socket, TQSocketNotifier::Read, 0);
connect(m_socketNotifier, TQT_SIGNAL(activated(int)), this, TQT_SLOT(readButton()) );
connect(m_socketNotifier, TQ_SIGNAL(activated(int)), this, TQ_SLOT(readButton()) );
RG_DEBUG << "LircClient::LircClient: connected to socket: " << m_socket << endl;
}

2
src/gui/application/LircClient.h
Unescape View File

@ -41,7 +41,7 @@ namespace Rosegarden
class LircClient : public TQObject
{
Q_OBJECT
TQ_OBJECT
public:
LircClient(void);

54
src/gui/application/LircCommander.cpp
Unescape View File

@ -45,33 +45,33 @@ LircCommander::LircCommander(LircClient *lirc, RosegardenGUIApp *rgGUIApp)
{
m_lirc = lirc;
m_rgGUIApp = rgGUIApp;
connect(m_lirc, TQT_SIGNAL(buttonPressed(char *)),
this, TQT_SLOT(slotExecute(char *)) );
connect(this, TQT_SIGNAL(play()),
m_rgGUIApp, TQT_SLOT(slotPlay()) );
connect(this, TQT_SIGNAL(stop()),
m_rgGUIApp, TQT_SLOT(slotStop()) );
connect(this, TQT_SIGNAL(record()),
m_rgGUIApp, TQT_SLOT(slotRecord()) );
connect(this, TQT_SIGNAL(rewind()),
m_rgGUIApp, TQT_SLOT(slotRewind()) );
connect(this, TQT_SIGNAL(rewindToBeginning()),
m_rgGUIApp, TQT_SLOT(slotRewindToBeginning()) );
connect(this, TQT_SIGNAL(fastForward()),
m_rgGUIApp, TQT_SLOT(slotFastforward()) );
connect(this, TQT_SIGNAL(fastForwardToEnd()),
m_rgGUIApp, TQT_SLOT(slotFastForwardToEnd()) );
connect(this, TQT_SIGNAL(toggleRecord()),
m_rgGUIApp, TQT_SLOT(slotToggleRecord()) );
connect(this, TQT_SIGNAL(trackDown()),
m_rgGUIApp, TQT_SLOT(slotTrackDown()) );
connect(this, TQT_SIGNAL(trackUp()),
m_rgGUIApp, TQT_SLOT(slotTrackUp()) );
connect(this, TQT_SIGNAL(trackMute()),
m_rgGUIApp, TQT_SLOT(slotToggleMutedCurrentTrack()) );
connect(this, TQT_SIGNAL(trackRecord()),
m_rgGUIApp, TQT_SLOT(slotToggleRecordCurrentTrack()) );
connect(m_lirc, TQ_SIGNAL(buttonPressed(char *)),
this, TQ_SLOT(slotExecute(char *)) );
connect(this, TQ_SIGNAL(play()),
m_rgGUIApp, TQ_SLOT(slotPlay()) );
connect(this, TQ_SIGNAL(stop()),
m_rgGUIApp, TQ_SLOT(slotStop()) );
connect(this, TQ_SIGNAL(record()),
m_rgGUIApp, TQ_SLOT(slotRecord()) );
connect(this, TQ_SIGNAL(rewind()),
m_rgGUIApp, TQ_SLOT(slotRewind()) );
connect(this, TQ_SIGNAL(rewindToBeginning()),
m_rgGUIApp, TQ_SLOT(slotRewindToBeginning()) );
connect(this, TQ_SIGNAL(fastForward()),
m_rgGUIApp, TQ_SLOT(slotFastforward()) );
connect(this, TQ_SIGNAL(fastForwardToEnd()),
m_rgGUIApp, TQ_SLOT(slotFastForwardToEnd()) );
connect(this, TQ_SIGNAL(toggleRecord()),
m_rgGUIApp, TQ_SLOT(slotToggleRecord()) );
connect(this, TQ_SIGNAL(trackDown()),
m_rgGUIApp, TQ_SLOT(slotTrackDown()) );
connect(this, TQ_SIGNAL(trackUp()),
m_rgGUIApp, TQ_SLOT(slotTrackUp()) );
connect(this, TQ_SIGNAL(trackMute()),
m_rgGUIApp, TQ_SLOT(slotToggleMutedCurrentTrack()) );
connect(this, TQ_SIGNAL(trackRecord()),
m_rgGUIApp, TQ_SLOT(slotToggleRecordCurrentTrack()) );
}
LircCommander::command LircCommander::commands[] =

2
src/gui/application/LircCommander.h
Unescape View File

@ -43,7 +43,7 @@ class LircClient;
class LircCommander : public TQObject
{
Q_OBJECT
TQ_OBJECT
public:
LircCommander(LircClient *lirc, RosegardenGUIApp *rgGUIApp);

2
src/gui/application/RosegardenApplication.h
Unescape View File

@ -45,7 +45,7 @@ namespace Rosegarden
*/
class RosegardenApplication : public KUniqueApplication
{
Q_OBJECT
TQ_OBJECT
public:
RosegardenApplication(): KUniqueApplication(), m_noSequencerMode(false) {}

1168
src/gui/application/RosegardenGUIApp.cpp
View File

File diff suppressed because it is too large Load Diff

2
src/gui/application/RosegardenGUIApp.h
Unescape View File

@ -106,7 +106,7 @@ class AudioManagerDialog;
*/
class RosegardenGUIApp : public KDockMainWindow, virtual public RosegardenIface
{
Q_OBJECT
TQ_OBJECT
friend class RosegardenGUIView;

376
src/gui/application/RosegardenGUIView.cpp
Unescape View File

@ -139,91 +139,91 @@ RosegardenGUIView::RosegardenGUIView(bool showTrackLabels,
m_rulerScale, showTrackLabels, unitsPerPixel, this /*hbox*/);
connect(m_trackEditor->getSegmentCanvas(),
TQT_SIGNAL(editSegment(Segment*)),
TQT_SLOT(slotEditSegment(Segment*)));
TQ_SIGNAL(editSegment(Segment*)),
TQ_SLOT(slotEditSegment(Segment*)));
connect(m_trackEditor->getSegmentCanvas(),
TQT_SIGNAL(editSegmentNotation(Segment*)),
TQT_SLOT(slotEditSegmentNotation(Segment*)));
TQ_SIGNAL(editSegmentNotation(Segment*)),
TQ_SLOT(slotEditSegmentNotation(Segment*)));
connect(m_trackEditor->getSegmentCanvas(),
TQT_SIGNAL(editSegmentMatrix(Segment*)),
TQT_SLOT(slotEditSegmentMatrix(Segment*)));
TQ_SIGNAL(editSegmentMatrix(Segment*)),
TQ_SLOT(slotEditSegmentMatrix(Segment*)));
connect(m_trackEditor->getSegmentCanvas(),
TQT_SIGNAL(editSegmentAudio(Segment*)),
TQT_SLOT(slotEditSegmentAudio(Segment*)));
TQ_SIGNAL(editSegmentAudio(Segment*)),
TQ_SLOT(slotEditSegmentAudio(Segment*)));
connect(m_trackEditor->getSegmentCanvas(),
TQT_SIGNAL(audioSegmentAutoSplit(Segment*)),
TQT_SLOT(slotSegmentAutoSplit(Segment*)));
TQ_SIGNAL(audioSegmentAutoSplit(Segment*)),
TQ_SLOT(slotSegmentAutoSplit(Segment*)));
connect(m_trackEditor->getSegmentCanvas(),
TQT_SIGNAL(editSegmentEventList(Segment*)),
TQT_SLOT(slotEditSegmentEventList(Segment*)));
TQ_SIGNAL(editSegmentEventList(Segment*)),
TQ_SLOT(slotEditSegmentEventList(Segment*)));
connect(m_trackEditor->getSegmentCanvas(),
TQT_SIGNAL(editRepeat(Segment*, timeT)),
TQT_SLOT(slotEditRepeat(Segment*, timeT)));
TQ_SIGNAL(editRepeat(Segment*, timeT)),
TQ_SLOT(slotEditRepeat(Segment*, timeT)));
connect(m_trackEditor->getSegmentCanvas(),
TQT_SIGNAL(setPointerPosition(timeT)),
doc, TQT_SLOT(slotSetPointerPosition(timeT)));
TQ_SIGNAL(setPointerPosition(timeT)),
doc, TQ_SLOT(slotSetPointerPosition(timeT)));
connect(m_trackEditor,
TQT_SIGNAL(droppedDocument(TQString)),
TQ_SIGNAL(droppedDocument(TQString)),
parent,
TQT_SLOT(slotOpenDroppedURL(TQString)));
TQ_SLOT(slotOpenDroppedURL(TQString)));
connect(m_trackEditor,
TQT_SIGNAL(droppedAudio(TQString)),
TQ_SIGNAL(droppedAudio(TQString)),
this,
TQT_SLOT(slotDroppedAudio(TQString)));
TQ_SLOT(slotDroppedAudio(TQString)));
connect(m_trackEditor,
TQT_SIGNAL(droppedNewAudio(TQString)),
TQ_SIGNAL(droppedNewAudio(TQString)),
this,
TQT_SLOT(slotDroppedNewAudio(TQString)));
TQ_SLOT(slotDroppedNewAudio(TQString)));
connect(m_instrumentParameterBox,
TQT_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)),
TQ_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)),
this,
TQT_SLOT(slotChangeInstrumentLabel(InstrumentId, TQString)));
TQ_SLOT(slotChangeInstrumentLabel(InstrumentId, TQString)));
connect(m_instrumentParameterBox,
TQT_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)),
TQ_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)),
m_trackParameterBox,
TQT_SLOT(slotInstrumentLabelChanged(InstrumentId, TQString)));
TQ_SLOT(slotInstrumentLabelChanged(InstrumentId, TQString)));
connect(m_trackEditor->getTrackButtons(),
TQT_SIGNAL(nameChanged()),
TQ_SIGNAL(nameChanged()),
m_trackParameterBox,
TQT_SLOT(slotSelectedTrackNameChanged()));
TQ_SLOT(slotSelectedTrackNameChanged()));
connect(m_trackEditor->getTrackButtons(),
TQT_SIGNAL(instrumentSelected(int)),
TQ_SIGNAL(instrumentSelected(int)),
m_trackParameterBox,
TQT_SLOT(slotUpdateControls(int)));
TQ_SLOT(slotUpdateControls(int)));
connect(m_trackParameterBox,
TQT_SIGNAL(instrumentSelected(TrackId, int)),
TQ_SIGNAL(instrumentSelected(TrackId, int)),
m_trackEditor->getTrackButtons(),
TQT_SLOT(slotTrackInstrumentSelection(TrackId, int)));
TQ_SLOT(slotTrackInstrumentSelection(TrackId, int)));
connect(this, TQT_SIGNAL(controllerDeviceEventReceived(MappedEvent *, const void *)),
this, TQT_SLOT(slotControllerDeviceEventReceived(MappedEvent *, const void *)));
connect(this, TQ_SIGNAL(controllerDeviceEventReceived(MappedEvent *, const void *)),
this, TQ_SLOT(slotControllerDeviceEventReceived(MappedEvent *, const void *)));
if (doc) {
/* signal no longer exists
connect(doc, TQT_SIGNAL(recordingSegmentUpdated(Segment *,
connect(doc, TQ_SIGNAL(recordingSegmentUpdated(Segment *,
timeT)),
this, TQT_SLOT(slotUpdateRecordingSegment(Segment *,
this, TQ_SLOT(slotUpdateRecordingSegment(Segment *,
timeT)));
*/
TQObject::connect
(getCommandHistory(), TQT_SIGNAL(commandExecuted()),
m_trackEditor->getSegmentCanvas(), TQT_SLOT(slotUpdateSegmentsDrawBuffer()));
(getCommandHistory(), TQ_SIGNAL(commandExecuted()),
m_trackEditor->getSegmentCanvas(), TQ_SLOT(slotUpdateSegmentsDrawBuffer()));
}
}
@ -455,77 +455,77 @@ RosegardenGUIView::createNotationView(std::vector<Segment *> segmentsToEdit)
// For tempo changes (ugh -- it'd be nicer to make a tempo change
// command that could interpret all this stuff from the dialog)
//
connect(notationView, TQT_SIGNAL(changeTempo(timeT,
connect(notationView, TQ_SIGNAL(changeTempo(timeT,
tempoT,
tempoT,
TempoDialog::TempoDialogAction)),
RosegardenGUIApp::self(), TQT_SLOT(slotChangeTempo(timeT,
RosegardenGUIApp::self(), TQ_SLOT(slotChangeTempo(timeT,
tempoT,
tempoT,
TempoDialog::TempoDialogAction)));
connect(notationView, TQT_SIGNAL(windowActivated()),
this, TQT_SLOT(slotActiveMainWindowChanged()));
connect(notationView, TQT_SIGNAL(selectTrack(int)),
this, TQT_SLOT(slotSelectTrackSegments(int)));
connect(notationView, TQT_SIGNAL(play()),
RosegardenGUIApp::self(), TQT_SLOT(slotPlay()));
connect(notationView, TQT_SIGNAL(stop()),
RosegardenGUIApp::self(), TQT_SLOT(slotStop()));
connect(notationView, TQT_SIGNAL(fastForwardPlayback()),
RosegardenGUIApp::self(), TQT_SLOT(slotFastforward()));
connect(notationView, TQT_SIGNAL(rewindPlayback()),
RosegardenGUIApp::self(), TQT_SLOT(slotRewind()));
connect(notationView, TQT_SIGNAL(fastForwardPlaybackToEnd()),
RosegardenGUIApp::self(), TQT_SLOT(slotFastForwardToEnd()));
connect(notationView, TQT_SIGNAL(rewindPlaybackToBeginning()),
RosegardenGUIApp::self(), TQT_SLOT(slotRewindToBeginning()));
connect(notationView, TQT_SIGNAL(panic()),
RosegardenGUIApp::self(), TQT_SLOT(slotPanic()));
connect(notationView, TQT_SIGNAL(saveFile()),
RosegardenGUIApp::self(), TQT_SLOT(slotFileSave()));
connect(notationView, TQT_SIGNAL(jumpPlaybackTo(timeT)),
getDocument(), TQT_SLOT(slotSetPointerPosition(timeT)));
connect(notationView, TQT_SIGNAL(openInNotation(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsNotation(std::vector<Segment *>)));
connect(notationView, TQT_SIGNAL(openInMatrix(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsMatrix(std::vector<Segment *>)));
connect(notationView, TQT_SIGNAL(openInPercussionMatrix(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsPercussionMatrix(std::vector<Segment *>)));
connect(notationView, TQT_SIGNAL(openInEventList(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsEventList(std::vector<Segment *>)));
connect(notationView, TQ_SIGNAL(windowActivated()),
this, TQ_SLOT(slotActiveMainWindowChanged()));
connect(notationView, TQ_SIGNAL(selectTrack(int)),
this, TQ_SLOT(slotSelectTrackSegments(int)));
connect(notationView, TQ_SIGNAL(play()),
RosegardenGUIApp::self(), TQ_SLOT(slotPlay()));
connect(notationView, TQ_SIGNAL(stop()),
RosegardenGUIApp::self(), TQ_SLOT(slotStop()));
connect(notationView, TQ_SIGNAL(fastForwardPlayback()),
RosegardenGUIApp::self(), TQ_SLOT(slotFastforward()));
connect(notationView, TQ_SIGNAL(rewindPlayback()),
RosegardenGUIApp::self(), TQ_SLOT(slotRewind()));
connect(notationView, TQ_SIGNAL(fastForwardPlaybackToEnd()),
RosegardenGUIApp::self(), TQ_SLOT(slotFastForwardToEnd()));
connect(notationView, TQ_SIGNAL(rewindPlaybackToBeginning()),
RosegardenGUIApp::self(), TQ_SLOT(slotRewindToBeginning()));
connect(notationView, TQ_SIGNAL(panic()),
RosegardenGUIApp::self(), TQ_SLOT(slotPanic()));
connect(notationView, TQ_SIGNAL(saveFile()),
RosegardenGUIApp::self(), TQ_SLOT(slotFileSave()));
connect(notationView, TQ_SIGNAL(jumpPlaybackTo(timeT)),
getDocument(), TQ_SLOT(slotSetPointerPosition(timeT)));
connect(notationView, TQ_SIGNAL(openInNotation(std::vector<Segment *>)),
this, TQ_SLOT(slotEditSegmentsNotation(std::vector<Segment *>)));
connect(notationView, TQ_SIGNAL(openInMatrix(std::vector<Segment *>)),
this, TQ_SLOT(slotEditSegmentsMatrix(std::vector<Segment *>)));
connect(notationView, TQ_SIGNAL(openInPercussionMatrix(std::vector<Segment *>)),
this, TQ_SLOT(slotEditSegmentsPercussionMatrix(std::vector<Segment *>)));
connect(notationView, TQ_SIGNAL(openInEventList(std::vector<Segment *>)),
this, TQ_SLOT(slotEditSegmentsEventList(std::vector<Segment *>)));
/* hjj: WHAT DO DO WITH THIS ?
connect(notationView, TQT_SIGNAL(editMetadata(TQString)),
this, TQT_SLOT(slotEditMetadata(TQString)));
connect(notationView, TQ_SIGNAL(editMetadata(TQString)),
this, TQ_SLOT(slotEditMetadata(TQString)));
*/
connect(notationView, TQT_SIGNAL(editTriggerSegment(int)),
this, TQT_SLOT(slotEditTriggerSegment(int)));
connect(notationView, TQT_SIGNAL(staffLabelChanged(TrackId, TQString)),
this, TQT_SLOT(slotChangeTrackLabel(TrackId, TQString)));
connect(notationView, TQT_SIGNAL(toggleSolo(bool)),
RosegardenGUIApp::self(), TQT_SLOT(slotToggleSolo(bool)));
connect(notationView, TQT_SIGNAL(editTimeSignature(timeT)),
RosegardenGUIApp::self(), TQT_SLOT(slotEditTempos(timeT)));
connect(notationView, TQ_SIGNAL(editTriggerSegment(int)),
this, TQ_SLOT(slotEditTriggerSegment(int)));
connect(notationView, TQ_SIGNAL(staffLabelChanged(TrackId, TQString)),
this, TQ_SLOT(slotChangeTrackLabel(TrackId, TQString)));
connect(notationView, TQ_SIGNAL(toggleSolo(bool)),
RosegardenGUIApp::self(), TQ_SLOT(slotToggleSolo(bool)));
connect(notationView, TQ_SIGNAL(editTimeSignature(timeT)),
RosegardenGUIApp::self(), TQ_SLOT(slotEditTempos(timeT)));
SequenceManager *sM = getDocument()->getSequenceManager();
connect(sM, TQT_SIGNAL(insertableNoteOnReceived(int, int)),
notationView, TQT_SLOT(slotInsertableNoteOnReceived(int, int)));
connect(sM, TQT_SIGNAL(insertableNoteOffReceived(int, int)),
notationView, TQT_SLOT(slotInsertableNoteOffReceived(int, int)));
connect(sM, TQ_SIGNAL(insertableNoteOnReceived(int, int)),
notationView, TQ_SLOT(slotInsertableNoteOnReceived(int, int)));
connect(sM, TQ_SIGNAL(insertableNoteOffReceived(int, int)),
notationView, TQ_SLOT(slotInsertableNoteOffReceived(int, int)));
connect(notationView, TQT_SIGNAL(stepByStepTargetRequested(TQObject *)),
this, TQT_SIGNAL(stepByStepTargetRequested(TQObject *)));
connect(this, TQT_SIGNAL(stepByStepTargetRequested(TQObject *)),
notationView, TQT_SLOT(slotStepByStepTargetRequested(TQObject *)));
connect(RosegardenGUIApp::self(), TQT_SIGNAL(compositionStateUpdate()),
notationView, TQT_SLOT(slotCompositionStateUpdate()));
connect(this, TQT_SIGNAL(compositionStateUpdate()),
notationView, TQT_SLOT(slotCompositionStateUpdate()));
connect(notationView, TQ_SIGNAL(stepByStepTargetRequested(TQObject *)),
this, TQ_SIGNAL(stepByStepTargetRequested(TQObject *)));
connect(this, TQ_SIGNAL(stepByStepTargetRequested(TQObject *)),
notationView, TQ_SLOT(slotStepByStepTargetRequested(TQObject *)));
connect(RosegardenGUIApp::self(), TQ_SIGNAL(compositionStateUpdate()),
notationView, TQ_SLOT(slotCompositionStateUpdate()));
connect(this, TQ_SIGNAL(compositionStateUpdate()),
notationView, TQ_SLOT(slotCompositionStateUpdate()));
// Encourage the notation view window to open to the same
// interval as the current segment view
@ -657,73 +657,73 @@ RosegardenGUIView::createMatrixView(std::vector<Segment *> segmentsToEdit, bool
// For tempo changes (ugh -- it'd be nicer to make a tempo change
// command that could interpret all this stuff from the dialog)
//
connect(matrixView, TQT_SIGNAL(changeTempo(timeT,
connect(matrixView, TQ_SIGNAL(changeTempo(timeT,
tempoT,
tempoT,
TempoDialog::TempoDialogAction)),
RosegardenGUIApp::self(), TQT_SLOT(slotChangeTempo(timeT,
RosegardenGUIApp::self(), TQ_SLOT(slotChangeTempo(timeT,
tempoT,
tempoT,
TempoDialog::TempoDialogAction)));
connect(matrixView, TQT_SIGNAL(windowActivated()),
this, TQT_SLOT(slotActiveMainWindowChanged()));
connect(matrixView, TQT_SIGNAL(selectTrack(int)),
this, TQT_SLOT(slotSelectTrackSegments(int)));
connect(matrixView, TQT_SIGNAL(play()),
RosegardenGUIApp::self(), TQT_SLOT(slotPlay()));
connect(matrixView, TQT_SIGNAL(stop()),
RosegardenGUIApp::self(), TQT_SLOT(slotStop()));
connect(matrixView, TQT_SIGNAL(fastForwardPlayback()),
RosegardenGUIApp::self(), TQT_SLOT(slotFastforward()));
connect(matrixView, TQT_SIGNAL(rewindPlayback()),
RosegardenGUIApp::self(), TQT_SLOT(slotRewind()));
connect(matrixView, TQT_SIGNAL(fastForwardPlaybackToEnd()),
RosegardenGUIApp::self(), TQT_SLOT(slotFastForwardToEnd()));
connect(matrixView, TQT_SIGNAL(rewindPlaybackToBeginning()),
RosegardenGUIApp::self(), TQT_SLOT(slotRewindToBeginning()));
connect(matrixView, TQT_SIGNAL(panic()),
RosegardenGUIApp::self(), TQT_SLOT(slotPanic()));
connect(matrixView, TQT_SIGNAL(saveFile()),
RosegardenGUIApp::self(), TQT_SLOT(slotFileSave()));
connect(matrixView, TQT_SIGNAL(jumpPlaybackTo(timeT)),
getDocument(), TQT_SLOT(slotSetPointerPosition(timeT)));
connect(matrixView, TQT_SIGNAL(openInNotation(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsNotation(std::vector<Segment *>)));
connect(matrixView, TQT_SIGNAL(openInMatrix(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsMatrix(std::vector<Segment *>)));
connect(matrixView, TQT_SIGNAL(openInEventList(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsEventList(std::vector<Segment *>)));
connect(matrixView, TQT_SIGNAL(editTriggerSegment(int)),
this, TQT_SLOT(slotEditTriggerSegment(int)));
connect(matrixView, TQT_SIGNAL(toggleSolo(bool)),
RosegardenGUIApp::self(), TQT_SLOT(slotToggleSolo(bool)));
connect(matrixView, TQT_SIGNAL(editTimeSignature(timeT)),
RosegardenGUIApp::self(), TQT_SLOT(slotEditTempos(timeT)));
connect(matrixView, TQ_SIGNAL(windowActivated()),
this, TQ_SLOT(slotActiveMainWindowChanged()));
connect(matrixView, TQ_SIGNAL(selectTrack(int)),
this, TQ_SLOT(slotSelectTrackSegments(int)));
connect(matrixView, TQ_SIGNAL(play()),
RosegardenGUIApp::self(), TQ_SLOT(slotPlay()));
connect(matrixView, TQ_SIGNAL(stop()),
RosegardenGUIApp::self(), TQ_SLOT(slotStop()));
connect(matrixView, TQ_SIGNAL(fastForwardPlayback()),
RosegardenGUIApp::self(), TQ_SLOT(slotFastforward()));
connect(matrixView, TQ_SIGNAL(rewindPlayback()),
RosegardenGUIApp::self(), TQ_SLOT(slotRewind()));
connect(matrixView, TQ_SIGNAL(fastForwardPlaybackToEnd()),
RosegardenGUIApp::self(), TQ_SLOT(slotFastForwardToEnd()));
connect(matrixView, TQ_SIGNAL(rewindPlaybackToBeginning()),
RosegardenGUIApp::self(), TQ_SLOT(slotRewindToBeginning()));
connect(matrixView, TQ_SIGNAL(panic()),
RosegardenGUIApp::self(), TQ_SLOT(slotPanic()));
connect(matrixView, TQ_SIGNAL(saveFile()),
RosegardenGUIApp::self(), TQ_SLOT(slotFileSave()));
connect(matrixView, TQ_SIGNAL(jumpPlaybackTo(timeT)),
getDocument(), TQ_SLOT(slotSetPointerPosition(timeT)));
connect(matrixView, TQ_SIGNAL(openInNotation(std::vector<Segment *>)),
this, TQ_SLOT(slotEditSegmentsNotation(std::vector<Segment *>)));
connect(matrixView, TQ_SIGNAL(openInMatrix(std::vector<Segment *>)),
this, TQ_SLOT(slotEditSegmentsMatrix(std::vector<Segment *>)));
connect(matrixView, TQ_SIGNAL(openInEventList(std::vector<Segment *>)),
this, TQ_SLOT(slotEditSegmentsEventList(std::vector<Segment *>)));
connect(matrixView, TQ_SIGNAL(editTriggerSegment(int)),
this, TQ_SLOT(slotEditTriggerSegment(int)));
connect(matrixView, TQ_SIGNAL(toggleSolo(bool)),
RosegardenGUIApp::self(), TQ_SLOT(slotToggleSolo(bool)));
connect(matrixView, TQ_SIGNAL(editTimeSignature(timeT)),
RosegardenGUIApp::self(), TQ_SLOT(slotEditTempos(timeT)));
SequenceManager *sM = getDocument()->getSequenceManager();
connect(sM, TQT_SIGNAL(insertableNoteOnReceived(int, int)),
matrixView, TQT_SLOT(slotInsertableNoteOnReceived(int, int)));
connect(sM, TQT_SIGNAL(insertableNoteOffReceived(int, int)),
matrixView, TQT_SLOT(slotInsertableNoteOffReceived(int, int)));
connect(matrixView, TQT_SIGNAL(stepByStepTargetRequested(TQObject *)),
this, TQT_SIGNAL(stepByStepTargetRequested(TQObject *)));
connect(this, TQT_SIGNAL(stepByStepTargetRequested(TQObject *)),
matrixView, TQT_SLOT(slotStepByStepTargetRequested(TQObject *)));
connect(RosegardenGUIApp::self(), TQT_SIGNAL(compositionStateUpdate()),
matrixView, TQT_SLOT(slotCompositionStateUpdate()));
connect(this, TQT_SIGNAL(compositionStateUpdate()),
matrixView, TQT_SLOT(slotCompositionStateUpdate()));
connect(sM, TQ_SIGNAL(insertableNoteOnReceived(int, int)),
matrixView, TQ_SLOT(slotInsertableNoteOnReceived(int, int)));
connect(sM, TQ_SIGNAL(insertableNoteOffReceived(int, int)),
matrixView, TQ_SLOT(slotInsertableNoteOffReceived(int, int)));
connect(matrixView, TQ_SIGNAL(stepByStepTargetRequested(TQObject *)),
this, TQ_SIGNAL(stepByStepTargetRequested(TQObject *)));
connect(this, TQ_SIGNAL(stepByStepTargetRequested(TQObject *)),
matrixView, TQ_SLOT(slotStepByStepTargetRequested(TQObject *)));
connect(RosegardenGUIApp::self(), TQ_SIGNAL(compositionStateUpdate()),
matrixView, TQ_SLOT(slotCompositionStateUpdate()));
connect(this, TQ_SIGNAL(compositionStateUpdate()),
matrixView, TQ_SLOT(slotCompositionStateUpdate()));
connect(this,
TQT_SIGNAL(instrumentLevelsChanged(InstrumentId,
TQ_SIGNAL(instrumentLevelsChanged(InstrumentId,
const LevelInfo &)),
matrixView,
TQT_SLOT(slotInstrumentLevelsChanged(InstrumentId,
TQ_SLOT(slotInstrumentLevelsChanged(InstrumentId,
const LevelInfo &)));
// Encourage the matrix view window to open to the same
@ -1543,12 +1543,12 @@ RosegardenGUIView::slotDroppedNewAudio(TQString audioDesc)
// Connect the progress dialog
//
connect(&aFM, TQT_SIGNAL(setProgress(int)),
progressDlg.progressBar(), TQT_SLOT(setValue(int)));
connect(&aFM, TQT_SIGNAL(setOperationName(TQString)),
&progressDlg, TQT_SLOT(slotSetOperationName(TQString)));
connect(&progressDlg, TQT_SIGNAL(cancelClicked()),
&aFM, TQT_SLOT(slotStopImport()));
connect(&aFM, TQ_SIGNAL(setProgress(int)),
progressDlg.progressBar(), TQ_SLOT(setValue(int)));
connect(&aFM, TQ_SIGNAL(setOperationName(TQString)),
&progressDlg, TQ_SLOT(slotSetOperationName(TQString)));
connect(&progressDlg, TQ_SIGNAL(cancelClicked()),
&aFM, TQ_SLOT(slotStopImport()));
try {
audioFileId = aFM.importURL(kurl, sampleRate);
@ -1564,10 +1564,10 @@ RosegardenGUIView::slotDroppedNewAudio(TQString audioDesc)
return ;
}
disconnect(&progressDlg, TQT_SIGNAL(cancelClicked()),
&aFM, TQT_SLOT(slotStopImport()));
connect(&progressDlg, TQT_SIGNAL(cancelClicked()),
&aFM, TQT_SLOT(slotStopPreview()));
disconnect(&progressDlg, TQ_SIGNAL(cancelClicked()),
&aFM, TQ_SLOT(slotStopImport()));
connect(&progressDlg, TQ_SIGNAL(cancelClicked()),
&aFM, TQ_SLOT(slotStopPreview()));
progressDlg.progressBar()->show();
progressDlg.slotSetOperationName(i18n("Generating audio preview..."));
@ -1581,8 +1581,8 @@ RosegardenGUIView::slotDroppedNewAudio(TQString audioDesc)
//return false;
}
disconnect(&progressDlg, TQT_SIGNAL(cancelClicked()),
&aFM, TQT_SLOT(slotStopPreview()));
disconnect(&progressDlg, TQ_SIGNAL(cancelClicked()),
&aFM, TQ_SLOT(slotStopPreview()));
// add the file at the sequencer
emit addAudioFile(audioFileId);
@ -1747,8 +1747,8 @@ RosegardenGUIView::slotUpdateRecordingSegment(Segment *segment,
/* signal no longer exists
TQObject::connect
(getDocument(), TQT_SIGNAL(recordingSegmentUpdated(Segment *, timeT)),
view, TQT_SLOT(slotUpdateRecordingSegment(Segment *, timeT)));
(getDocument(), TQ_SIGNAL(recordingSegmentUpdated(Segment *, timeT)),
view, TQ_SLOT(slotUpdateRecordingSegment(Segment *, timeT)));
*/
view->show();
@ -1998,31 +1998,31 @@ RosegardenGUIView::createEventView(std::vector<Segment *> segmentsToEdit)
segmentsToEdit,
this);
connect(eventView, TQT_SIGNAL(windowActivated()),
this, TQT_SLOT(slotActiveMainWindowChanged()));
connect(eventView, TQT_SIGNAL(selectTrack(int)),
this, TQT_SLOT(slotSelectTrackSegments(int)));
connect(eventView, TQT_SIGNAL(saveFile()),
RosegardenGUIApp::self(), TQT_SLOT(slotFileSave()));
connect(eventView, TQT_SIGNAL(openInNotation(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsNotation(std::vector<Segment *>)));
connect(eventView, TQT_SIGNAL(openInMatrix(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsMatrix(std::vector<Segment *>)));
connect(eventView, TQT_SIGNAL(openInPercussionMatrix(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsPercussionMatrix(std::vector<Segment *>)));
connect(eventView, TQT_SIGNAL(openInEventList(std::vector<Segment *>)),
this, TQT_SLOT(slotEditSegmentsEventList(std::vector<Segment *>)));
connect(eventView, TQT_SIGNAL(editTriggerSegment(int)),
this, TQT_SLOT(slotEditTriggerSegment(int)));
connect(this, TQT_SIGNAL(compositionStateUpdate()),
eventView, TQT_SLOT(slotCompositionStateUpdate()));
connect(RosegardenGUIApp::self(), TQT_SIGNAL(compositionStateUpdate()),
eventView, TQT_SLOT(slotCompositionStateUpdate()));
connect(eventView, TQT_SIGNAL(toggleSolo(bool)),
RosegardenGUIApp::self(), TQT_SLOT(slotToggleSolo(bool)));
connect(eventView, TQ_SIGNAL(windowActivated()),
this, TQ_SLOT(slotActiveMainWindowChanged()));
connect(eventView, TQ_SIGNAL(selectTrack(int)),
this, TQ_SLOT(slotSelectTrackSegments(int)));
connect(eventView, TQ_SIGNAL(saveFile()),
RosegardenGUIApp::self(), TQ_SLOT(slotFileSave()));
connect(eventView, TQ_SIGNAL(openInNotation(std::vector<Segment *>)),
this, TQ_SLOT(slotEditSegmentsNotation(std::vector<Segment *>)));
connect(eventView, TQ_SIGNAL(openInMatrix(std::vector<Segment *>)),
this, TQ_SLOT(slotEditSegmentsMatrix(std::vector<Segment *>)));
connect(eventView, TQ_SIGNAL(openInPercussionMatrix(std::vector<Segment *>)),
this, TQ_SLOT(slotEditSegmentsPercussionMatrix(std::vector<Segment *>)));
connect(eventView, TQ_SIGNAL(openInEventList(std::vector<Segment *>)),
this, TQ_SLOT(slotEditSegmentsEventList(std::vector<Segment *>)));
connect(eventView, TQ_SIGNAL(editTriggerSegment(int)),
this, TQ_SLOT(slotEditTriggerSegment(int)));
connect(this, TQ_SIGNAL(compositionStateUpdate()),
eventView, TQ_SLOT(slotCompositionStateUpdate()));
connect(RosegardenGUIApp::self(), TQ_SIGNAL(compositionStateUpdate()),
eventView, TQ_SLOT(slotCompositionStateUpdate()));
connect(eventView, TQ_SIGNAL(toggleSolo(bool)),
RosegardenGUIApp::self(), TQ_SLOT(slotToggleSolo(bool)));
// create keyboard accelerators on view
//

2
src/gui/application/RosegardenGUIView.h
Unescape View File

@ -73,7 +73,7 @@ class LevelInfo;
*/
class RosegardenGUIView : public TQVBox
{
Q_OBJECT
TQ_OBJECT
public:

20
src/gui/application/StartupTester.cpp
Unescape View File

@ -42,10 +42,10 @@ StartupTester::StartupTester() :
m_haveAudioFileImporter(false)
{
TQHttp *http = new TQHttp();
connect(http, TQT_SIGNAL(responseHeaderReceived(const TQHttpResponseHeader &)),
this, TQT_SLOT(slotHttpResponseHeaderReceived(const TQHttpResponseHeader &)));
connect(http, TQT_SIGNAL(done(bool)),
this, TQT_SLOT(slotHttpDone(bool)));
connect(http, TQ_SIGNAL(responseHeaderReceived(const TQHttpResponseHeader &)),
this, TQ_SLOT(slotHttpResponseHeaderReceived(const TQHttpResponseHeader &)));
connect(http, TQ_SIGNAL(done(bool)),
this, TQ_SLOT(slotHttpDone(bool)));
m_versionHttpFailed = false;
http->setHost("www.rosegardenmusic.com");
http->get("/latest-version.txt");
@ -65,8 +65,8 @@ StartupTester::run()
TDEProcess *proc = new TDEProcess();
m_stdoutBuffer = "";
TQObject::connect(proc, TQT_SIGNAL(receivedStdout(TDEProcess *, char *, int)),
this, TQT_SLOT(stdoutReceived(TDEProcess *, char *, int)));
TQObject::connect(proc, TQ_SIGNAL(receivedStdout(TDEProcess *, char *, int)),
this, TQ_SLOT(stdoutReceived(TDEProcess *, char *, int)));
*proc << "rosegarden-audiofile-importer";
*proc << "--conftest";
proc->start(TDEProcess::Block, TDEProcess::All);
@ -83,8 +83,8 @@ StartupTester::run()
proc = new TDEProcess;
m_stdoutBuffer = "";
TQObject::connect(proc, TQT_SIGNAL(receivedStdout(TDEProcess *, char *, int)),
this, TQT_SLOT(stdoutReceived(TDEProcess *, char *, int)));
TQObject::connect(proc, TQ_SIGNAL(receivedStdout(TDEProcess *, char *, int)),
this, TQ_SLOT(stdoutReceived(TDEProcess *, char *, int)));
*proc << "rosegarden-project-package";
*proc << "--conftest";
proc->start(TDEProcess::Block, TDEProcess::All);
@ -103,8 +103,8 @@ StartupTester::run()
proc = new TDEProcess();
m_stdoutBuffer = "";
TQObject::connect(proc, TQT_SIGNAL(receivedStdout(TDEProcess *, char *, int)),
this, TQT_SLOT(stdoutReceived(TDEProcess *, char *, int)));
TQObject::connect(proc, TQ_SIGNAL(receivedStdout(TDEProcess *, char *, int)),
this, TQ_SLOT(stdoutReceived(TDEProcess *, char *, int)));
*proc << "rosegarden-lilypondview";
*proc << "--conftest";
proc->start(TDEProcess::Block, TDEProcess::All);

2
src/gui/application/StartupTester.h
Unescape View File

@ -36,7 +36,7 @@ namespace Rosegarden
class StartupTester : public TQObject, public TQThread
{
Q_OBJECT
TQ_OBJECT
public:

14
src/gui/application/main.cpp
Unescape View File

@ -479,7 +479,7 @@ int main(int argc, char *argv[])
// Ensure quit on last window close
// Register main DCOP interface
//
TQObject::connect(&app, TQT_SIGNAL(lastWindowClosed()), &app, TQT_SLOT(quit()));
TQObject::connect(&app, TQ_SIGNAL(lastWindowClosed()), &app, TQ_SLOT(quit()));
app.dcopClient()->registerAs(app.name(), false);
app.dcopClient()->setDefaultObject(ROSEGARDEN_GUI_IFACE_NAME);
@ -594,7 +594,7 @@ int main(int argc, char *argv[])
rosegardengui = new RosegardenGUIApp(!app.noSequencerMode(),
args->isSet("existingsequencer"),
TQT_TQOBJECT(startLogo));
startLogo);
rosegardengui->setIsFirstRun(newVersion);
@ -624,8 +624,8 @@ int main(int argc, char *argv[])
}
TQObject::connect(&app, TQT_SIGNAL(aboutToSaveState()),
rosegardengui, TQT_SLOT(slotDeleteTransport()));
TQObject::connect(&app, TQ_SIGNAL(aboutToSaveState()),
rosegardengui, TQ_SLOT(slotDeleteTransport()));
// Now that we've started up, raise start logo
//
@ -661,8 +661,8 @@ int main(int argc, char *argv[])
(*sfxLoadProcess) << sfxLoadPath << soundFontPath;
RG_DEBUG << "Starting sfxload : " << sfxLoadPath << " " << soundFontPath << endl;
TQObject::connect(sfxLoadProcess, TQT_SIGNAL(processExited(TDEProcess*)),
&app, TQT_SLOT(sfxLoadExited(TDEProcess*)));
TQObject::connect(sfxLoadProcess, TQ_SIGNAL(processExited(TDEProcess*)),
&app, TQ_SLOT(sfxLoadExited(TDEProcess*)));
sfxLoadProcess->start();
} else {
@ -694,7 +694,7 @@ int main(int argc, char *argv[])
if (visibleFor < RealTime(2, 0)) {
int waitTime = visibleFor.sec * 1000 + visibleFor.msec();
TQTimer::singleShot(2500 - waitTime, startLogo, TQT_SLOT(close()));
TQTimer::singleShot(2500 - waitTime, startLogo, TQ_SLOT(close()));
} else {
startLogo->close();
}

2
src/gui/configuration/AudioConfigurationPage.cpp
Unescape View File

@ -135,7 +135,7 @@ AudioConfigurationPage::AudioConfigurationPage(
new TQPushButton(i18n("Choose..."), frame);
layout->addWidget(changePathButton, row, 2);
connect(changePathButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotFileDialog()));
connect(changePathButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotFileDialog()));
++row;
m_cfg->setGroup(SequencerOptionsConfigGroup);

2
src/gui/configuration/AudioConfigurationPage.h
Unescape View File

@ -47,7 +47,7 @@ class RosegardenGUIDoc;
class AudioConfigurationPage : public TabbedConfigurationPage
{
Q_OBJECT
TQ_OBJECT
public:
AudioConfigurationPage(RosegardenGUIDoc *doc,

16
src/gui/configuration/AudioPropertiesPage.cpp
Unescape View File

@ -82,8 +82,8 @@ AudioPropertiesPage::AudioPropertiesPage(RosegardenGUIDoc *doc,
calculateStats();
connect(m_changePathButton, TQT_SIGNAL(released()),
TQT_SLOT(slotFileDialog()));
connect(m_changePathButton, TQ_SIGNAL(released()),
TQ_SLOT(slotFileDialog()));
addTab(frame, i18n("Modify audio path"));
}
@ -95,9 +95,9 @@ AudioPropertiesPage::calculateStats()
//
TQString mountPoint = TDEIO::findPathMountPoint(m_path->text());
KDiskFreeSp * job = new KDiskFreeSp;
connect(job, TQT_SIGNAL(foundMountPoint(const TQString&, unsigned long, unsigned long,
connect(job, TQ_SIGNAL(foundMountPoint(const TQString&, unsigned long, unsigned long,
unsigned long)),
this, TQT_SLOT(slotFoundMountPoint(const TQString&, unsigned long, unsigned long,
this, TQ_SLOT(slotFoundMountPoint(const TQString&, unsigned long, unsigned long,
unsigned long)));
job->readDF(mountPoint);
}
@ -153,11 +153,11 @@ AudioPropertiesPage::slotFileDialog()
this, "file dialog", true);
fileDialog->setMode(KFile::Directory);
connect(fileDialog, TQT_SIGNAL(fileSelected(const TQString&)),
TQT_SLOT(slotFileSelected(const TQString&)));
connect(fileDialog, TQ_SIGNAL(fileSelected(const TQString&)),
TQ_SLOT(slotFileSelected(const TQString&)));
connect(fileDialog, TQT_SIGNAL(destroyed()),
TQT_SLOT(slotDirectoryDialogClosed()));
connect(fileDialog, TQ_SIGNAL(destroyed()),
TQ_SLOT(slotDirectoryDialogClosed()));
if (fileDialog->exec() == TQDialog::Accepted) {
m_path->setText(fileDialog->selectedFile());

2
src/gui/configuration/AudioPropertiesPage.h
Unescape View File

@ -46,7 +46,7 @@ class RosegardenGUIDoc;
*/
class AudioPropertiesPage : public TabbedConfigurationPage
{
Q_OBJECT
TQ_OBJECT
public:
AudioPropertiesPage(RosegardenGUIDoc *doc,

20
src/gui/configuration/ColourConfigurationPage.cpp
Unescape View File

@ -73,20 +73,20 @@ ColourConfigurationPage::ColourConfigurationPage(RosegardenGUIDoc *doc,
frame);
layout->addWidget(deleteColourButton, 1, 1, TQt::AlignHCenter);
connect(addColourButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotAddNew()));
connect(addColourButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotAddNew()));
connect(deleteColourButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotDelete()));
connect(deleteColourButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotDelete()));
connect(this, TQT_SIGNAL(docColoursChanged()),
m_doc, TQT_SLOT(slotDocColoursChanged()));
connect(this, TQ_SIGNAL(docColoursChanged()),
m_doc, TQ_SLOT(slotDocColoursChanged()));
connect(m_colourtable, TQT_SIGNAL(entryTextChanged(unsigned int, TQString)),
this, TQT_SLOT(slotTextChanged(unsigned int, TQString)));
connect(m_colourtable, TQ_SIGNAL(entryTextChanged(unsigned int, TQString)),
this, TQ_SLOT(slotTextChanged(unsigned int, TQString)));
connect(m_colourtable, TQT_SIGNAL(entryColourChanged(unsigned int, TQColor)),
this, TQT_SLOT(slotColourChanged(unsigned int, TQColor)));
connect(m_colourtable, TQ_SIGNAL(entryColourChanged(unsigned int, TQColor)),
this, TQ_SLOT(slotColourChanged(unsigned int, TQColor)));
addTab(frame, i18n("Color Map"));

2
src/gui/configuration/ColourConfigurationPage.h
Unescape View File

@ -46,7 +46,7 @@ class RosegardenGUIDoc;
*/
class ColourConfigurationPage : public TabbedConfigurationPage
{
Q_OBJECT
TQ_OBJECT
public:
ColourConfigurationPage(RosegardenGUIDoc *doc,

2
src/gui/configuration/ConfigurationPage.h
Unescape View File

@ -44,7 +44,7 @@ class RosegardenGUIDoc;
*/
class ConfigurationPage : public TQWidget
{
Q_OBJECT
TQ_OBJECT
public:

2
src/gui/configuration/DocumentMetaConfigurationPage.h
Unescape View File

@ -45,7 +45,7 @@ class HeadersConfigurationPage;
*/
class DocumentMetaConfigurationPage : public TabbedConfigurationPage
{
Q_OBJECT
TQ_OBJECT
public:
DocumentMetaConfigurationPage(RosegardenGUIDoc *doc,

4
src/gui/configuration/GeneralConfigurationPage.cpp
Unescape View File

@ -192,8 +192,8 @@ GeneralConfigurationPage::GeneralConfigurationPage(RosegardenGUIDoc *doc,
TQPushButton *showStatusButton = new TQPushButton(i18n("Details..."),
frame);
TQObject::connect(showStatusButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotShowStatus()));
TQObject::connect(showStatusButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotShowStatus()));
layout->addWidget(showStatusButton, row, 2, TQt::AlignRight);
++row;

2
src/gui/configuration/GeneralConfigurationPage.h
Unescape View File

@ -50,7 +50,7 @@ class RosegardenGUIDoc;
*/
class GeneralConfigurationPage : public TabbedConfigurationPage
{
Q_OBJECT
TQ_OBJECT
public:

10
src/gui/configuration/HeadersConfigurationPage.cpp
Unescape View File

@ -57,7 +57,7 @@ HeadersConfigurationPage::HeadersConfigurationPage(TQWidget *parent,
//
TQGroupBox *headersBox = new TQGroupBox
(1, Qt::Horizontal,
(1, TQt::Horizontal,
i18n("Printable headers"), this);
TQFrame *frameHeaders = new TQFrame(headersBox);
TQGridLayout *layoutHeaders = new TQGridLayout(frameHeaders, 10, 6, 10, 5);
@ -215,11 +215,11 @@ HeadersConfigurationPage::HeadersConfigurationPage(TQWidget *parent,
frameOtherHeaders);
layoutOtherHeaders->addWidget(deletePropButton, 1, 1, TQt::AlignHCenter);
connect(addPropButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotAddNewProperty()));
connect(addPropButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotAddNewProperty()));
connect(deletePropButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotDeleteProperty()));
connect(deletePropButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotDeleteProperty()));
}
void

2
src/gui/configuration/HeadersConfigurationPage.h
Unescape View File

@ -37,7 +37,7 @@ class RosegardenGUIDoc;
class HeadersConfigurationPage : public TQVBox
{
Q_OBJECT
TQ_OBJECT
public:

12
src/gui/configuration/LatencyConfigurationPage.cpp
Unescape View File

@ -68,8 +68,8 @@ LatencyConfigurationPage::LatencyConfigurationPage(RosegardenGUIDoc *doc,
layout->addWidget(m_fetchLatencyValues, 1, 3);
connect(m_fetchLatencyValues, TQT_SIGNAL(released()),
TQT_SLOT(slotFetchLatencyValues()));
connect(m_fetchLatencyValues, TQ_SIGNAL(released()),
TQ_SLOT(slotFetchLatencyValues()));
int jackPlaybackValue = (m_cfg->readLongNumEntry(
"jackplaybacklatencyusec", 0) / 1000) +
@ -83,8 +83,8 @@ LatencyConfigurationPage::LatencyConfigurationPage(RosegardenGUIDoc *doc,
TQLabel *jackPlaybackLabel = new TQLabel(TQString("%1").arg(jackPlaybackValue),
frame);
layout->addWidget(jackPlaybackLabel, 2, 2, TQt::AlignHCenter);
connect(m_jackPlayback, TQT_SIGNAL(valueChanged(int)),
jackPlaybackLabel, TQT_SLOT(setNum(int)));
connect(m_jackPlayback, TQ_SIGNAL(valueChanged(int)),
jackPlaybackLabel, TQ_SLOT(setNum(int)));
m_jackPlayback->setMinValue(0);
layout->addWidget(new TQLabel("0", frame), 3, 1, TQt::AlignRight);
@ -106,8 +106,8 @@ LatencyConfigurationPage::LatencyConfigurationPage(RosegardenGUIDoc *doc,
TQLabel *jackRecordLabel = new TQLabel(TQString("%1").arg(jackRecordValue),
frame);
layout->addWidget(jackRecordLabel, 4, 2, TQt::AlignHCenter);
connect(m_jackRecord, TQT_SIGNAL(valueChanged(int)),
jackRecordLabel, TQT_SLOT(setNum(int)));
connect(m_jackRecord, TQ_SIGNAL(valueChanged(int)),
jackRecordLabel, TQ_SLOT(setNum(int)));
m_jackRecord->setMinValue(0);
layout->addWidget(new TQLabel("0", frame), 5, 1, TQt::AlignRight);

2
src/gui/configuration/LatencyConfigurationPage.h
Unescape View File

@ -47,7 +47,7 @@ class RosegardenGUIDoc;
*/
class LatencyConfigurationPage : public TabbedConfigurationPage
{
Q_OBJECT
TQ_OBJECT
public:

14
src/gui/configuration/MIDIConfigurationPage.cpp
Unescape View File

@ -191,14 +191,14 @@ MIDIConfigurationPage::MIDIConfigurationPage(
m_soundFontChoose->setEnabled(false);
}
connect(m_sfxLoadEnabled, TQT_SIGNAL(toggled(bool)),
this, TQT_SLOT(slotSoundFontToggled(bool)));
connect(m_sfxLoadEnabled, TQ_SIGNAL(toggled(bool)),
this, TQ_SLOT(slotSoundFontToggled(bool)));
connect(m_sfxLoadChoose, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotSfxLoadPathChoose()));
connect(m_sfxLoadChoose, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotSfxLoadPathChoose()));
connect(m_soundFontChoose, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotSoundFontChoose()));
connect(m_soundFontChoose, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotSoundFontChoose()));
layout->setRowStretch(row, 10);
@ -363,7 +363,7 @@ MIDIConfigurationPage::apply()
int midiClock = m_midiSync->currentItem();
m_cfg->writeEntry("midiclock", midiClock);
// Now send it (OLD TQT_METHOD - to be removed)
// Now send it (OLD METHOD - to be removed)
//!!! No, don't remove -- this controls SPP as well doesn't it?
//
MappedEvent mEMIDIClock(MidiInstrumentBase, // InstrumentId

2
src/gui/configuration/MIDIConfigurationPage.h
Unescape View File

@ -48,7 +48,7 @@ class RosegardenGUIDoc;
class MIDIConfigurationPage : public TabbedConfigurationPage
{
Q_OBJECT
TQ_OBJECT
public:
MIDIConfigurationPage(RosegardenGUIDoc *doc,

2
src/gui/configuration/MatrixConfigurationPage.h
Unescape View File

@ -42,7 +42,7 @@ namespace Rosegarden
*/
class MatrixConfigurationPage : public TabbedConfigurationPage
{
Q_OBJECT
TQ_OBJECT
public:

8
src/gui/configuration/NotationConfigurationPage.cpp
Unescape View File

@ -444,14 +444,14 @@ NotationConfigurationPage::NotationConfigurationPage(TDEConfig *cfg,
m_viewButton = new TQPushButton(i18n("View"), frame);
layout->addMultiCellWidget(m_font, row, row, 1, 2);
layout->addWidget(m_viewButton, row, 3);
TQObject::connect(m_viewButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotViewButtonPressed()));
TQObject::connect(m_viewButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotViewButtonPressed()));
#else
layout->addMultiCellWidget(m_font, row, row, 1, 3);
#endif
m_font->setEditable(false);
TQObject::connect(m_font, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotFontComboChanged(int)));
TQObject::connect(m_font, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotFontComboChanged(int)));
++row;
TQFrame *subFrame = new TQFrame(frame);

2
src/gui/configuration/NotationConfigurationPage.h
Unescape View File

@ -50,7 +50,7 @@ class QuantizeParameters;
*/
class NotationConfigurationPage : public TabbedConfigurationPage
{
Q_OBJECT
TQ_OBJECT
public:

2
src/gui/configuration/TabbedConfigurationPage.h
Unescape View File

@ -44,7 +44,7 @@ class RosegardenGUIDoc;
*/
class TabbedConfigurationPage : public ConfigurationPage
{
Q_OBJECT
TQ_OBJECT
public:

2
src/gui/dialogs/AddTracksDialog.h
Unescape View File

@ -34,7 +34,7 @@ namespace Rosegarden
class AddTracksDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

84
src/gui/dialogs/AudioManagerDialog.cpp
Unescape View File

@ -127,48 +127,48 @@ AudioManagerDialog::AudioManagerDialog(TQWidget *parent,
TQString pixmapDir = TDEGlobal::dirs()->findResource("appdata", "pixmaps/");
TQIconSet icon(TQPixmap(pixmapDir + "/toolbar/transport-play.xpm"));
new TDEAction(i18n("&Add Audio File..."), "document-open", 0, TQT_TQOBJECT(this),
TQT_SLOT(slotAdd()), actionCollection(), "add_audio");
new TDEAction(i18n("&Add Audio File..."), "document-open", 0, this,
TQ_SLOT(slotAdd()), actionCollection(), "add_audio");
new TDEAction(i18n("&Unload Audio File"), "edit-delete", 0, TQT_TQOBJECT(this),
TQT_SLOT(slotRemove()),
new TDEAction(i18n("&Unload Audio File"), "edit-delete", 0, this,
TQ_SLOT(slotRemove()),
actionCollection(), "remove_audio");
icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/transport-play.xpm"));
new TDEAction(i18n("&Play Preview"), icon, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotPlayPreview()),
new TDEAction(i18n("&Play Preview"), icon, 0, this,
TQ_SLOT(slotPlayPreview()),
actionCollection(), "preview_audio");
/*!!! Not actually implemented -- this never worked right!
new TDEAction(i18n("Re&label"), 0, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotRename()),
new TDEAction(i18n("Re&label"), 0, 0, this,
TQ_SLOT(slotRename()),
actionCollection(), "rename_audio");
*/
icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/insert_audio_into_track.xpm"));
new TDEAction(i18n("&Insert into Selected Audio Track"),
icon, 0, TQT_TQOBJECT(this), TQT_SLOT(slotInsert()),
icon, 0, this, TQ_SLOT(slotInsert()),
actionCollection(), "insert_audio");
new TDEAction(i18n("Unload &all Audio Files"), 0, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotRemoveAll()),
new TDEAction(i18n("Unload &all Audio Files"), 0, 0, this,
TQ_SLOT(slotRemoveAll()),
actionCollection(), "remove_all_audio");
new TDEAction(i18n("Unload all &Unused Audio Files"), 0, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotRemoveAllUnused()),
new TDEAction(i18n("Unload all &Unused Audio Files"), 0, 0, this,
TQ_SLOT(slotRemoveAllUnused()),
actionCollection(), "remove_all_unused_audio");
new TDEAction(i18n("&Delete Unused Audio Files..."), 0, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotDeleteUnused()),
new TDEAction(i18n("&Delete Unused Audio Files..."), 0, 0, this,
TQ_SLOT(slotDeleteUnused()),
actionCollection(), "delete_unused_audio");
new TDEAction(i18n("&Export Audio File..."), "fileexport", 0, TQT_TQOBJECT(this),
TQT_SLOT(slotExportAudio()),
new TDEAction(i18n("&Export Audio File..."), "fileexport", 0, this,
TQ_SLOT(slotExportAudio()),
actionCollection(), "export_audio");
/*
new TDEAction(i18n("Distribute Audio on &MIDI"),
0, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotDistributeOnMidiSegment()),
0, 0, this,
TQ_SLOT(slotDistributeOnMidiSegment()),
actionCollection(),
"distribute_audio");
*/
@ -200,11 +200,11 @@ AudioManagerDialog::AudioManagerDialog(TQWidget *parent,
m_fileList->setShowToolTips(true);
// connect selection mechanism
connect(m_fileList, TQT_SIGNAL(selectionChanged(TQListViewItem*)),
TQT_SLOT(slotSelectionChanged(TQListViewItem*)));
connect(m_fileList, TQ_SIGNAL(selectionChanged(TQListViewItem*)),
TQ_SLOT(slotSelectionChanged(TQListViewItem*)));
connect(m_fileList, TQT_SIGNAL(dropped(TQDropEvent*, TQListViewItem*)),
TQT_SLOT(slotDropped(TQDropEvent*, TQListViewItem*)));
connect(m_fileList, TQ_SIGNAL(dropped(TQDropEvent*, TQListViewItem*)),
TQ_SLOT(slotDropped(TQDropEvent*, TQListViewItem*)));
// setup local accelerators
//
@ -214,22 +214,22 @@ AudioManagerDialog::AudioManagerDialog(TQWidget *parent,
//
m_accelerators->connectItem(m_accelerators->insertItem(Key_Delete),
this,
TQT_SLOT(slotRemove()));
TQ_SLOT(slotRemove()));
slotPopulateFileList();
// Connect command history for updates
//
connect(getCommandHistory(), TQT_SIGNAL(commandExecuted(KCommand *)),
this, TQT_SLOT(slotCommandExecuted(KCommand *)));
connect(getCommandHistory(), TQ_SIGNAL(commandExecuted(KCommand *)),
this, TQ_SLOT(slotCommandExecuted(KCommand *)));
//setInitialSize(configDialogSize(AudioManagerDialogConfigGroup));
connect(m_playTimer, TQT_SIGNAL(timeout()),
this, TQT_SLOT(slotCancelPlayingAudio()));
connect(m_playTimer, TQ_SIGNAL(timeout()),
this, TQ_SLOT(slotCancelPlayingAudio()));
KStdAction::close(TQT_TQOBJECT(this),
TQT_SLOT(slotClose()),
KStdAction::close(this,
TQ_SLOT(slotClose()),
actionCollection());
createGUI("audiomanager.rc");
@ -1091,12 +1091,12 @@ AudioManagerDialog::addFile(const KURL& kurl)
// Connect the progress dialog
//
connect(&aFM, TQT_SIGNAL(setProgress(int)),
progressDlg.progressBar(), TQT_SLOT(setValue(int)));
connect(&aFM, TQT_SIGNAL(setOperationName(TQString)),
&progressDlg, TQT_SLOT(slotSetOperationName(TQString)));
connect(&progressDlg, TQT_SIGNAL(cancelClicked()),
&aFM, TQT_SLOT(slotStopImport()));
connect(&aFM, TQ_SIGNAL(setProgress(int)),
progressDlg.progressBar(), TQ_SLOT(setValue(int)));
connect(&aFM, TQ_SIGNAL(setOperationName(TQString)),
&progressDlg, TQ_SLOT(slotSetOperationName(TQString)));
connect(&progressDlg, TQ_SIGNAL(cancelClicked()),
&aFM, TQ_SLOT(slotStopImport()));
try {
id = aFM.importURL(kurl, m_sampleRate);
@ -1112,10 +1112,10 @@ AudioManagerDialog::addFile(const KURL& kurl)
return false;
}
disconnect(&progressDlg, TQT_SIGNAL(cancelClicked()),
&aFM, TQT_SLOT(slotStopImport()));
connect(&progressDlg, TQT_SIGNAL(cancelClicked()),
&aFM, TQT_SLOT(slotStopPreview()));
disconnect(&progressDlg, TQ_SIGNAL(cancelClicked()),
&aFM, TQ_SLOT(slotStopImport()));
connect(&progressDlg, TQ_SIGNAL(cancelClicked()),
&aFM, TQ_SLOT(slotStopPreview()));
progressDlg.progressBar()->show();
progressDlg.slotSetOperationName(i18n("Generating audio preview..."));
@ -1129,8 +1129,8 @@ AudioManagerDialog::addFile(const KURL& kurl)
KMessageBox::information(this, message);
}
disconnect(&progressDlg, TQT_SIGNAL(cancelClicked()),
&aFM, TQT_SLOT(slotStopPreview()));
disconnect(&progressDlg, TQ_SIGNAL(cancelClicked()),
&aFM, TQ_SLOT(slotStopPreview()));
slotPopulateFileList();

2
src/gui/dialogs/AudioManagerDialog.h
Unescape View File

@ -55,7 +55,7 @@ class AudioFile;
class AudioManagerDialog : public TDEMainWindow
{
Q_OBJECT
TQ_OBJECT
public:

2
src/gui/dialogs/AudioPlayingDialog.h
Unescape View File

@ -38,7 +38,7 @@ namespace Rosegarden
class AudioPlayingDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

40
src/gui/dialogs/AudioPluginDialog.cpp
Unescape View File

@ -95,7 +95,7 @@ AudioPluginDialog::AudioPluginDialog(TQWidget *parent,
TQVBox *vbox = makeVBoxMainWidget();
TQGroupBox *pluginSelectionBox = new TQGroupBox
(1, Qt::Horizontal, i18n("Plugin"), vbox);
(1, TQt::Horizontal, i18n("Plugin"), vbox);
makePluginParamsBox(vbox, 0, 10);
@ -118,8 +118,8 @@ AudioPluginDialog::AudioPluginDialog(TQWidget *parent,
TQToolTip::add
(m_bypass, i18n("Bypass this plugin."));
connect(m_bypass, TQT_SIGNAL(toggled(bool)),
this, TQT_SLOT(slotBypassChanged(bool)));
connect(m_bypass, TQ_SIGNAL(toggled(bool)),
this, TQ_SLOT(slotBypassChanged(bool)));
m_insOuts = new TQLabel(i18n("<ports>"), h);
@ -132,29 +132,29 @@ AudioPluginDialog::AudioPluginDialog(TQWidget *parent,
TQToolTip::add
(m_pluginId, i18n("Unique ID of plugin."));
connect(m_pluginList, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotPluginSelected(int)));
connect(m_pluginList, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotPluginSelected(int)));
connect(m_pluginCategoryList, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotCategorySelected(int)));
connect(m_pluginCategoryList, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotCategorySelected(int)));
// new line
h = new TQHBox(pluginSelectionBox);
m_copyButton = new TQPushButton(i18n("Copy"), h);
connect(m_copyButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotCopy()));
connect(m_copyButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotCopy()));
TQToolTip::add
(m_copyButton, i18n("Copy plugin parameters"));
m_pasteButton = new TQPushButton(i18n("Paste"), h);
connect(m_pasteButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotPaste()));
connect(m_pasteButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotPaste()));
TQToolTip::add
(m_pasteButton, i18n("Paste plugin parameters"));
m_defaultButton = new TQPushButton(i18n("Default"), h);
connect(m_defaultButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotDefault()));
connect(m_defaultButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotDefault()));
TQToolTip::add
(m_defaultButton, i18n("Set to defaults"));
@ -523,8 +523,8 @@ AudioPluginDialog::slotPluginSelected(int i)
m_gridLayout->addMultiCellWidget(m_programCombo,
0, 0, 1, m_gridLayout->numCols() - 1,
TQt::AlignLeft);
connect(m_programCombo, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotPluginProgramChanged(const TQString &)));
connect(m_programCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotPluginProgramChanged(const TQString &)));
m_programCombo->clear();
m_programCombo->insertItem(i18n("<none selected>"));
@ -553,8 +553,8 @@ AudioPluginDialog::slotPluginSelected(int i)
showBounds,
portCount > tooManyPorts);
connect(control, TQT_SIGNAL(valueChanged(float)),
this, TQT_SLOT(slotPluginPortChanged(float)));
connect(control, TQ_SIGNAL(valueChanged(float)),
this, TQ_SLOT(slotPluginPortChanged(float)));
m_pluginWidgets.push_back(control);
}
@ -602,7 +602,7 @@ AudioPluginDialog::getProgramsForInstance(AudioPluginInstance *inst, int &curren
void
AudioPluginDialog::slotPluginPortChanged(float value)
{
const TQObject* object = TQT_TQOBJECT_CONST(const_cast<const TQT_BASE_OBJECT_NAME*>(sender()));
const TQObject* object = sender();
const PluginControl* control = dynamic_cast<const PluginControl*>(object);
@ -720,8 +720,8 @@ AudioPluginDialog::updatePluginProgramList()
m_programCombo->show();
m_programCombo->blockSignals(true);
connect(m_programCombo, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotPluginProgramChanged(const TQString &)));
connect(m_programCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotPluginProgramChanged(const TQString &)));
} else {
return ;

2
src/gui/dialogs/AudioPluginDialog.h
Unescape View File

@ -54,7 +54,7 @@ class AudioPluginInstance;
class AudioPluginDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

6
src/gui/dialogs/AudioSplitDialog.cpp
Unescape View File

@ -68,7 +68,7 @@ AudioSplitDialog::AudioSplitDialog(TQWidget *parent,
new TQLabel(i18n("AutoSplit Segment \"") +
strtoqstr(m_segment->getLabel()) + TQString("\""), w);
m_canvas = new TQCanvas(TQT_TQOBJECT(w));
m_canvas = new TQCanvas(w);
m_canvas->resize(m_canvasWidth, m_canvasHeight);
m_canvasView = new TQCanvasView(m_canvas, w);
m_canvasView->setFixedWidth(m_canvasWidth);
@ -82,8 +82,8 @@ AudioSplitDialog::AudioSplitDialog(TQWidget *parent,
new TQLabel(i18n("Threshold"), hbox);
m_thresholdSpin = new TQSpinBox(hbox);
m_thresholdSpin->setSuffix(" %");
connect(m_thresholdSpin, TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotThresholdChanged(int)));
connect(m_thresholdSpin, TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotThresholdChanged(int)));
// ensure this is cleared
m_previewBoxes.clear();

2
src/gui/dialogs/AudioSplitDialog.h
Unescape View File

@ -43,7 +43,7 @@ class RosegardenGUIDoc;
class AudioSplitDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:
AudioSplitDialog(TQWidget *parent,

2
src/gui/dialogs/BeatsBarsDialog.cpp
Unescape View File

@ -44,7 +44,7 @@ BeatsBarsDialog::BeatsBarsDialog(TQWidget* parent) :
{
TQHBox *hbox = makeHBoxMainWidget();
TQGroupBox *gbox = new TQGroupBox(1, Qt::Horizontal,
TQGroupBox *gbox = new TQGroupBox(1, TQt::Horizontal,
i18n("The selected audio segment contains:"), hbox);
TQFrame *frame = new TQFrame(gbox);

2
src/gui/dialogs/BeatsBarsDialog.h
Unescape View File

@ -39,7 +39,7 @@ namespace Rosegarden
*/
class BeatsBarsDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

20
src/gui/dialogs/ClefDialog.cpp
Unescape View File

@ -57,31 +57,31 @@ ClefDialog::ClefDialog(TQWidget *parent,
TQVBox *vbox = makeVBoxMainWidget();
TQGroupBox *clefFrame = new TQGroupBox
(1, Qt::Horizontal, i18n("Clef"), vbox);
(1, TQt::Horizontal, i18n("Clef"), vbox);
TQButtonGroup *conversionFrame = new TQButtonGroup
(1, Qt::Horizontal, i18n("Existing notes following clef change"), vbox);
(1, TQt::Horizontal, i18n("Existing notes following clef change"), vbox);
TQHBox *clefBox = new TQHBox(clefFrame);
BigArrowButton *clefDown = new BigArrowButton(clefBox, Qt::LeftArrow);
BigArrowButton *clefDown = new BigArrowButton(clefBox, TQt::LeftArrow);
TQToolTip::add
(clefDown, i18n("Lower clef"));
TQHBox *clefLabelBox = new TQVBox(clefBox);
m_octaveUp = new BigArrowButton(clefLabelBox, Qt::UpArrow);
m_octaveUp = new BigArrowButton(clefLabelBox, TQt::UpArrow);
TQToolTip::add
(m_octaveUp, i18n("Up an Octave"));
m_clefLabel = new TQLabel(i18n("Clef"), clefLabelBox);
m_clefLabel->setAlignment(AlignVCenter | AlignHCenter);
m_octaveDown = new BigArrowButton(clefLabelBox, Qt::DownArrow);
m_octaveDown = new BigArrowButton(clefLabelBox, TQt::DownArrow);
TQToolTip::add
(m_octaveDown, i18n("Down an Octave"));
BigArrowButton *clefUp = new BigArrowButton(clefBox, Qt::RightArrow);
BigArrowButton *clefUp = new BigArrowButton(clefBox, TQt::RightArrow);
TQToolTip::add
(clefUp, i18n("Higher clef"));
@ -109,10 +109,10 @@ ClefDialog::ClefDialog(TQWidget *parent,
conversionFrame->hide();
}
TQObject::connect(clefUp, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotClefUp()));
TQObject::connect(clefDown, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotClefDown()));
TQObject::connect(m_octaveUp, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotOctaveUp()));
TQObject::connect(m_octaveDown, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotOctaveDown()));
TQObject::connect(clefUp, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotClefUp()));
TQObject::connect(clefDown, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotClefDown()));
TQObject::connect(m_octaveUp, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotOctaveUp()));
TQObject::connect(m_octaveDown, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotOctaveDown()));
redrawClefPixmap();
}

2
src/gui/dialogs/ClefDialog.h
Unescape View File

@ -41,7 +41,7 @@ class NotePixmapFactory;
class ClefDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

2
src/gui/dialogs/CompositionLengthDialog.h
Unescape View File

@ -39,7 +39,7 @@ class Composition;
class CompositionLengthDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:
CompositionLengthDialog(TQWidget *parent,

8
src/gui/dialogs/ConfigureDialog.cpp
Unescape View File

@ -78,10 +78,10 @@ ConfigureDialog::ConfigureDialog(RosegardenGUIDoc *doc,
page->setPageIndex(pageIndex(pageWidget));
m_configurationPages.push_back(page);
connect(page, TQT_SIGNAL(updateAutoSaveInterval(unsigned int)),
this, TQT_SIGNAL(updateAutoSaveInterval(unsigned int)));
connect(page, TQT_SIGNAL(updateSidebarStyle(unsigned int)),
this, TQT_SIGNAL(updateSidebarStyle(unsigned int)));
connect(page, TQ_SIGNAL(updateAutoSaveInterval(unsigned int)),
this, TQ_SIGNAL(updateAutoSaveInterval(unsigned int)));
connect(page, TQ_SIGNAL(updateSidebarStyle(unsigned int)),
this, TQ_SIGNAL(updateSidebarStyle(unsigned int)));
pageWidget = addPage(MIDIConfigurationPage::iconLabel(),
MIDIConfigurationPage::title(),

2
src/gui/dialogs/ConfigureDialog.h
Unescape View File

@ -38,7 +38,7 @@ class RosegardenGUIDoc;
class ConfigureDialog : public ConfigureDialogBase
{
Q_OBJECT
TQ_OBJECT
public:
ConfigureDialog(RosegardenGUIDoc *doc,

2
src/gui/dialogs/ConfigureDialogBase.h
Unescape View File

@ -39,7 +39,7 @@ class ConfigurationPage;
class ConfigureDialogBase : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:
ConfigureDialogBase(TQWidget *parent=0,

2
src/gui/dialogs/CountdownBar.h
Unescape View File

@ -37,7 +37,7 @@ namespace Rosegarden
class CountdownBar : public TQFrame
{
Q_OBJECT
TQ_OBJECT
public:
CountdownBar(TQWidget *parent, int width, int height);

2
src/gui/dialogs/CountdownDialog.cpp
Unescape View File

@ -69,7 +69,7 @@ CountdownDialog::CountdownDialog(TQWidget *parent, int seconds):
layout->addWidget(m_progressBar, 0, AlignCenter);
layout->addWidget(m_stopButton, 0, AlignRight);
connect (m_stopButton, TQT_SIGNAL(released()), this, TQT_SIGNAL(stopped()));
connect (m_stopButton, TQ_SIGNAL(released()), this, TQ_SIGNAL(stopped()));
// Set the total time to show the bar in initial position
//

2
src/gui/dialogs/CountdownDialog.h
Unescape View File

@ -42,7 +42,7 @@ class CountdownBar;
class CountdownDialog : public TQDialog // KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

68
src/gui/dialogs/EventEditDialog.cpp
Unescape View File

@ -76,9 +76,9 @@ EventEditDialog::EventEditDialog(TQWidget *parent,
TQVBox *vbox = makeVBoxMainWidget();
TQGroupBox *intrinsicBox = new TQGroupBox
(1, Qt::Horizontal, i18n("Intrinsics"), vbox);
(1, TQt::Horizontal, i18n("Intrinsics"), vbox);
TQGrid *intrinsicGrid = new TQGrid(4, Qt::Horizontal, intrinsicBox);
TQGrid *intrinsicGrid = new TQGrid(4, TQt::Horizontal, intrinsicBox);
new TQLabel(i18n("Event type: "), intrinsicGrid);
new TQLabel("", intrinsicGrid);
@ -92,8 +92,8 @@ EventEditDialog::EventEditDialog(TQWidget *parent,
TQSpinBox *absoluteTime = new TQSpinBox
(INT_MIN, INT_MAX, Note(Note::Shortest).getDuration(), intrinsicGrid);
absoluteTime->setValue(event.getAbsoluteTime());
TQObject::connect(absoluteTime, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotAbsoluteTimeChanged(int)));
TQObject::connect(absoluteTime, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotAbsoluteTimeChanged(int)));
slotAbsoluteTimeChanged(event.getAbsoluteTime());
new TQLabel(i18n("Duration: "), intrinsicGrid);
@ -105,8 +105,8 @@ EventEditDialog::EventEditDialog(TQWidget *parent,
TQSpinBox *duration = new TQSpinBox
(0, INT_MAX, Note(Note::Shortest).getDuration(), intrinsicGrid);
duration->setValue(event.getDuration());
TQObject::connect(duration, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotDurationChanged(int)));
TQObject::connect(duration, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotDurationChanged(int)));
slotDurationChanged(event.getDuration());
new TQLabel(i18n("Sub-ordering: "), intrinsicGrid);
@ -115,13 +115,13 @@ EventEditDialog::EventEditDialog(TQWidget *parent,
TQSpinBox *subOrdering = new TQSpinBox( -100, 100, 1, intrinsicGrid);
subOrdering->setValue(event.getSubOrdering());
TQObject::connect(subOrdering, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotSubOrderingChanged(int)));
TQObject::connect(subOrdering, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotSubOrderingChanged(int)));
slotSubOrderingChanged(event.getSubOrdering());
TQGroupBox *persistentBox = new TQGroupBox
(1, Qt::Horizontal, i18n("Persistent properties"), vbox);
m_persistentGrid = new TQGrid(4, Qt::Horizontal, persistentBox);
(1, TQt::Horizontal, i18n("Persistent properties"), vbox);
m_persistentGrid = new TQGrid(4, TQt::Horizontal, persistentBox);
TQLabel *label = new TQLabel(i18n("Name"), m_persistentGrid);
TQFont font(label->font());
@ -150,7 +150,7 @@ EventEditDialog::EventEditDialog(TQWidget *parent,
} else {
TQGroupBox *nonPersistentBox = new TQGroupBox
(1, Qt::Horizontal, i18n("Non-persistent properties"), vbox);
(1, TQt::Horizontal, i18n("Non-persistent properties"), vbox);
new TQLabel(i18n("These are cached values, lost if the event is modified."),
nonPersistentBox);
@ -159,7 +159,7 @@ EventEditDialog::EventEditDialog(TQWidget *parent,
m_nonPersistentView->setResizePolicy(TQScrollView::AutoOneFit);
m_nonPersistentGrid = new TQGrid
(4, Qt::Horizontal, m_nonPersistentView->viewport());
(4, TQt::Horizontal, m_nonPersistentView->viewport());
m_nonPersistentView->addChild(m_nonPersistentGrid);
m_nonPersistentGrid->setSpacing(4);
@ -184,8 +184,8 @@ EventEditDialog::EventEditDialog(TQWidget *parent,
button->setFixedSize(TQSize(24, 24));
TQToolTip::add
(button, i18n("Make persistent"));
TQObject::connect(button, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotPropertyMadePersistent()));
TQObject::connect(button, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotPropertyMadePersistent()));
}
}
}
@ -213,8 +213,8 @@ EventEditDialog::addPersistentProperty(const PropertyName &name)
TQSpinBox *spinBox = new TQSpinBox
(min, max, 1, m_persistentGrid, strtoqstr(name).ascii());
spinBox->setValue(m_originalEvent.get<Int>(name));
TQObject::connect(spinBox, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotIntPropertyChanged(int)));
TQObject::connect(spinBox, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotIntPropertyChanged(int)));
spinBox->show();
break;
}
@ -228,8 +228,8 @@ case UInt: {
TQSpinBox *spinBox = new TQSpinBox
(min, max, 1, m_persistentGrid, strtoqstr(name).ascii());
spinBox->setValue(m_originalEvent.get<UInt>(name));
TQObject::connect(spinBox, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotIntPropertyChanged(int)));
TQObject::connect(spinBox, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotIntPropertyChanged(int)));
spinBox->show();
break;
}
@ -245,8 +245,8 @@ case UInt: {
hbox, TQString(strtoqstr(name) + "%sec").ascii());
spinBox->setValue(realTime.sec);
TQObject::connect(spinBox, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotRealTimePropertyChanged(int)));
TQObject::connect(spinBox, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotRealTimePropertyChanged(int)));
// nseconds
//
@ -255,8 +255,8 @@ case UInt: {
hbox, TQString(strtoqstr(name) + "%nsec").ascii());
spinBox->setValue(realTime.nsec);
TQObject::connect(spinBox, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotRealTimePropertyChanged(int)));
TQObject::connect(spinBox, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotRealTimePropertyChanged(int)));
spinBox->show();
break;
}
@ -265,8 +265,8 @@ case UInt: {
TQCheckBox *checkBox = new TQCheckBox
("", m_persistentGrid, strtoqstr(name).ascii());
checkBox->setChecked(m_originalEvent.get<Bool>(name));
TQObject::connect(checkBox, TQT_SIGNAL(activated()),
this, TQT_SLOT(slotBoolPropertyChanged()));
TQObject::connect(checkBox, TQ_SIGNAL(activated()),
this, TQ_SLOT(slotBoolPropertyChanged()));
checkBox->show();
break;
}
@ -276,8 +276,8 @@ case UInt: {
(strtoqstr(m_originalEvent.get<String>(name)),
m_persistentGrid,
strtoqstr(name).ascii());
TQObject::connect(lineEdit, TQT_SIGNAL(textChanged(const TQString &)),
this, TQT_SLOT(slotStringPropertyChanged(const TQString &)));
TQObject::connect(lineEdit, TQ_SIGNAL(textChanged(const TQString &)),
this, TQ_SLOT(slotStringPropertyChanged(const TQString &)));
lineEdit->show();
break;
}
@ -288,8 +288,8 @@ case UInt: {
button->setFixedSize(TQSize(24, 24));
TQToolTip::add
(button, i18n("Delete this property"));
TQObject::connect(button, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotPropertyDeleted()));
TQObject::connect(button, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotPropertyDeleted()));
button->show();
}
@ -354,7 +354,7 @@ EventEditDialog::slotSubOrderingChanged(int value)
void
EventEditDialog::slotIntPropertyChanged(int value)
{
const TQObject *s = TQT_TQOBJECT_CONST(const_cast<const TQT_BASE_OBJECT_NAME*>(sender()));
const TQObject *s = sender();
const TQSpinBox *spinBox = dynamic_cast<const TQSpinBox *>(s);
if (!spinBox)
return ;
@ -367,7 +367,7 @@ EventEditDialog::slotIntPropertyChanged(int value)
void
EventEditDialog::slotRealTimePropertyChanged(int value)
{
const TQObject *s = TQT_TQOBJECT_CONST(const_cast<const TQT_BASE_OBJECT_NAME*>(sender()));
const TQObject *s = sender();
const TQSpinBox *spinBox = dynamic_cast<const TQSpinBox *>(s);
if (!spinBox)
return ;
@ -391,7 +391,7 @@ EventEditDialog::slotRealTimePropertyChanged(int value)
void
EventEditDialog::slotBoolPropertyChanged()
{
const TQObject *s = TQT_TQOBJECT_CONST(const_cast<const TQT_BASE_OBJECT_NAME*>(sender()));
const TQObject *s = sender();
const TQCheckBox *checkBox = dynamic_cast<const TQCheckBox *>(s);
if (!checkBox)
return ;
@ -406,7 +406,7 @@ EventEditDialog::slotBoolPropertyChanged()
void
EventEditDialog::slotStringPropertyChanged(const TQString &value)
{
const TQObject *s = TQT_TQOBJECT_CONST(const_cast<const TQT_BASE_OBJECT_NAME*>(sender()));
const TQObject *s = sender();
const TQLineEdit *lineEdit = dynamic_cast<const TQLineEdit *>(s);
if (!lineEdit)
return ;
@ -419,7 +419,7 @@ EventEditDialog::slotStringPropertyChanged(const TQString &value)
void
EventEditDialog::slotPropertyDeleted()
{
const TQObject *s = TQT_TQOBJECT_CONST(const_cast<const TQT_BASE_OBJECT_NAME*>(sender()));
const TQObject *s = sender();
const TQPushButton *pushButton = dynamic_cast<const TQPushButton *>(s);
if (!pushButton)
return ;
@ -451,7 +451,7 @@ EventEditDialog::slotPropertyDeleted()
void
EventEditDialog::slotPropertyMadePersistent()
{
const TQObject *s = TQT_TQOBJECT_CONST(const_cast<const TQT_BASE_OBJECT_NAME*>(sender()));
const TQObject *s = sender();
const TQPushButton *pushButton = dynamic_cast<const TQPushButton *>(s);
if (!pushButton)
return ;

2
src/gui/dialogs/EventEditDialog.h
Unescape View File

@ -44,7 +44,7 @@ class PropertyName;
class EventEditDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

36
src/gui/dialogs/EventFilterDialog.cpp
Unescape View File

@ -128,8 +128,8 @@ EventFilterDialog::initDialog()
cfg->setGroup(EventFilterDialogConfigGroup);
m_pitchFromSpinBox->setValue(cfg->readUnsignedNumEntry("pitchfrom", 0));
noteFrameLayout->addWidget(m_pitchFromSpinBox, 1, 2);
connect(m_pitchFromSpinBox, TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotPitchFromChanged(int)));
connect(m_pitchFromSpinBox, TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotPitchFromChanged(int)));
m_pitchFromChooserButton = new TQPushButton(i18n("edit"), noteFrame);
m_pitchFromChooserButton->setSizePolicy(TQSizePolicy((TQSizePolicy::SizeType)0,
@ -138,8 +138,8 @@ EventFilterDialog::initDialog()
TQToolTip::add
(m_pitchFromChooserButton, i18n("choose a pitch using a staff"));
noteFrameLayout->addWidget(m_pitchFromChooserButton, 1, 3);
connect(m_pitchFromChooserButton, TQT_SIGNAL(clicked()),
TQT_SLOT(slotPitchFromChooser()));
connect(m_pitchFromChooserButton, TQ_SIGNAL(clicked()),
TQ_SLOT(slotPitchFromChooser()));
// Pitch To
m_pitchToSpinBox = new TQSpinBox(noteFrame);
@ -147,15 +147,15 @@ EventFilterDialog::initDialog()
cfg->setGroup(EventFilterDialogConfigGroup);
m_pitchToSpinBox->setValue(cfg->readUnsignedNumEntry("pitchto", 127));
noteFrameLayout->addWidget(m_pitchToSpinBox, 1, 4);
connect(m_pitchToSpinBox, TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotPitchToChanged(int)));
connect(m_pitchToSpinBox, TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotPitchToChanged(int)));
m_pitchToChooserButton = new TQPushButton(i18n("edit"), noteFrame);
TQToolTip::add
(m_pitchToChooserButton, i18n("choose a pitch using a staff"));
noteFrameLayout->addWidget(m_pitchToChooserButton, 1, 5);
connect(m_pitchToChooserButton, TQT_SIGNAL(clicked()),
TQT_SLOT(slotPitchToChooser()));
connect(m_pitchToChooserButton, TQ_SIGNAL(clicked()),
TQ_SLOT(slotPitchToChooser()));
// Velocity From/To
m_velocityFromSpinBox = new TQSpinBox(noteFrame);
@ -163,30 +163,30 @@ EventFilterDialog::initDialog()
cfg->setGroup(EventFilterDialogConfigGroup);
m_velocityFromSpinBox->setValue(cfg->readUnsignedNumEntry("velocityfrom", 0));
noteFrameLayout->addWidget(m_velocityFromSpinBox, 2, 2);
connect(m_velocityFromSpinBox, TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotVelocityFromChanged(int)));
connect(m_velocityFromSpinBox, TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotVelocityFromChanged(int)));
m_velocityToSpinBox = new TQSpinBox(noteFrame);
m_velocityToSpinBox->setMaxValue(127);
cfg->setGroup(EventFilterDialogConfigGroup);
m_velocityToSpinBox->setValue(cfg->readUnsignedNumEntry("velocityto", 127));
noteFrameLayout->addWidget( m_velocityToSpinBox, 2, 4 );
connect(m_velocityToSpinBox, TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotVelocityToChanged(int)));
connect(m_velocityToSpinBox, TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotVelocityToChanged(int)));
// Duration From/To
m_noteDurationFromComboBox = new TQComboBox(0, noteFrame);
m_noteDurationFromComboBox->insertItem(i18n("longest"));
noteFrameLayout->addWidget(m_noteDurationFromComboBox, 3, 2);
connect(m_noteDurationFromComboBox, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotDurationFromChanged(int)));
connect(m_noteDurationFromComboBox, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotDurationFromChanged(int)));
m_noteDurationToComboBox = new TQComboBox(0, noteFrame);
m_noteDurationToComboBox->insertItem(i18n("longest"));
noteFrameLayout->addWidget(m_noteDurationToComboBox, 3, 4);
connect(m_noteDurationToComboBox, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotDurationToChanged(int)));
connect(m_noteDurationToComboBox, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotDurationToChanged(int)));
populateDurationCombos();
@ -207,8 +207,8 @@ EventFilterDialog::initDialog()
(m_buttonNone, i18n("Exclude entire range of values"));
buttonLayout->addWidget( m_buttonNone, 0, 1 );
connect(m_buttonAll, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotToggleAll()));
connect(m_buttonNone, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotToggleNone()));
connect(m_buttonAll, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotToggleAll()));
connect(m_buttonNone, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotToggleNone()));
}

2
src/gui/dialogs/EventFilterDialog.h
Unescape View File

@ -56,7 +56,7 @@ class Event;
*/
class EventFilterDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

4
src/gui/dialogs/EventParameterDialog.cpp
Unescape View File

@ -80,8 +80,8 @@ EventParameterDialog::EventParameterDialog(
text = i18n("Ringing - set %1 alternating from max to min with both dying to zero").arg(strtoqstr(property));
m_patternCombo->insertItem(text);
connect(m_patternCombo, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotPatternSelected(int)));
connect(m_patternCombo, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotPatternSelected(int)));
TQHBox *value1Box = new TQHBox(vBox);
m_value1Label = new TQLabel(i18n("Value"), value1Box);

2
src/gui/dialogs/EventParameterDialog.h
Unescape View File

@ -40,7 +40,7 @@ namespace Rosegarden
class EventParameterDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

2
src/gui/dialogs/ExportDeviceDialog.cpp
Unescape View File

@ -41,7 +41,7 @@ ExportDeviceDialog::ExportDeviceDialog(TQWidget *parent, TQString deviceName) :
Ok | Cancel, Ok)
{
TQVBox *vbox = makeVBoxMainWidget();
TQButtonGroup *bg = new TQButtonGroup(1, Qt::Horizontal,
TQButtonGroup *bg = new TQButtonGroup(1, TQt::Horizontal,
i18n("Export devices"),
vbox);
m_exportAll = new TQRadioButton(i18n("Export all devices"), bg);

2
src/gui/dialogs/FileLocateDialog.h
Unescape View File

@ -37,7 +37,7 @@ namespace Rosegarden
class FileLocateDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

2
src/gui/dialogs/FileMergeDialog.h
Unescape View File

@ -39,7 +39,7 @@ namespace Rosegarden
class FileMergeDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

2
src/gui/dialogs/FloatEdit.cpp
Unescape View File

@ -45,7 +45,7 @@ FloatEdit::FloatEdit(TQWidget *parent,
KDialogBase(parent, "rosegardenFloatEdit", true, title, Ok | Cancel, Ok)
{
TQVBox *vbox = makeVBoxMainWidget();
TQGroupBox *groupBox = new TQGroupBox(1, Qt::Horizontal, text, vbox);
TQGroupBox *groupBox = new TQGroupBox(1, TQt::Horizontal, text, vbox);
TQVBox *inVbox = new TQVBox(groupBox);
// Calculate decimal points according to the step size

2
src/gui/dialogs/FloatEdit.h
Unescape View File

@ -39,7 +39,7 @@ class HSpinBox;
class FloatEdit : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

4
src/gui/dialogs/IdentifyTextCodecDialog.cpp
Unescape View File

@ -134,8 +134,8 @@ IdentifyTextCodecDialog::IdentifyTextCodecDialog(TQWidget *parent,
++i;
}
connect(codecs, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotCodecSelected(int)));
connect(codecs, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotCodecSelected(int)));
new TQLabel(i18n("\nExample text from file:"), vbox);
m_example = new TQLabel("", vbox);

2
src/gui/dialogs/IdentifyTextCodecDialog.h
Unescape View File

@ -39,7 +39,7 @@ namespace Rosegarden
class IdentifyTextCodecDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

6
src/gui/dialogs/ImportDeviceDialog.cpp
Unescape View File

@ -107,7 +107,7 @@ ImportDeviceDialog::doImport()
return false;
}
TQGroupBox *groupBox = new TQGroupBox(2, Qt::Horizontal,
TQGroupBox *groupBox = new TQGroupBox(2, TQt::Horizontal,
i18n("Source device"),
mainFrame);
@ -147,7 +147,7 @@ ImportDeviceDialog::doImport()
TQHBox *optionsBox = new TQHBox(mainFrame);
TQGroupBox *gb = new TQGroupBox(1, Qt::Horizontal, i18n("Options"),
TQGroupBox *gb = new TQGroupBox(1, TQt::Horizontal, i18n("Options"),
optionsBox);
m_importBanks = new TQCheckBox(i18n("Import banks"), gb);
@ -160,7 +160,7 @@ ImportDeviceDialog::doImport()
m_rename = 0;
}
m_buttonGroup = new TQButtonGroup(1, Qt::Horizontal,
m_buttonGroup = new TQButtonGroup(1, TQt::Horizontal,
i18n("Bank import behavior"),
optionsBox);
m_mergeBanks = new TQRadioButton(i18n("Merge banks"), m_buttonGroup);

2
src/gui/dialogs/ImportDeviceDialog.h
Unescape View File

@ -51,7 +51,7 @@ class RosegardenGUIDoc;
class ImportDeviceDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

4
src/gui/dialogs/InterpretDialog.cpp
Unescape View File

@ -45,7 +45,7 @@ InterpretDialog::InterpretDialog(TQWidget *parent) :
TQVBox *vbox = makeVBoxMainWidget();
TQGroupBox *groupBox = new TQGroupBox
(1, Qt::Horizontal, i18n("Interpretations to apply"), vbox);
(1, TQt::Horizontal, i18n("Interpretations to apply"), vbox);
m_applyTextDynamics = new TQCheckBox
(i18n("Apply text dynamics (p, mf, ff etc)"), groupBox);
@ -73,7 +73,7 @@ InterpretDialog::InterpretDialog(TQWidget *parent) :
(config->readBoolEntry("interpretarticulate", true));
connect(m_allInterpretations,
TQT_SIGNAL(clicked()), this, TQT_SLOT(slotAllBoxChanged()));
TQ_SIGNAL(clicked()), this, TQ_SLOT(slotAllBoxChanged()));
slotAllBoxChanged();
}

2
src/gui/dialogs/InterpretDialog.h
Unescape View File

@ -37,7 +37,7 @@ namespace Rosegarden
class InterpretDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:
InterpretDialog(TQWidget *parent);

10
src/gui/dialogs/IntervalDialog.cpp
Unescape View File

@ -71,7 +71,7 @@ IntervalDialog::IntervalDialog(TQWidget *parent, bool askChangeKey, bool askTran
if (askChangeKey)
{
TQButtonGroup *affectKeyGroup = new TQButtonGroup(1, Qt::Horizontal, i18n("Effect on Key"), vBox);
TQButtonGroup *affectKeyGroup = new TQButtonGroup(1, TQt::Horizontal, i18n("Effect on Key"), vBox);
m_transposeWithinKey = new TQRadioButton(i18n("Transpose within key"), affectKeyGroup);
m_transposeWithinKey->setChecked(true);
m_transposeChangingKey = new TQRadioButton(i18n("Change key for selection"), affectKeyGroup);
@ -93,11 +93,11 @@ IntervalDialog::IntervalDialog(TQWidget *parent, bool askChangeKey, bool askTran
m_transposeSegmentBack = NULL;
}
connect(m_referencenote, TQT_SIGNAL(noteChanged(int,int,int)),
this, TQT_SLOT(slotSetReferenceNote(int,int,int)));
connect(m_referencenote, TQ_SIGNAL(noteChanged(int,int,int)),
this, TQ_SLOT(slotSetReferenceNote(int,int,int)));
connect(m_targetnote, TQT_SIGNAL(noteChanged(int,int,int)),
this, TQT_SLOT(slotSetTargetNote(int,int,int)));
connect(m_targetnote, TQ_SIGNAL(noteChanged(int,int,int)),
this, TQ_SLOT(slotSetTargetNote(int,int,int)));
}
// number of octaves the notes are apart

2
src/gui/dialogs/IntervalDialog.h
Unescape View File

@ -43,7 +43,7 @@ class RosegardenGUIDoc;
class IntervalDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:
IntervalDialog(TQWidget *parent, bool askChangeKey = false, bool askTransposeSegmentBack = false);

28
src/gui/dialogs/KeySignatureDialog.cpp
Unescape View File

@ -72,16 +72,16 @@ KeySignatureDialog::KeySignatureDialog(TQWidget *parent,
TQHBox *nameBox = 0;
TQGroupBox *keyFrame = new TQGroupBox
(1, Qt::Horizontal, i18n("Key signature"), vbox);
(1, TQt::Horizontal, i18n("Key signature"), vbox);
TQGroupBox *transposeFrame = new TQButtonGroup
(1, Qt::Horizontal, i18n("Key transposition"), vbox);
(1, TQt::Horizontal, i18n("Key transposition"), vbox);
TQGroupBox *buttonFrame = new TQButtonGroup
(1, Qt::Horizontal, i18n("Scope"), vbox);
(1, TQt::Horizontal, i18n("Scope"), vbox);
TQButtonGroup *conversionFrame = new TQButtonGroup
(1, Qt::Horizontal, i18n("Existing notes following key change"), vbox);
(1, TQt::Horizontal, i18n("Existing notes following key change"), vbox);
keyBox = new TQHBox(keyFrame);
nameBox = new TQHBox(keyFrame);
@ -91,14 +91,14 @@ KeySignatureDialog::KeySignatureDialog(TQWidget *parent,
explanatoryLabel = new TQLabel(explanatoryText, keyFrame);
}
BigArrowButton *keyDown = new BigArrowButton(keyBox, Qt::LeftArrow);
BigArrowButton *keyDown = new BigArrowButton(keyBox, TQt::LeftArrow);
TQToolTip::add
(keyDown, i18n("Flatten"));
m_keyLabel = new TQLabel(i18n("Key"), keyBox);
m_keyLabel->setAlignment(AlignVCenter | AlignHCenter);
BigArrowButton *keyUp = new BigArrowButton(keyBox, Qt::RightArrow);
BigArrowButton *keyUp = new BigArrowButton(keyBox, TQt::RightArrow);
TQToolTip::add
(keyUp, i18n("Sharpen"));
@ -162,14 +162,14 @@ KeySignatureDialog::KeySignatureDialog(TQWidget *parent,
conversionFrame->hide();
}
TQObject::connect(keyUp, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotKeyUp()));
TQObject::connect(keyDown, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotKeyDown()));
TQObject::connect(m_keyCombo, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotKeyNameChanged(const TQString &)));
TQObject::connect(m_keyCombo, TQT_SIGNAL(textChanged(const TQString &)),
this, TQT_SLOT(slotKeyNameChanged(const TQString &)));
TQObject::connect(m_majorMinorCombo, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotMajorMinorChanged(const TQString &)));
TQObject::connect(keyUp, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotKeyUp()));
TQObject::connect(keyDown, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotKeyDown()));
TQObject::connect(m_keyCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotKeyNameChanged(const TQString &)));
TQObject::connect(m_keyCombo, TQ_SIGNAL(textChanged(const TQString &)),
this, TQ_SLOT(slotKeyNameChanged(const TQString &)));
TQObject::connect(m_majorMinorCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotMajorMinorChanged(const TQString &)));
}
KeySignatureDialog::ConversionType

2
src/gui/dialogs/KeySignatureDialog.h
Unescape View File

@ -45,7 +45,7 @@ class NotePixmapFactory;
class KeySignatureDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

10
src/gui/dialogs/LilyPondOptionsDialog.cpp
Unescape View File

@ -100,7 +100,7 @@ LilyPondOptionsDialog::LilyPondOptionsDialog(TQWidget *parent,
//
TQGroupBox *basicOptionsBox = new TQGroupBox
(1, Qt::Horizontal,
(1, TQt::Horizontal,
i18n("Basic options"), generalFrame);
generalGrid->addWidget(basicOptionsBox, 0, 0);
@ -163,7 +163,7 @@ LilyPondOptionsDialog::LilyPondOptionsDialog(TQWidget *parent,
//
TQGroupBox *staffOptionsBox = new TQGroupBox
(1, Qt::Horizontal,
(1, TQt::Horizontal,
i18n("Staff level options"), generalFrame);
generalGrid->addWidget(staffOptionsBox, 1, 0);
@ -192,7 +192,7 @@ LilyPondOptionsDialog::LilyPondOptionsDialog(TQWidget *parent,
//
TQGroupBox *notationOptionsBox = new TQGroupBox
(1, Qt::Horizontal,
(1, TQt::Horizontal,
i18n("Notation options"), generalFrame);
generalGrid->addWidget(notationOptionsBox, 2, 0);
@ -238,7 +238,7 @@ LilyPondOptionsDialog::LilyPondOptionsDialog(TQWidget *parent,
//
TQGroupBox *advancedLayoutOptionsBox = new TQGroupBox
(1, Qt::Horizontal,
(1, TQt::Horizontal,
i18n("Layout options"), advancedFrame);
advancedGrid->addWidget(advancedLayoutOptionsBox, 0, 0);
@ -261,7 +261,7 @@ LilyPondOptionsDialog::LilyPondOptionsDialog(TQWidget *parent,
layoutAdvancedLayout->addMultiCellWidget(m_lilyRaggedBottom, 1, 2, 0, 1);
TQGroupBox *miscOptionsBox = new TQGroupBox
(1, Qt::Horizontal,
(1, TQt::Horizontal,
i18n("Miscellaneous options"), advancedFrame);
advancedGrid->addWidget(miscOptionsBox, 1, 0);

2
src/gui/dialogs/LilyPondOptionsDialog.h
Unescape View File

@ -42,7 +42,7 @@ class HeadersConfigurationPage;
class LilyPondOptionsDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

6
src/gui/dialogs/LyricEditDialog.cpp
Unescape View File

@ -57,16 +57,16 @@ LyricEditDialog::LyricEditDialog(TQWidget *parent,
TQVBox *vbox = makeVBoxMainWidget();
TQGroupBox *groupBox = new TQGroupBox
(1, Qt::Horizontal, i18n("Lyrics for this segment"), vbox);
(1, TQt::Horizontal, i18n("Lyrics for this segment"), vbox);
TQHBox *hbox = new TQHBox(groupBox);
hbox->setSpacing(5);
// new TQLabel(i18n("Verse:"), hbox);
m_verseNumber = new KComboBox(hbox);
m_verseNumber->setEditable(false);
connect(m_verseNumber, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotVerseNumberChanged(int)));
connect(m_verseNumber, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotVerseNumberChanged(int)));
m_verseAddButton = new TQPushButton(i18n("Add Verse"), hbox);
connect(m_verseAddButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotAddVerse()));
connect(m_verseAddButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotAddVerse()));
TQFrame *f = new TQFrame(hbox);
hbox->setStretchFactor(f, 10);

2
src/gui/dialogs/LyricEditDialog.h
Unescape View File

@ -42,7 +42,7 @@ class Segment;
class LyricEditDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

2
src/gui/dialogs/MakeOrnamentDialog.cpp
Unescape View File

@ -44,7 +44,7 @@ MakeOrnamentDialog::MakeOrnamentDialog(TQWidget *parent, TQString defaultName,
Ok | Cancel, Ok)
{
TQVBox *vbox = makeVBoxMainWidget();
TQGroupBox *nameBox = new TQGroupBox(2, Qt::Vertical, i18n("Name"), vbox);
TQGroupBox *nameBox = new TQGroupBox(2, TQt::Vertical, i18n("Name"), vbox);
new TQLabel(i18n("The name is used to identify both the ornament\nand the triggered segment that stores\nthe ornament's notes."), nameBox);

2
src/gui/dialogs/MakeOrnamentDialog.h
Unescape View File

@ -39,7 +39,7 @@ class PitchChooser;
class MakeOrnamentDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

36
src/gui/dialogs/ManageMetronomeDialog.cpp
Unescape View File

@ -72,7 +72,7 @@ ManageMetronomeDialog::ManageMetronomeDialog(TQWidget *parent,
TQVBox *vbox = new TQVBox(hbox);
TQGroupBox *deviceBox = new TQGroupBox
(1, Qt::Horizontal, i18n("Metronome Instrument"), vbox);
(1, TQt::Horizontal, i18n("Metronome Instrument"), vbox);
TQFrame *frame = new TQFrame(deviceBox);
TQGridLayout *layout = new TQGridLayout(frame, 2, 2, 10, 5);
@ -108,12 +108,12 @@ ManageMetronomeDialog::ManageMetronomeDialog(TQWidget *parent,
layout->addWidget(new TQLabel(i18n("Instrument"), frame), 1, 0);
m_metronomeInstrument = new KComboBox(frame);
connect(m_metronomeInstrument, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotSetModified()));
connect(m_metronomeInstrument, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotInstrumentChanged(int)));
connect(m_metronomeInstrument, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotSetModified()));
connect(m_metronomeInstrument, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotInstrumentChanged(int)));
layout->addWidget(m_metronomeInstrument, 1, 1);
TQGroupBox *beatBox = new TQGroupBox
(1, Qt::Horizontal, i18n("Beats"), vbox);
(1, TQt::Horizontal, i18n("Beats"), vbox);
frame = new TQFrame(beatBox);
layout = new TQGridLayout(frame, 4, 2, 10, 5);
@ -124,58 +124,58 @@ ManageMetronomeDialog::ManageMetronomeDialog(TQWidget *parent,
m_metronomeResolution->insertItem(i18n("Bars only"));
m_metronomeResolution->insertItem(i18n("Bars and beats"));
m_metronomeResolution->insertItem(i18n("Bars, beats, and divisions"));
connect(m_metronomeResolution, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotResolutionChanged(int)));
connect(m_metronomeResolution, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotResolutionChanged(int)));
layout->addWidget(m_metronomeResolution, 0, 1);
layout->addWidget(new TQLabel(i18n("Bar velocity"), frame), 1, 0);
m_metronomeBarVely = new TQSpinBox(frame);
m_metronomeBarVely->setMinValue(0);
m_metronomeBarVely->setMaxValue(127);
connect(m_metronomeBarVely, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(slotSetModified()));
connect(m_metronomeBarVely, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(slotSetModified()));
layout->addWidget(m_metronomeBarVely, 1, 1);
layout->addWidget(new TQLabel(i18n("Beat velocity"), frame), 2, 0);
m_metronomeBeatVely = new TQSpinBox(frame);
m_metronomeBeatVely->setMinValue(0);
m_metronomeBeatVely->setMaxValue(127);
connect(m_metronomeBeatVely, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(slotSetModified()));
connect(m_metronomeBeatVely, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(slotSetModified()));
layout->addWidget(m_metronomeBeatVely, 2, 1);
layout->addWidget(new TQLabel(i18n("Sub-beat velocity"), frame), 3, 0);
m_metronomeSubBeatVely = new TQSpinBox(frame);
m_metronomeSubBeatVely->setMinValue(0);
m_metronomeSubBeatVely->setMaxValue(127);
connect(m_metronomeSubBeatVely, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(slotSetModified()));
connect(m_metronomeSubBeatVely, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(slotSetModified()));
layout->addWidget(m_metronomeSubBeatVely, 3, 1);
vbox = new TQVBox(hbox);
m_metronomePitch = new PitchChooser(i18n("Pitch"), vbox, 60);
connect(m_metronomePitch, TQT_SIGNAL(pitchChanged(int)), this, TQT_SLOT(slotPitchChanged(int)));
connect(m_metronomePitch, TQT_SIGNAL(preview(int)), this, TQT_SLOT(slotPreviewPitch(int)));
connect(m_metronomePitch, TQ_SIGNAL(pitchChanged(int)), this, TQ_SLOT(slotPitchChanged(int)));
connect(m_metronomePitch, TQ_SIGNAL(preview(int)), this, TQ_SLOT(slotPreviewPitch(int)));
m_metronomePitchSelector = new KComboBox(m_metronomePitch);
m_metronomePitchSelector->insertItem(i18n("for Bar"));
m_metronomePitchSelector->insertItem(i18n("for Beat"));
m_metronomePitchSelector->insertItem(i18n("for Sub-beat"));
connect(m_metronomePitchSelector, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotPitchSelectorChanged(int)));
connect(m_metronomePitchSelector, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotPitchSelectorChanged(int)));
TQGroupBox *enableBox = new TQGroupBox
(1, Qt::Horizontal, i18n("Metronome Activated"), vbox);
(1, TQt::Horizontal, i18n("Metronome Activated"), vbox);
m_playEnabled = new TQCheckBox(i18n("Playing"), enableBox);
m_recordEnabled = new TQCheckBox(i18n("Recording"), enableBox);
connect(m_playEnabled, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotSetModified()));
connect(m_recordEnabled, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotSetModified()));
connect(m_playEnabled, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotSetModified()));
connect(m_recordEnabled, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotSetModified()));
// populate the dialog
populate(m_metronomeDevice->currentItem());
// connect up the device list
connect(m_metronomeDevice, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(populate(int)));
connect(m_metronomeDevice, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(populate(int)));
// connect up the device list
connect(m_metronomeDevice, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotSetModified()));
connect(m_metronomeDevice, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotSetModified()));
setModified(false);
}

2
src/gui/dialogs/ManageMetronomeDialog.h
Unescape View File

@ -43,7 +43,7 @@ class InstrumentParameterBox;
class ManageMetronomeDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

2
src/gui/dialogs/MarkerModifyDialog.cpp
Unescape View File

@ -89,7 +89,7 @@ MarkerModifyDialog::initialise(Composition *composition,
m_timeEdit->setValue(time);
*/
TQGroupBox *groupBox = new TQGroupBox
(1, Qt::Horizontal, i18n("Marker Properties"), vbox);
(1, TQt::Horizontal, i18n("Marker Properties"), vbox);
TQFrame *frame = new TQFrame(groupBox);

2
src/gui/dialogs/MarkerModifyDialog.h
Unescape View File

@ -41,7 +41,7 @@ class Composition;
class MarkerModifyDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:
MarkerModifyDialog(TQWidget *parent,

8
src/gui/dialogs/PasteNotationDialog.cpp
Unescape View File

@ -47,7 +47,7 @@ PasteNotationDialog::PasteNotationDialog(TQWidget *parent,
TQVBox *vbox = makeVBoxMainWidget();
TQButtonGroup *pasteTypeGroup = new TQButtonGroup
(1, Qt::Horizontal, i18n("Paste type"), vbox);
(1, TQt::Horizontal, i18n("Paste type"), vbox);
PasteEventsCommand::PasteTypeMap pasteTypes =
PasteEventsCommand::getPasteTypes();
@ -57,14 +57,14 @@ PasteNotationDialog::PasteNotationDialog(TQWidget *parent,
TQRadioButton *button = new TQRadioButton(i->second, pasteTypeGroup);
button->setChecked(m_defaultType == i->first);
TQObject::connect(button, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotPasteTypeChanged()));
TQObject::connect(button, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotPasteTypeChanged()));
m_pasteTypeButtons.push_back(button);
}
TQButtonGroup *setAsDefaultGroup = new TQButtonGroup
(1, Qt::Horizontal, i18n("Options"), vbox);
(1, TQt::Horizontal, i18n("Options"), vbox);
m_setAsDefaultButton = new TQCheckBox
(i18n("Make this the default paste type"), setAsDefaultGroup);

2
src/gui/dialogs/PasteNotationDialog.h
Unescape View File

@ -40,7 +40,7 @@ namespace Rosegarden
class PasteNotationDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

4
src/gui/dialogs/PitchDialog.cpp
Unescape View File

@ -41,8 +41,8 @@ PitchDialog::PitchDialog(TQWidget *parent, TQString title, int defaultPitch) :
m_pitchChooser = new PitchChooser(title, vbox, defaultPitch);
setButtonText(User1, i18n("Reset"));
connect(this, TQT_SIGNAL(user1Clicked()),
m_pitchChooser, TQT_SLOT(slotResetToDefault()));
connect(this, TQ_SIGNAL(user1Clicked()),
m_pitchChooser, TQ_SLOT(slotResetToDefault()));
}
int

2
src/gui/dialogs/PitchDialog.h
Unescape View File

@ -38,7 +38,7 @@ class PitchChooser;
class PitchDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:
PitchDialog(TQWidget *parent, TQString title, int defaultPitch = 60);

2
src/gui/dialogs/PitchPickerDialog.h
Unescape View File

@ -35,7 +35,7 @@ namespace Rosegarden
class PitchPickerDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

2
src/gui/dialogs/QuantizeDialog.h
Unescape View File

@ -38,7 +38,7 @@ class QuantizeParameters;
class QuantizeDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

6
src/gui/dialogs/RescaleDialog.cpp
Unescape View File

@ -56,7 +56,7 @@ RescaleDialog::RescaleDialog(TQWidget *parent,
constrainToCompositionDuration);
if (showCloseGapOption) {
TQGroupBox *optionBox = new TQGroupBox(1, Qt::Horizontal, i18n("Options"), vbox);
TQGroupBox *optionBox = new TQGroupBox(1, TQt::Horizontal, i18n("Options"), vbox);
m_closeGap = new TQCheckBox(i18n("Adjust times of following events accordingly"),
optionBox);
TDEConfig *config = kapp->config();
@ -68,8 +68,8 @@ RescaleDialog::RescaleDialog(TQWidget *parent,
}
setButtonText(User1, i18n("Reset"));
connect(this, TQT_SIGNAL(user1Clicked()),
m_newDuration, TQT_SLOT(slotResetToDefault()));
connect(this, TQ_SIGNAL(user1Clicked()),
m_newDuration, TQ_SLOT(slotResetToDefault()));
}
timeT

2
src/gui/dialogs/RescaleDialog.h
Unescape View File

@ -40,7 +40,7 @@ class Composition;
class RescaleDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

2
src/gui/dialogs/ShowSequencerStatusDialog.h
Unescape View File

@ -36,7 +36,7 @@ namespace Rosegarden
class ShowSequencerStatusDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:
ShowSequencerStatusDialog(TQWidget *parent);

68
src/gui/dialogs/SimpleEventEditDialog.cpp
Unescape View File

@ -70,7 +70,7 @@ SimpleEventEditDialog::SimpleEventEditDialog(TQWidget *parent,
TQVBox *vbox = makeVBoxMainWidget();
TQGroupBox *groupBox = new TQGroupBox
(1, Qt::Horizontal, i18n("Event Properties"), vbox);
(1, TQt::Horizontal, i18n("Event Properties"), vbox);
TQFrame *frame = new TQFrame(groupBox);
@ -101,8 +101,8 @@ SimpleEventEditDialog::SimpleEventEditDialog(TQWidget *parent,
// Connect up the combos
//
connect(m_typeCombo, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotEventTypeChanged(int)));
connect(m_typeCombo, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotEventTypeChanged(int)));
} else {
@ -119,10 +119,10 @@ SimpleEventEditDialog::SimpleEventEditDialog(TQWidget *parent,
layout->addWidget(m_timeSpinBox, 1, 1);
layout->addWidget(m_timeEditButton, 1, 2);
connect(m_timeSpinBox, TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotAbsoluteTimeChanged(int)));
connect(m_timeEditButton, TQT_SIGNAL(released()),
TQT_SLOT(slotEditAbsoluteTime()));
connect(m_timeSpinBox, TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotAbsoluteTimeChanged(int)));
connect(m_timeEditButton, TQ_SIGNAL(released()),
TQ_SLOT(slotEditAbsoluteTime()));
m_durationLabel = new TQLabel(i18n("Duration:"), frame);
layout->addWidget(m_durationLabel, 2, 0);
@ -131,10 +131,10 @@ SimpleEventEditDialog::SimpleEventEditDialog(TQWidget *parent,
layout->addWidget(m_durationSpinBox, 2, 1);
layout->addWidget(m_durationEditButton, 2, 2);
connect(m_durationSpinBox, TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotDurationChanged(int)));
connect(m_durationEditButton, TQT_SIGNAL(released()),
TQT_SLOT(slotEditDuration()));
connect(m_durationSpinBox, TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotDurationChanged(int)));
connect(m_durationEditButton, TQ_SIGNAL(released()),
TQ_SLOT(slotEditDuration()));
m_pitchLabel = new TQLabel(i18n("Pitch:"), frame);
layout->addWidget(m_pitchLabel, 3, 0);
@ -143,10 +143,10 @@ SimpleEventEditDialog::SimpleEventEditDialog(TQWidget *parent,
layout->addWidget(m_pitchSpinBox, 3, 1);
layout->addWidget(m_pitchEditButton, 3, 2);
connect(m_pitchSpinBox, TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotPitchChanged(int)));
connect(m_pitchEditButton, TQT_SIGNAL(released()),
TQT_SLOT(slotEditPitch()));
connect(m_pitchSpinBox, TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotPitchChanged(int)));
connect(m_pitchEditButton, TQ_SIGNAL(released()),
TQ_SLOT(slotEditPitch()));
m_pitchSpinBox->setMinValue(MidiMinValue);
m_pitchSpinBox->setMaxValue(MidiMaxValue);
@ -163,8 +163,8 @@ SimpleEventEditDialog::SimpleEventEditDialog(TQWidget *parent,
m_velocitySpinBox = new TQSpinBox(frame);
layout->addWidget(m_velocitySpinBox, 5, 1);
connect(m_velocitySpinBox, TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotVelocityChanged(int)));
connect(m_velocitySpinBox, TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotVelocityChanged(int)));
m_velocitySpinBox->setMinValue(MidiMinValue);
m_velocitySpinBox->setMaxValue(MidiMaxValue);
@ -179,15 +179,15 @@ SimpleEventEditDialog::SimpleEventEditDialog(TQWidget *parent,
m_sysexSaveButton = new TQPushButton(i18n("Save data"), frame);
layout->addWidget(m_sysexSaveButton, 4, 2);
connect(m_metaEdit, TQT_SIGNAL(textChanged(const TQString &)),
TQT_SLOT(slotMetaChanged(const TQString &)));
connect(m_sysexLoadButton, TQT_SIGNAL(released()),
TQT_SLOT(slotSysexLoad()));
connect(m_sysexSaveButton, TQT_SIGNAL(released()),
TQT_SLOT(slotSysexSave()));
connect(m_metaEdit, TQ_SIGNAL(textChanged(const TQString &)),
TQ_SLOT(slotMetaChanged(const TQString &)));
connect(m_sysexLoadButton, TQ_SIGNAL(released()),
TQ_SLOT(slotSysexLoad()));
connect(m_sysexSaveButton, TQ_SIGNAL(released()),
TQ_SLOT(slotSysexSave()));
m_notationGroupBox = new TQGroupBox
(1, Qt::Horizontal, i18n("Notation Properties"), vbox);
(1, TQt::Horizontal, i18n("Notation Properties"), vbox);
frame = new TQFrame(m_notationGroupBox);
@ -197,8 +197,8 @@ SimpleEventEditDialog::SimpleEventEditDialog(TQWidget *parent,
layout->addMultiCellWidget(m_lockNotationValues, 0, 0, 0, 2);
m_lockNotationValues->setChecked(true);
connect(m_lockNotationValues, TQT_SIGNAL(released()),
TQT_SLOT(slotLockNotationChanged()));
connect(m_lockNotationValues, TQ_SIGNAL(released()),
TQ_SLOT(slotLockNotationChanged()));
m_notationTimeLabel = new TQLabel(i18n("Notation time:"), frame);
layout->addWidget(m_notationTimeLabel, 1, 0);
@ -207,10 +207,10 @@ SimpleEventEditDialog::SimpleEventEditDialog(TQWidget *parent,
layout->addWidget(m_notationTimeSpinBox, 1, 1);
layout->addWidget(m_notationTimeEditButton, 1, 2);
connect(m_notationTimeSpinBox, TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotNotationAbsoluteTimeChanged(int)));
connect(m_notationTimeEditButton, TQT_SIGNAL(released()),
TQT_SLOT(slotEditNotationAbsoluteTime()));
connect(m_notationTimeSpinBox, TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotNotationAbsoluteTimeChanged(int)));
connect(m_notationTimeEditButton, TQ_SIGNAL(released()),
TQ_SLOT(slotEditNotationAbsoluteTime()));
m_notationDurationLabel = new TQLabel(i18n("Notation duration:"), frame);
layout->addWidget(m_notationDurationLabel, 2, 0);
@ -219,10 +219,10 @@ SimpleEventEditDialog::SimpleEventEditDialog(TQWidget *parent,
layout->addWidget(m_notationDurationSpinBox, 2, 1);
layout->addWidget(m_notationDurationEditButton, 2, 2);
connect(m_notationDurationSpinBox, TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotNotationDurationChanged(int)));
connect(m_notationDurationEditButton, TQT_SIGNAL(released()),
TQT_SLOT(slotEditNotationDuration()));
connect(m_notationDurationSpinBox, TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotNotationDurationChanged(int)));
connect(m_notationDurationEditButton, TQ_SIGNAL(released()),
TQ_SLOT(slotEditNotationDuration()));
setupForEvent();
}

2
src/gui/dialogs/SimpleEventEditDialog.h
Unescape View File

@ -47,7 +47,7 @@ class RosegardenGUIDoc;
class SimpleEventEditDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:
SimpleEventEditDialog(TQWidget *parent,

2
src/gui/dialogs/SplitByPitchDialog.h
Unescape View File

@ -39,7 +39,7 @@ class PitchChooser;
class SplitByPitchDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:
SplitByPitchDialog(TQWidget *parent);

2
src/gui/dialogs/SplitByRecordingSrcDialog.cpp
Unescape View File

@ -48,7 +48,7 @@ SplitByRecordingSrcDialog::SplitByRecordingSrcDialog(TQWidget *parent, Rosegarde
TQVBox *vBox = makeVBoxMainWidget();
TQGroupBox *groupBox = new TQGroupBox
(1, Qt::Horizontal, i18n("Recording Source"), vBox);
(1, TQt::Horizontal, i18n("Recording Source"), vBox);
TQFrame *frame = new TQFrame(groupBox);
TQGridLayout *layout = new TQGridLayout(frame, 2, 2, 10, 5);

2
src/gui/dialogs/SplitByRecordingSrcDialog.h
Unescape View File

@ -40,7 +40,7 @@ class RosegardenGUIDoc;
class SplitByRecordingSrcDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:
SplitByRecordingSrcDialog(TQWidget *parent, RosegardenGUIDoc *doc);

46
src/gui/dialogs/TempoDialog.cpp
Unescape View File

@ -58,7 +58,7 @@ TempoDialog::TempoDialog(TQWidget *parent, RosegardenGUIDoc *doc,
setHelp("tempo");
TQVBox *vbox = makeVBoxMainWidget();
TQGroupBox *groupBox = new TQGroupBox(1, Qt::Horizontal, i18n("Tempo"), vbox);
TQGroupBox *groupBox = new TQGroupBox(1, TQt::Horizontal, i18n("Tempo"), vbox);
TQFrame *frame = new TQFrame(groupBox);
TQGridLayout *layout = new TQGridLayout(frame, 4, 3, 5, 5);
@ -68,12 +68,12 @@ TempoDialog::TempoDialog(TQWidget *parent, RosegardenGUIDoc *doc,
m_tempoValueSpinBox = new HSpinBox(frame, 0, 100000, 0.0, 1000.0, 5);
layout->addWidget(m_tempoValueSpinBox, 0, 2);
connect(m_tempoValueSpinBox, TQT_SIGNAL(valueChanged(const TQString &)),
TQT_SLOT(slotTempoChanged(const TQString &)));
connect(m_tempoValueSpinBox, TQ_SIGNAL(valueChanged(const TQString &)),
TQ_SLOT(slotTempoChanged(const TQString &)));
m_tempoTap= new TQPushButton(i18n("Tap"), frame);
layout->addWidget(m_tempoTap, 0, 3);
connect(m_tempoTap, TQT_SIGNAL(clicked()), TQT_SLOT(slotTapClicked()));
connect(m_tempoTap, TQ_SIGNAL(clicked()), TQ_SLOT(slotTapClicked()));
m_tempoConstant = new TQRadioButton(i18n("Tempo is fixed until the following tempo change"), frame);
@ -91,16 +91,16 @@ TempoDialog::TempoDialog(TQWidget *parent, RosegardenGUIDoc *doc,
layout->addWidget(m_tempoRampToTarget, 3, 1);
layout->addWidget(m_tempoTargetSpinBox, 3, 2);
// connect(m_tempoTargetCheckBox, TQT_SIGNAL(clicked()),
// TQT_SLOT(slotTargetCheckBoxClicked()));
connect(m_tempoConstant, TQT_SIGNAL(clicked()),
TQT_SLOT(slotTempoConstantClicked()));
connect(m_tempoRampToNext, TQT_SIGNAL(clicked()),
TQT_SLOT(slotTempoRampToNextClicked()));
connect(m_tempoRampToTarget, TQT_SIGNAL(clicked()),
TQT_SLOT(slotTempoRampToTargetClicked()));
connect(m_tempoTargetSpinBox, TQT_SIGNAL(valueChanged(const TQString &)),
TQT_SLOT(slotTargetChanged(const TQString &)));
// connect(m_tempoTargetCheckBox, TQ_SIGNAL(clicked()),
// TQ_SLOT(slotTargetCheckBoxClicked()));
connect(m_tempoConstant, TQ_SIGNAL(clicked()),
TQ_SLOT(slotTempoConstantClicked()));
connect(m_tempoRampToNext, TQ_SIGNAL(clicked()),
TQ_SLOT(slotTempoRampToNextClicked()));
connect(m_tempoRampToTarget, TQ_SIGNAL(clicked()),
TQ_SLOT(slotTempoRampToTargetClicked()));
connect(m_tempoTargetSpinBox, TQ_SIGNAL(valueChanged(const TQString &)),
TQ_SLOT(slotTargetChanged(const TQString &)));
m_tempoBeatLabel = new TQLabel(frame);
layout->addWidget(m_tempoBeatLabel, 0, 4);
@ -122,7 +122,7 @@ TempoDialog::TempoDialog(TQWidget *parent, RosegardenGUIDoc *doc,
}
// Scope Box
TQButtonGroup *scopeGroup = new TQButtonGroup(1, Qt::Horizontal,
TQButtonGroup *scopeGroup = new TQButtonGroup(1, TQt::Horizontal,
i18n("Scope"), vbox);
// new TQLabel(scopeBox);
@ -173,14 +173,14 @@ TempoDialog::TempoDialog(TQWidget *parent, RosegardenGUIDoc *doc,
// new TQLabel(scopeBox);
connect(m_tempoChangeHere, TQT_SIGNAL(clicked()),
TQT_SLOT(slotActionChanged()));
connect(m_tempoChangeBefore, TQT_SIGNAL(clicked()),
TQT_SLOT(slotActionChanged()));
connect(m_tempoChangeStartOfBar, TQT_SIGNAL(clicked()),
TQT_SLOT(slotActionChanged()));
connect(m_tempoChangeGlobal, TQT_SIGNAL(clicked()),
TQT_SLOT(slotActionChanged()));
connect(m_tempoChangeHere, TQ_SIGNAL(clicked()),
TQ_SLOT(slotActionChanged()));
connect(m_tempoChangeBefore, TQ_SIGNAL(clicked()),
TQ_SLOT(slotActionChanged()));
connect(m_tempoChangeStartOfBar, TQ_SIGNAL(clicked()),
TQ_SLOT(slotActionChanged()));
connect(m_tempoChangeGlobal, TQ_SIGNAL(clicked()),
TQ_SLOT(slotActionChanged()));
m_tempoChangeHere->setChecked(true);

2
src/gui/dialogs/TempoDialog.h
Unescape View File

@ -47,7 +47,7 @@ class HSpinBox;
class TempoDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:
enum TempoDialogAction {

40
src/gui/dialogs/TextEventDialog.cpp
Unescape View File

@ -61,11 +61,11 @@ TextEventDialog::TextEventDialog(TQWidget *parent,
TQVBox *vbox = makeVBoxMainWidget();
TQGroupBox *entryBox = new TQGroupBox
(1, Qt::Horizontal, i18n("Specification"), vbox);
(1, TQt::Horizontal, i18n("Specification"), vbox);
TQGroupBox *exampleBox = new TQGroupBox
(1, Qt::Horizontal, i18n("Preview"), vbox);
(1, TQt::Horizontal, i18n("Preview"), vbox);
TQGrid *entryGrid = new TQGrid(2, Qt::Horizontal, entryBox);
TQGrid *entryGrid = new TQGrid(2, TQt::Horizontal, entryBox);
new TQLabel(i18n("Text: "), entryGrid);
m_text = new TQLineEdit(entryGrid);
@ -327,23 +327,23 @@ TextEventDialog::TextEventDialog(TQWidget *parent,
m_prevLyric = config->readEntry("previous_lyric", "");
m_prevAnnotation = config->readEntry("previous_annotation", "");
TQObject::connect(m_text, TQT_SIGNAL(textChanged(const TQString &)),
this, TQT_SLOT(slotTextChanged(const TQString &)));
TQObject::connect(m_typeCombo, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotTypeChanged(const TQString &)));
TQObject::connect(this, TQT_SIGNAL(okClicked()), this, TQT_SLOT(slotOK()));
TQObject::connect(m_dynamicShortcutCombo, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotDynamicShortcutChanged(const TQString &)));
TQObject::connect(m_directionShortcutCombo, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotDirectionShortcutChanged(const TQString &)));
TQObject::connect(m_localDirectionShortcutCombo, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotLocalDirectionShortcutChanged(const TQString &)));
TQObject::connect(m_tempoShortcutCombo, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotTempoShortcutChanged(const TQString &)));
TQObject::connect(m_localTempoShortcutCombo, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotLocalTempoShortcutChanged(const TQString &)));
TQObject::connect(m_lilyPondDirectiveCombo, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotLilyPondDirectiveChanged(const TQString &)));
TQObject::connect(m_text, TQ_SIGNAL(textChanged(const TQString &)),
this, TQ_SLOT(slotTextChanged(const TQString &)));
TQObject::connect(m_typeCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotTypeChanged(const TQString &)));
TQObject::connect(this, TQ_SIGNAL(okClicked()), this, TQ_SLOT(slotOK()));
TQObject::connect(m_dynamicShortcutCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotDynamicShortcutChanged(const TQString &)));
TQObject::connect(m_directionShortcutCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotDirectionShortcutChanged(const TQString &)));
TQObject::connect(m_localDirectionShortcutCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotLocalDirectionShortcutChanged(const TQString &)));
TQObject::connect(m_tempoShortcutCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotTempoShortcutChanged(const TQString &)));
TQObject::connect(m_localTempoShortcutCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotLocalTempoShortcutChanged(const TQString &)));
TQObject::connect(m_lilyPondDirectiveCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotLilyPondDirectiveChanged(const TQString &)));
m_text->setFocus();
slotTypeChanged(strtoqstr(getTextType()));

2
src/gui/dialogs/TextEventDialog.h
Unescape View File

@ -44,7 +44,7 @@ class NotePixmapFactory;
class TextEventDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

8
src/gui/dialogs/TimeDialog.cpp
Unescape View File

@ -47,8 +47,8 @@ TimeDialog::TimeDialog(TQWidget *parent, TQString title,
constrainToCompositionDuration);
setButtonText(User1, i18n("Reset"));
connect(this, TQT_SIGNAL(user1Clicked()),
m_timeWidget, TQT_SLOT(slotResetToDefault()));
connect(this, TQ_SIGNAL(user1Clicked()),
m_timeWidget, TQ_SLOT(slotResetToDefault()));
}
TimeDialog::TimeDialog(TQWidget *parent, TQString title,
@ -64,8 +64,8 @@ TimeDialog::TimeDialog(TQWidget *parent, TQString title,
constrainToCompositionDuration);
setButtonText(User1, i18n("Reset"));
connect(this, TQT_SIGNAL(user1Clicked()),
m_timeWidget, TQT_SLOT(slotResetToDefault()));
connect(this, TQ_SIGNAL(user1Clicked()),
m_timeWidget, TQ_SLOT(slotResetToDefault()));
}
timeT

2
src/gui/dialogs/TimeDialog.h
Unescape View File

@ -40,7 +40,7 @@ class Composition;
class TimeDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:
/// for absolute times

26
src/gui/dialogs/TimeSignatureDialog.cpp
Unescape View File

@ -77,7 +77,7 @@ TimeSignatureDialog::TimeSignatureDialog(TQWidget *parent,
TQVBox *vbox = makeVBoxMainWidget();
TQGroupBox *groupBox = new TQGroupBox
(1, Qt::Horizontal, i18n("Time signature"), vbox);
(1, TQt::Horizontal, i18n("Time signature"), vbox);
TQHBox *numBox = new TQHBox(groupBox);
TQHBox *denomBox = new TQHBox(groupBox);
@ -86,8 +86,8 @@ TimeSignatureDialog::TimeSignatureDialog(TQWidget *parent,
explanatoryLabel = new TQLabel(explanatoryText, groupBox);
}
BigArrowButton *numDown = new BigArrowButton(numBox, Qt::LeftArrow);
BigArrowButton *denomDown = new BigArrowButton(denomBox, Qt::LeftArrow);
BigArrowButton *numDown = new BigArrowButton(numBox, TQt::LeftArrow);
BigArrowButton *denomDown = new BigArrowButton(denomBox, TQt::LeftArrow);
m_numLabel = new TQLabel
(TQString("%1").arg(m_timeSignature.getNumerator()), numBox);
@ -100,13 +100,13 @@ TimeSignatureDialog::TimeSignatureDialog(TQWidget *parent,
m_numLabel->setFont(*timeSigFont);
m_denomLabel->setFont(*timeSigFont);
BigArrowButton *numUp = new BigArrowButton(numBox, Qt::RightArrow);
BigArrowButton *denomUp = new BigArrowButton(denomBox, Qt::RightArrow);
BigArrowButton *numUp = new BigArrowButton(numBox, TQt::RightArrow);
BigArrowButton *denomUp = new BigArrowButton(denomBox, TQt::RightArrow);
TQObject::connect(numDown, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotNumDown()));
TQObject::connect(numUp, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotNumUp()));
TQObject::connect(denomDown, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotDenomDown()));
TQObject::connect(denomUp, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotDenomUp()));
TQObject::connect(numDown, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotNumDown()));
TQObject::connect(numUp, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotNumUp()));
TQObject::connect(denomDown, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotDenomDown()));
TQObject::connect(denomUp, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotDenomUp()));
if (timeEditable) {
@ -124,7 +124,7 @@ TimeSignatureDialog::TimeSignatureDialog(TQWidget *parent,
m_timeEditor = 0;
groupBox = new TQButtonGroup(1, Qt::Horizontal, i18n("Scope"), vbox);
groupBox = new TQButtonGroup(1, TQt::Horizontal, i18n("Scope"), vbox);
int barNo = composition->getBarNumber(m_time);
bool atStartOfBar = (m_time == composition->getBarStart(barNo));
@ -166,7 +166,7 @@ TimeSignatureDialog::TimeSignatureDialog(TQWidget *parent,
}
}
groupBox = new TQGroupBox(1, Qt::Horizontal, i18n("Options"), vbox);
groupBox = new TQGroupBox(1, TQt::Horizontal, i18n("Options"), vbox);
TDEConfig *config = kapp->config();
config->setGroup(GeneralOptionsConfigGroup);
@ -190,8 +190,8 @@ TimeSignatureDialog::TimeSignatureDialog(TQWidget *parent,
m_normalizeRestsButton->setChecked
(config->readBoolEntry("timesigdialognormalize", true));
TQObject::connect(m_hideSignatureButton, TQT_SIGNAL(clicked()), this,
TQT_SLOT(slotUpdateCommonTimeButton()));
TQObject::connect(m_hideSignatureButton, TQ_SIGNAL(clicked()), this,
TQ_SLOT(slotUpdateCommonTimeButton()));
slotUpdateCommonTimeButton();
m_explanatoryLabel = explanatoryLabel;

2
src/gui/dialogs/TimeSignatureDialog.h
Unescape View File

@ -44,7 +44,7 @@ class Composition;
class TimeSignatureDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

110
src/gui/dialogs/TransportDialog.cpp
Unescape View File

@ -140,41 +140,41 @@ TransportDialog::TransportDialog(TQWidget *parent,
m_midiOutTimer = new TQTimer(this);
m_clearMetronomeTimer = new TQTimer(this);
connect(m_midiInTimer, TQT_SIGNAL(timeout()),
TQT_SLOT(slotClearMidiInLabel()));
connect(m_midiInTimer, TQ_SIGNAL(timeout()),
TQ_SLOT(slotClearMidiInLabel()));
connect(m_midiOutTimer, TQT_SIGNAL(timeout()),
TQT_SLOT(slotClearMidiOutLabel()));
connect(m_midiOutTimer, TQ_SIGNAL(timeout()),
TQ_SLOT(slotClearMidiOutLabel()));
connect(m_clearMetronomeTimer, TQT_SIGNAL(timeout()),
TQT_SLOT(slotResetBackground()));
connect(m_clearMetronomeTimer, TQ_SIGNAL(timeout()),
TQ_SLOT(slotResetBackground()));
m_transport->TimeDisplayLabel->hide();
m_transport->ToEndLabel->hide();
connect(m_transport->TimeDisplayButton, TQT_SIGNAL(clicked()),
TQT_SLOT(slotChangeTimeDisplay()));
connect(m_transport->TimeDisplayButton, TQ_SIGNAL(clicked()),
TQ_SLOT(slotChangeTimeDisplay()));
connect(m_transport->ToEndButton, TQT_SIGNAL(clicked()),
TQT_SLOT(slotChangeToEnd()));
connect(m_transport->ToEndButton, TQ_SIGNAL(clicked()),
TQ_SLOT(slotChangeToEnd()));
connect(m_transport->LoopButton, TQT_SIGNAL(clicked()),
TQT_SLOT(slotLoopButtonClicked()));
connect(m_transport->LoopButton, TQ_SIGNAL(clicked()),
TQ_SLOT(slotLoopButtonClicked()));
connect(m_transport->PanelOpenButton, TQT_SIGNAL(clicked()),
TQT_SLOT(slotPanelOpenButtonClicked()));
connect(m_transport->PanelOpenButton, TQ_SIGNAL(clicked()),
TQ_SLOT(slotPanelOpenButtonClicked()));
connect(m_transport->PanelCloseButton, TQT_SIGNAL(clicked()),
TQT_SLOT(slotPanelCloseButtonClicked()));
connect(m_transport->PanelCloseButton, TQ_SIGNAL(clicked()),
TQ_SLOT(slotPanelCloseButtonClicked()));
connect(m_transport->PanicButton, TQT_SIGNAL(clicked()), TQT_SIGNAL(panic()));
connect(m_transport->PanicButton, TQ_SIGNAL(clicked()), TQ_SIGNAL(panic()));
m_panelOpen = *m_transport->PanelOpenButton->pixmap();
m_panelClosed = *m_transport->PanelCloseButton->pixmap();
connect(m_transport->SetStartLPButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotSetStartLoopingPointAtMarkerPos()));
connect(m_transport->SetStopLPButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotSetStopLoopingPointAtMarkerPos()));
connect(m_transport->SetStartLPButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotSetStartLoopingPointAtMarkerPos()));
connect(m_transport->SetStopLPButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotSetStopLoopingPointAtMarkerPos()));
// clear labels
//
@ -216,46 +216,46 @@ TransportDialog::TransportDialog(TQWidget *parent,
m_transport->TempoDisplay->setFont( localFont );
m_transport->TimeSigDisplay->setFont( localFont );
connect(m_transport->TempoDisplay, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTempo()));
connect(m_transport->TempoDisplay, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTempo()));
connect(m_transport->TempoDisplay, TQT_SIGNAL(scrollWheel(int)),
this, TQT_SIGNAL(scrollTempo(int)));
connect(m_transport->TempoDisplay, TQ_SIGNAL(scrollWheel(int)),
this, TQ_SIGNAL(scrollTempo(int)));
connect(m_transport->TimeSigDisplay, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTimeSignature()));
connect(m_transport->TimeSigDisplay, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTimeSignature()));
// toil through the individual pixmaps
connect(m_transport->NegativePixmap, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime()));
connect(m_transport->TenHoursPixmap, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime()));
connect(m_transport->UnitHoursPixmap, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime()));
connect(m_transport->HourColonPixmap, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime()));
connect(m_transport->TenMinutesPixmap, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime()));
connect(m_transport->UnitMinutesPixmap, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime()));
connect(m_transport->MinuteColonPixmap, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime()));
connect(m_transport->TenSecondsPixmap, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime()));
connect(m_transport->UnitSecondsPixmap, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime()));
connect(m_transport->SecondColonPixmap, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime()));
connect(m_transport->TenthsPixmap, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime()));
connect(m_transport->HundredthsPixmap, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime()));
connect(m_transport->HundredthColonPixmap, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime()));
connect(m_transport->TenThousandthsPixmap, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime()));
connect(m_transport->ThousandthsPixmap, TQT_SIGNAL(doubleClicked()),
this, TQT_SLOT(slotEditTime()));
connect(m_transport->NegativePixmap, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTime()));
connect(m_transport->TenHoursPixmap, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTime()));
connect(m_transport->UnitHoursPixmap, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTime()));
connect(m_transport->HourColonPixmap, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTime()));
connect(m_transport->TenMinutesPixmap, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTime()));
connect(m_transport->UnitMinutesPixmap, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTime()));
connect(m_transport->MinuteColonPixmap, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTime()));
connect(m_transport->TenSecondsPixmap, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTime()));
connect(m_transport->UnitSecondsPixmap, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTime()));
connect(m_transport->SecondColonPixmap, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTime()));
connect(m_transport->TenthsPixmap, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTime()));
connect(m_transport->HundredthsPixmap, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTime()));
connect(m_transport->HundredthColonPixmap, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTime()));
connect(m_transport->TenThousandthsPixmap, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTime()));
connect(m_transport->ThousandthsPixmap, TQ_SIGNAL(doubleClicked()),
this, TQ_SLOT(slotEditTime()));
// accelerator object
//

2
src/gui/dialogs/TransportDialog.h
Unescape View File

@ -48,7 +48,7 @@ class MappedEvent;
class TransportDialog : public TQWidget
{
Q_OBJECT
TQ_OBJECT
public:
TransportDialog(TQWidget *parent=0,

2
src/gui/dialogs/TriggerSegmentDialog.h
Unescape View File

@ -41,7 +41,7 @@ class Composition;
class TriggerSegmentDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

28
src/gui/dialogs/TupletDialog.cpp
Unescape View File

@ -53,7 +53,7 @@ TupletDialog::TupletDialog(TQWidget *parent, Note::Type defaultUnitType,
TQVBox *vbox = makeVBoxMainWidget();
TQGroupBox *timingBox = new TQGroupBox
(1, Qt::Horizontal, i18n("New timing for tuplet group"), vbox);
(1, TQt::Horizontal, i18n("New timing for tuplet group"), vbox);
if (m_maxDuration > 0) {
@ -103,15 +103,15 @@ TupletDialog::TupletDialog(TQWidget *parent, Note::Type defaultUnitType,
m_hasTimingAlready->setChecked(false);
timingLayout->addMultiCellWidget(m_hasTimingAlready, 2, 2, 0, 2);
connect(m_hasTimingAlready, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotHasTimingChanged()));
connect(m_hasTimingAlready, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotHasTimingChanged()));
updateUntupledCombo();
updateTupledCombo();
m_timingDisplayBox = new TQGroupBox
(1, Qt::Horizontal, i18n("Timing calculations"), vbox);
(1, TQt::Horizontal, i18n("Timing calculations"), vbox);
TQGrid *timingDisplayGrid = new TQGrid(3, Qt::Horizontal, m_timingDisplayBox);
TQGrid *timingDisplayGrid = new TQGrid(3, TQt::Horizontal, m_timingDisplayBox);
if (maxDuration > 0) {
@ -157,18 +157,18 @@ TupletDialog::TupletDialog(TQWidget *parent, Note::Type defaultUnitType,
updateTimingDisplays();
TQObject::connect(m_unitCombo, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotUnitChanged(const TQString &)));
TQObject::connect(m_unitCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotUnitChanged(const TQString &)));
TQObject::connect(m_untupledCombo, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotUntupledChanged(const TQString &)));
TQObject::connect(m_untupledCombo, TQT_SIGNAL(textChanged(const TQString &)),
this, TQT_SLOT(slotUntupledChanged(const TQString &)));
TQObject::connect(m_untupledCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotUntupledChanged(const TQString &)));
TQObject::connect(m_untupledCombo, TQ_SIGNAL(textChanged(const TQString &)),
this, TQ_SLOT(slotUntupledChanged(const TQString &)));
TQObject::connect(m_tupledCombo, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotTupledChanged(const TQString &)));
TQObject::connect(m_tupledCombo, TQT_SIGNAL(textChanged(const TQString &)),
this, TQT_SLOT(slotTupledChanged(const TQString &)));
TQObject::connect(m_tupledCombo, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotTupledChanged(const TQString &)));
TQObject::connect(m_tupledCombo, TQ_SIGNAL(textChanged(const TQString &)),
this, TQ_SLOT(slotTupledChanged(const TQString &)));
}
void

2
src/gui/dialogs/TupletDialog.h
Unescape View File

@ -43,7 +43,7 @@ namespace Rosegarden
class TupletDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

6
src/gui/dialogs/UseOrnamentDialog.cpp
Unescape View File

@ -58,7 +58,7 @@ UseOrnamentDialog::UseOrnamentDialog(TQWidget *parent,
TQVBox *vbox = makeVBoxMainWidget();
TQLabel *label;
TQGroupBox *notationBox = new TQGroupBox(1, Qt::Horizontal, i18n("Notation"), vbox);
TQGroupBox *notationBox = new TQGroupBox(1, TQt::Horizontal, i18n("Notation"), vbox);
TQFrame *frame = new TQFrame(notationBox);
TQGridLayout *layout = new TQGridLayout(frame, 4, 1, 5, 5);
@ -91,7 +91,7 @@ UseOrnamentDialog::UseOrnamentDialog(TQWidget *parent,
}
m_mark->insertItem(i18n("Text mark"));
connect(m_mark, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotMarkChanged(int)));
connect(m_mark, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotMarkChanged(int)));
m_textLabel = new TQLabel(i18n(" Text: "), frame);
layout->addWidget(m_textLabel, 0, 2);
@ -99,7 +99,7 @@ UseOrnamentDialog::UseOrnamentDialog(TQWidget *parent,
m_text = new TQLineEdit(frame);
layout->addWidget(m_text, 0, 3);
TQGroupBox *performBox = new TQGroupBox(1, Qt::Horizontal, i18n("Performance"), vbox);
TQGroupBox *performBox = new TQGroupBox(1, TQt::Horizontal, i18n("Performance"), vbox);
frame = new TQFrame(performBox);
layout = new TQGridLayout(frame, 3, 2, 5, 5);

2
src/gui/dialogs/UseOrnamentDialog.h
Unescape View File

@ -45,7 +45,7 @@ class Composition;
class UseOrnamentDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

70
src/gui/editors/eventlist/EventView.cpp
Unescape View File

@ -124,7 +124,7 @@ EventView::EventView(RosegardenGUIDoc *doc,
// define some note filtering buttons in a group
//
m_filterGroup =
new TQButtonGroup(1, Qt::Horizontal, i18n("Event filters"), getCentralWidget());
new TQButtonGroup(1, TQt::Horizontal, i18n("Event filters"), getCentralWidget());
m_noteCheckBox = new TQCheckBox(i18n("Note"), m_filterGroup);
m_programCheckBox = new TQCheckBox(i18n("Program Change"), m_filterGroup);
@ -141,8 +141,8 @@ EventView::EventView(RosegardenGUIDoc *doc,
// Connect up
//
connect(m_filterGroup, TQT_SIGNAL(released(int)),
TQT_SLOT(slotModifyFilter(int)));
connect(m_filterGroup, TQ_SIGNAL(released(int)),
TQ_SLOT(slotModifyFilter(int)));
m_eventList = new TDEListView(getCentralWidget());
m_eventList->setItemsRenameable(true);
@ -156,7 +156,7 @@ EventView::EventView(RosegardenGUIDoc *doc,
segments[0]->getComposition()->getTriggerSegmentRec(id);
TQGroupBox *groupBox = new TQGroupBox
(1, Qt::Horizontal, i18n("Triggered Segment Properties"), getCentralWidget());
(1, TQt::Horizontal, i18n("Triggered Segment Properties"), getCentralWidget());
TQFrame *frame = new TQFrame(groupBox);
TQGridLayout *layout = new TQGridLayout(frame, 5, 3, 5, 5);
@ -169,21 +169,21 @@ EventView::EventView(RosegardenGUIDoc *doc,
layout->addWidget(m_triggerName, 0, 1);
TQPushButton *editButton = new TQPushButton(i18n("edit"), frame);
layout->addWidget(editButton, 0, 2);
connect(editButton, TQT_SIGNAL(clicked()), TQT_TQOBJECT(this), TQT_SLOT(slotEditTriggerName()));
connect(editButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotEditTriggerName()));
layout->addWidget(new TQLabel(i18n("Base pitch: "), frame), 1, 0);
m_triggerPitch = new TQLabel(TQString("%1").arg(rec->getBasePitch()), frame);
layout->addWidget(m_triggerPitch, 1, 1);
editButton = new TQPushButton(i18n("edit"), frame);
layout->addWidget(editButton, 1, 2);
connect(editButton, TQT_SIGNAL(clicked()), TQT_TQOBJECT(this), TQT_SLOT(slotEditTriggerPitch()));
connect(editButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotEditTriggerPitch()));
layout->addWidget(new TQLabel(i18n("Base velocity: "), frame), 2, 0);
m_triggerVelocity = new TQLabel(TQString("%1").arg(rec->getBaseVelocity()), frame);
layout->addWidget(m_triggerVelocity, 2, 1);
editButton = new TQPushButton(i18n("edit"), frame);
layout->addWidget(editButton, 2, 2);
connect(editButton, TQT_SIGNAL(clicked()), TQT_TQOBJECT(this), TQT_SLOT(slotEditTriggerVelocity()));
connect(editButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotEditTriggerVelocity()));
/*!!! Comment out these two options, which are not yet used
anywhere else -- intended for use with library ornaments, not
@ -209,11 +209,11 @@ EventView::EventView(RosegardenGUIDoc *doc,
adjust->setCurrentItem(2);
}
connect(adjust, TQT_SIGNAL(activated(int)), TQT_TQOBJECT(this), TQT_SLOT(slotTriggerTimeAdjustChanged(int)));
connect(adjust, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotTriggerTimeAdjustChanged(int)));
TQCheckBox *retune = new TQCheckBox(i18n("Adjust pitch to trigger note by default"), frame);
retune->setChecked(rec->getDefaultRetune());
connect(retune, TQT_SIGNAL(clicked()), TQT_TQOBJECT(this), TQT_SLOT(slotTriggerRetuneChanged()));
connect(retune, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotTriggerRetuneChanged()));
layout->addMultiCellWidget(retune, 4, 4, 1, 2);
*/
@ -230,12 +230,12 @@ EventView::EventView(RosegardenGUIDoc *doc,
// Connect double clicker
//
connect(m_eventList, TQT_SIGNAL(doubleClicked(TQListViewItem*)),
TQT_SLOT(slotPopupEventEditor(TQListViewItem*)));
connect(m_eventList, TQ_SIGNAL(doubleClicked(TQListViewItem*)),
TQ_SLOT(slotPopupEventEditor(TQListViewItem*)));
connect(m_eventList,
TQT_SIGNAL(rightButtonPressed(TQListViewItem*, const TQPoint&, int)),
TQT_SLOT(slotPopupMenu(TQListViewItem*, const TQPoint&, int)));
TQ_SIGNAL(rightButtonPressed(TQListViewItem*, const TQPoint&, int)),
TQ_SLOT(slotPopupMenu(TQListViewItem*, const TQPoint&, int)));
m_eventList->setAllColumnsShowFocus(true);
m_eventList->setSelectionMode(TQListView::Extended);
@ -1118,42 +1118,42 @@ EventView::setupActions()
TQString pixmapDir = TDEGlobal::dirs()->findResource("appdata", "pixmaps/");
TQIconSet icon(TQPixmap(pixmapDir + "/toolbar/event-insert.png"));
new TDEAction(i18n("&Insert Event"), icon, Key_I, TQT_TQOBJECT(this),
TQT_SLOT(slotEditInsert()), actionCollection(),
new TDEAction(i18n("&Insert Event"), icon, Key_I, this,
TQ_SLOT(slotEditInsert()), actionCollection(),
"insert");
TQCanvasPixmap pixmap(pixmapDir + "/toolbar/event-delete.png");
icon = TQIconSet(pixmap);
new TDEAction(i18n("&Delete Event"), icon, Key_Delete, TQT_TQOBJECT(this),
TQT_SLOT(slotEditDelete()), actionCollection(),
new TDEAction(i18n("&Delete Event"), icon, Key_Delete, this,
TQ_SLOT(slotEditDelete()), actionCollection(),
"delete");
pixmap.load(pixmapDir + "/toolbar/event-edit.png");
icon = TQIconSet(pixmap);
new TDEAction(i18n("&Edit Event"), icon, Key_E, TQT_TQOBJECT(this),
TQT_SLOT(slotEditEvent()), actionCollection(),
new TDEAction(i18n("&Edit Event"), icon, Key_E, this,
TQ_SLOT(slotEditEvent()), actionCollection(),
"edit_simple");
pixmap.load(pixmapDir + "/toolbar/event-edit-advanced.png");
icon = TQIconSet(pixmap);
new TDEAction(i18n("&Advanced Event Editor"), icon, Key_A, TQT_TQOBJECT(this),
TQT_SLOT(slotEditEventAdvanced()), actionCollection(),
new TDEAction(i18n("&Advanced Event Editor"), icon, Key_A, this,
TQ_SLOT(slotEditEventAdvanced()), actionCollection(),
"edit_advanced");
// icon = TQIconSet(TQCanvasPixmap(pixmapDir + "/toolbar/eventfilter.xpm"));
new TDEAction(i18n("&Filter Selection"), "filter", Key_F, TQT_TQOBJECT(this),
TQT_SLOT(slotFilterSelection()), actionCollection(),
new TDEAction(i18n("&Filter Selection"), "filter", Key_F, this,
TQ_SLOT(slotFilterSelection()), actionCollection(),
"filter_selection");
new TDEAction(i18n("Select &All"), Key_A + CTRL, TQT_TQOBJECT(this),
TQT_SLOT(slotSelectAll()), actionCollection(),
new TDEAction(i18n("Select &All"), Key_A + CTRL, this,
TQ_SLOT(slotSelectAll()), actionCollection(),
"select_all");
new TDEAction(i18n("Clear Selection"), Key_Escape, TQT_TQOBJECT(this),
TQT_SLOT(slotClearSelection()), actionCollection(),
new TDEAction(i18n("Clear Selection"), Key_Escape, this,
TQ_SLOT(slotClearSelection()), actionCollection(),
"clear_selection");
m_config->setGroup(EventViewConfigGroup);
@ -1164,8 +1164,8 @@ EventView::setupActions()
pixmap.load(pixmapDir + "/toolbar/time-musical.png");
icon = TQIconSet(pixmap);
action = new TDERadioAction(i18n("&Musical Times"), icon, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotMusicalTime()),
action = new TDERadioAction(i18n("&Musical Times"), icon, 0, this,
TQ_SLOT(slotMusicalTime()),
actionCollection(), "time_musical");
action->setExclusiveGroup("timeMode");
if (timeMode == 0)
@ -1174,8 +1174,8 @@ EventView::setupActions()
pixmap.load(pixmapDir + "/toolbar/time-real.png");
icon = TQIconSet(pixmap);
action = new TDERadioAction(i18n("&Real Times"), icon, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotRealTime()),
action = new TDERadioAction(i18n("&Real Times"), icon, 0, this,
TQ_SLOT(slotRealTime()),
actionCollection(), "time_real");
action->setExclusiveGroup("timeMode");
if (timeMode == 1)
@ -1184,8 +1184,8 @@ EventView::setupActions()
pixmap.load(pixmapDir + "/toolbar/time-raw.png");
icon = TQIconSet(pixmap);
action = new TDERadioAction(i18n("Ra&w Times"), icon, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotRawTime()),
action = new TDERadioAction(i18n("Ra&w Times"), icon, 0, this,
TQ_SLOT(slotRawTime()),
actionCollection(), "time_raw");
action->setExclusiveGroup("timeMode");
if (timeMode == 2)
@ -1516,8 +1516,8 @@ EventView::createMenu()
m_menu->insertItem(i18n("Open in Event Editor"), 0);
m_menu->insertItem(i18n("Open in Expert Event Editor"), 1);
connect(m_menu, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotMenuActivated(int)));
connect(m_menu, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotMenuActivated(int)));
}
void

2
src/gui/editors/eventlist/EventView.h
Unescape View File

@ -54,7 +54,7 @@ class Event;
class EventView : public EditViewBase, public SegmentObserver
{
Q_OBJECT
TQ_OBJECT
// Event filters

2
src/gui/editors/guitar/FingeringBox.cpp
Unescape View File

@ -181,7 +181,7 @@ FingeringBox::mousePressEvent(TQMouseEvent *event)
if (!m_editable)
return;
if((event->button() == Qt::LeftButton) && m_editable) {
if((event->button() == TQt::LeftButton) && m_editable) {
// Find string position
m_press_string_num = getStringNumber(event->pos());

4
src/gui/editors/guitar/GuitarChordEditorDialog.cpp
Unescape View File

@ -50,8 +50,8 @@ GuitarChordEditorDialog::GuitarChordEditorDialog(Guitar::Chord& chord, const Gui
m_startFret = new TQSpinBox(1, 24, 1, page);
topLayout->addWidget(m_startFret, 1, 1);
connect(m_startFret, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotStartFretChanged(int)));
connect(m_startFret, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotStartFretChanged(int)));
topLayout->addWidget(new TQLabel(i18n("Root"), page), 2, 1);
m_rootNotesList = new TQComboBox(page);

2
src/gui/editors/guitar/GuitarChordEditorDialog.h
Unescape View File

@ -39,7 +39,7 @@ class FingeringBox;
class GuitarChordEditorDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

28
src/gui/editors/guitar/GuitarChordSelectorDialog.cpp
Unescape View File

@ -63,8 +63,8 @@ GuitarChordSelectorDialog::GuitarChordSelectorDialog(TQWidget *parent)
m_chordComplexityCombo->insertItem(i18n("common"));
m_chordComplexityCombo->insertItem(i18n("all"));
connect(m_chordComplexityCombo, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotComplexityChanged(int)));
connect(m_chordComplexityCombo, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotComplexityChanged(int)));
TQVBoxLayout* vboxLayout = new TQVBoxLayout(page, 5);
topLayout->addMultiCellLayout(vboxLayout, 1, 3, 2, 2);
@ -74,12 +74,12 @@ GuitarChordSelectorDialog::GuitarChordSelectorDialog(TQWidget *parent)
vboxLayout->addWidget(m_deleteFingeringButton);
vboxLayout->addWidget(m_editFingeringButton);
connect(m_newFingeringButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotNewFingering()));
connect(m_deleteFingeringButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotDeleteFingering()));
connect(m_editFingeringButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotEditFingering()));
connect(m_newFingeringButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotNewFingering()));
connect(m_deleteFingeringButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotDeleteFingering()));
connect(m_editFingeringButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotEditFingering()));
topLayout->addWidget(new TQLabel(i18n("Fingerings"), page), 0, 3);
m_fingeringsList = new TQListBox(page);
@ -88,12 +88,12 @@ GuitarChordSelectorDialog::GuitarChordSelectorDialog(TQWidget *parent)
m_fingeringBox = new FingeringBox(false, page);
topLayout->addMultiCellWidget(m_fingeringBox, 2, 2, 0, 1);
connect(m_rootNotesList, TQT_SIGNAL(highlighted(int)),
this, TQT_SLOT(slotRootHighlighted(int)));
connect(m_chordExtList, TQT_SIGNAL(highlighted(int)),
this, TQT_SLOT(slotChordExtHighlighted(int)));
connect(m_fingeringsList, TQT_SIGNAL(highlighted(TQListBoxItem*)),
this, TQT_SLOT(slotFingeringHighlighted(TQListBoxItem*)));
connect(m_rootNotesList, TQ_SIGNAL(highlighted(int)),
this, TQ_SLOT(slotRootHighlighted(int)));
connect(m_chordExtList, TQ_SIGNAL(highlighted(int)),
this, TQ_SLOT(slotChordExtHighlighted(int)));
connect(m_fingeringsList, TQ_SIGNAL(highlighted(TQListBoxItem*)),
this, TQ_SLOT(slotFingeringHighlighted(TQListBoxItem*)));
}
void

2
src/gui/editors/guitar/GuitarChordSelectorDialog.h
Unescape View File

@ -43,7 +43,7 @@ class FingeringBox;
class GuitarChordSelectorDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
enum { COMPLEXITY_BEGINNER, COMPLEXITY_COMMON, COMPLEXITY_ALL };

2
src/gui/editors/matrix/MatrixCanvasView.h
Unescape View File

@ -44,7 +44,7 @@ class MatrixElement;
class MatrixCanvasView : public RosegardenCanvasView
{
Q_OBJECT
TQ_OBJECT
public:

8
src/gui/editors/matrix/MatrixEraser.cpp
Unescape View File

@ -50,21 +50,21 @@ MatrixEraser::MatrixEraser(MatrixView* parent)
TQIconSet icon = TQIconSet(pixmap);
new TDEAction(i18n("Switch to Select Tool"), icon, 0, this,
TQT_SLOT(slotSelectSelected()), actionCollection(),
TQ_SLOT(slotSelectSelected()), actionCollection(),
"select");
new TDEAction(i18n("Switch to Draw Tool"), "pencil", 0, this,
TQT_SLOT(slotDrawSelected()), actionCollection(),
TQ_SLOT(slotDrawSelected()), actionCollection(),
"draw");
new TDEAction(i18n("Switch to Move Tool"), "move", 0, this,
TQT_SLOT(slotMoveSelected()), actionCollection(),
TQ_SLOT(slotMoveSelected()), actionCollection(),
"move");
pixmap.load(pixmapDir + "/toolbar/resize.xpm");
icon = TQIconSet(pixmap);
new TDEAction(i18n("Switch to Resize Tool"), icon, 0, this,
TQT_SLOT(slotResizeSelected()), actionCollection(),
TQ_SLOT(slotResizeSelected()), actionCollection(),
"resize");
createMenu("matrixeraser.rc");

24
src/gui/editors/matrix/MatrixMover.cpp
Unescape View File

@ -63,21 +63,21 @@ MatrixMover::MatrixMover(MatrixView* parent) :
TQIconSet icon = TQIconSet(pixmap);
new TDEAction(i18n("Switch to Select Tool"), icon, 0, this,
TQT_SLOT(slotSelectSelected()), actionCollection(),
TQ_SLOT(slotSelectSelected()), actionCollection(),
"select");
new TDEAction(i18n("Switch to Draw Tool"), "pencil", 0, this,
TQT_SLOT(slotDrawSelected()), actionCollection(),
TQ_SLOT(slotDrawSelected()), actionCollection(),
"draw");
new TDEAction(i18n("Switch to Erase Tool"), "eraser", 0, this,
TQT_SLOT(slotEraseSelected()), actionCollection(),
TQ_SLOT(slotEraseSelected()), actionCollection(),
"erase");
pixmap.load(pixmapDir + "/toolbar/resize.xpm");
icon = TQIconSet(pixmap);
new TDEAction(i18n("Switch to Resize Tool"), icon, 0, this,
TQT_SLOT(slotResizeSelected()), actionCollection(),
TQ_SLOT(slotResizeSelected()), actionCollection(),
"resize");
createMenu("matrixmover.rc");
@ -418,20 +418,20 @@ void MatrixMover::handleMouseRelease(timeT newTime,
void MatrixMover::ready()
{
connect(m_parentView->getCanvasView(), TQT_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotMatrixScrolled(int, int)));
connect(this, TQT_SIGNAL(hoveredOverNoteChanged(int, bool, timeT)),
m_mParentView, TQT_SLOT(slotHoveredOverNoteChanged(int, bool, timeT)));
connect(m_parentView->getCanvasView(), TQ_SIGNAL(contentsMoving (int, int)),
this, TQ_SLOT(slotMatrixScrolled(int, int)));
connect(this, TQ_SIGNAL(hoveredOverNoteChanged(int, bool, timeT)),
m_mParentView, TQ_SLOT(slotHoveredOverNoteChanged(int, bool, timeT)));
m_mParentView->setCanvasCursor(TQt::sizeAllCursor);
setBasicContextHelp();
}
void MatrixMover::stow()
{
disconnect(m_parentView->getCanvasView(), TQT_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotMatrixScrolled(int, int)));
disconnect(this, TQT_SIGNAL(hoveredOverNoteChanged(int, bool, timeT)),
m_mParentView, TQT_SLOT(slotHoveredOverNoteChanged(int, bool, timeT)));
disconnect(m_parentView->getCanvasView(), TQ_SIGNAL(contentsMoving (int, int)),
this, TQ_SLOT(slotMatrixScrolled(int, int)));
disconnect(this, TQ_SIGNAL(hoveredOverNoteChanged(int, bool, timeT)),
m_mParentView, TQ_SLOT(slotHoveredOverNoteChanged(int, bool, timeT)));
}
void MatrixMover::slotMatrixScrolled(int newX, int newY)

2
src/gui/editors/matrix/MatrixMover.h
Unescape View File

@ -43,7 +43,7 @@ class Event;
class MatrixMover : public MatrixTool
{
Q_OBJECT
TQ_OBJECT
friend class MatrixToolBox;

16
src/gui/editors/matrix/MatrixPainter.cpp
Unescape View File

@ -61,21 +61,21 @@ MatrixPainter::MatrixPainter(MatrixView* parent)
TQIconSet icon = TQIconSet(pixmap);
new TDEAction(i18n("Switch to Select Tool"), icon, 0, this,
TQT_SLOT(slotSelectSelected()), actionCollection(),
TQ_SLOT(slotSelectSelected()), actionCollection(),
"select");
new TDEAction(i18n("Switch to Erase Tool"), "eraser", 0, this,
TQT_SLOT(slotEraseSelected()), actionCollection(),
TQ_SLOT(slotEraseSelected()), actionCollection(),
"erase");
new TDEAction(i18n("Switch to Move Tool"), "move", 0, this,
TQT_SLOT(slotMoveSelected()), actionCollection(),
TQ_SLOT(slotMoveSelected()), actionCollection(),
"move");
pixmap.load(pixmapDir + "/toolbar/resize.xpm");
icon = TQIconSet(pixmap);
new TDEAction(i18n("Switch to Resize Tool"), icon, 0, this,
TQT_SLOT(slotResizeSelected()), actionCollection(),
TQ_SLOT(slotResizeSelected()), actionCollection(),
"resize");
createMenu("matrixpainter.rc");
@ -318,8 +318,8 @@ void MatrixPainter::handleMouseRelease(timeT endTime,
void MatrixPainter::ready()
{
connect(m_parentView->getCanvasView(), TQT_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotMatrixScrolled(int, int)));
connect(m_parentView->getCanvasView(), TQ_SIGNAL(contentsMoving (int, int)),
this, TQ_SLOT(slotMatrixScrolled(int, int)));
m_mParentView->setCanvasCursor(TQt::crossCursor);
@ -328,8 +328,8 @@ void MatrixPainter::ready()
void MatrixPainter::stow()
{
disconnect(m_parentView->getCanvasView(), TQT_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotMatrixScrolled(int, int)));
disconnect(m_parentView->getCanvasView(), TQ_SIGNAL(contentsMoving (int, int)),
this, TQ_SLOT(slotMatrixScrolled(int, int)));
}
void MatrixPainter::slotMatrixScrolled(int newX, int newY)

2
src/gui/editors/matrix/MatrixPainter.h
Unescape View File

@ -43,7 +43,7 @@ class Event;
class MatrixPainter : public MatrixTool
{
Q_OBJECT
TQ_OBJECT
friend class MatrixToolBox;

2
src/gui/editors/matrix/MatrixParameterBox.h
Unescape View File

@ -43,7 +43,7 @@ class EventSelection;
class MatrixParameterBox : public TQFrame
{
Q_OBJECT
TQ_OBJECT
public:

16
src/gui/editors/matrix/MatrixResizer.cpp
Unescape View File

@ -59,19 +59,19 @@ MatrixResizer::MatrixResizer(MatrixView* parent)
TQIconSet icon = TQIconSet(pixmap);
new TDEAction(i18n("Switch to Select Tool"), icon, 0, this,
TQT_SLOT(slotSelectSelected()), actionCollection(),
TQ_SLOT(slotSelectSelected()), actionCollection(),
"select");
new TDEAction(i18n("Switch to Draw Tool"), "pencil", 0, this,
TQT_SLOT(slotDrawSelected()), actionCollection(),
TQ_SLOT(slotDrawSelected()), actionCollection(),
"draw");
new TDEAction(i18n("Switch to Erase Tool"), "eraser", 0, this,
TQT_SLOT(slotEraseSelected()), actionCollection(),
TQ_SLOT(slotEraseSelected()), actionCollection(),
"erase");
new TDEAction(i18n("Switch to Move Tool"), "move", 0, this,
TQT_SLOT(slotMoveSelected()), actionCollection(),
TQ_SLOT(slotMoveSelected()), actionCollection(),
"move");
createMenu("matrixresizer.rc");
@ -287,16 +287,16 @@ void MatrixResizer::handleMouseRelease(timeT newTime,
void MatrixResizer::ready()
{
connect(m_parentView->getCanvasView(), TQT_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotMatrixScrolled(int, int)));
connect(m_parentView->getCanvasView(), TQ_SIGNAL(contentsMoving (int, int)),
this, TQ_SLOT(slotMatrixScrolled(int, int)));
m_mParentView->setCanvasCursor(TQt::sizeHorCursor);
setBasicContextHelp();
}
void MatrixResizer::stow()
{
disconnect(m_parentView->getCanvasView(), TQT_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotMatrixScrolled(int, int)));
disconnect(m_parentView->getCanvasView(), TQ_SIGNAL(contentsMoving (int, int)),
this, TQ_SLOT(slotMatrixScrolled(int, int)));
}
void MatrixResizer::slotMatrixScrolled(int newX, int newY)

2
src/gui/editors/matrix/MatrixResizer.h
Unescape View File

@ -43,7 +43,7 @@ class Event;
class MatrixResizer : public MatrixTool
{
Q_OBJECT
TQ_OBJECT
friend class MatrixToolBox;

22
src/gui/editors/matrix/MatrixSelector.cpp
Unescape View File

@ -69,19 +69,19 @@ MatrixSelector::MatrixSelector(MatrixView* view)
m_matrixView(view),
m_selectionToMerge(0)
{
connect(m_parentView, TQT_SIGNAL(usedSelection()),
this, TQT_SLOT(slotHideSelection()));
connect(m_parentView, TQ_SIGNAL(usedSelection()),
this, TQ_SLOT(slotHideSelection()));
new TDEAction(i18n("Switch to Draw Tool"), "pencil", 0, this,
TQT_SLOT(slotDrawSelected()), actionCollection(),
TQ_SLOT(slotDrawSelected()), actionCollection(),
"draw");
new TDEAction(i18n("Switch to Erase Tool"), "eraser", 0, this,
TQT_SLOT(slotEraseSelected()), actionCollection(),
TQ_SLOT(slotEraseSelected()), actionCollection(),
"erase");
new TDEAction(i18n("Switch to Move Tool"), "move", 0, this,
TQT_SLOT(slotMoveSelected()), actionCollection(),
TQ_SLOT(slotMoveSelected()), actionCollection(),
"move");
TQString pixmapDir = TDEGlobal::dirs()->findResource("appdata", "pixmaps/");
@ -89,7 +89,7 @@ MatrixSelector::MatrixSelector(MatrixView* view)
TQIconSet icon = TQIconSet(pixmap);
new TDEAction(i18n("Switch to Resize Tool"), icon, 0, this,
TQT_SLOT(slotResizeSelected()), actionCollection(),
TQ_SLOT(slotResizeSelected()), actionCollection(),
"resize");
createMenu("matrixselector.rc");
@ -316,7 +316,7 @@ void MatrixSelector::handleMouseDoubleClick(timeT ,
m_justSelectedBar = true;
TQTimer::singleShot(TQApplication::doubleClickInterval(), this,
TQT_SLOT(slotClickTimeout()));
TQ_SLOT(slotClickTimeout()));
} */
}
@ -445,8 +445,8 @@ void MatrixSelector::ready()
//m_mParentView->setPositionTracking(false);
}
connect(m_parentView->getCanvasView(), TQT_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotMatrixScrolled(int, int)));
connect(m_parentView->getCanvasView(), TQ_SIGNAL(contentsMoving (int, int)),
this, TQ_SLOT(slotMatrixScrolled(int, int)));
setContextHelp(i18n("Click and drag to select; middle-click and drag to draw new note"));
}
@ -459,8 +459,8 @@ void MatrixSelector::stow()
m_mParentView->canvas()->update();
}
disconnect(m_parentView->getCanvasView(), TQT_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotMatrixScrolled(int, int)));
disconnect(m_parentView->getCanvasView(), TQ_SIGNAL(contentsMoving (int, int)),
this, TQ_SLOT(slotMatrixScrolled(int, int)));
}

2
src/gui/editors/matrix/MatrixSelector.h
Unescape View File

@ -46,7 +46,7 @@ class EditTool;
class MatrixSelector : public MatrixTool
{
Q_OBJECT
TQ_OBJECT
friend class MatrixToolBox;

2
src/gui/editors/matrix/MatrixTool.h
Unescape View File

@ -40,7 +40,7 @@ class SnapGrid;
class MatrixTool : public EditTool
{
Q_OBJECT
TQ_OBJECT
public:

2
src/gui/editors/matrix/MatrixToolBox.h
Unescape View File

@ -38,7 +38,7 @@ class MatrixStaff;
class MatrixToolBox : public EditToolBox
{
Q_OBJECT
TQ_OBJECT
public:
MatrixToolBox(MatrixView* parent);

394
src/gui/editors/matrix/MatrixView.cpp
Unescape View File

@ -173,14 +173,14 @@ MatrixView::MatrixView(RosegardenGUIDoc *doc,
KDockWidget::DockLeft, // dock site
20); // relation target/this (in percent)
connect(m_dockLeft, TQT_SIGNAL(iMBeingClosed()),
TQT_TQOBJECT(this), TQT_SLOT(slotParametersClosed()));
connect(m_dockLeft, TQT_SIGNAL(hasUndocked()),
TQT_TQOBJECT(this), TQT_SLOT(slotParametersClosed()));
connect(m_dockLeft, TQ_SIGNAL(iMBeingClosed()),
this, TQ_SLOT(slotParametersClosed()));
connect(m_dockLeft, TQ_SIGNAL(hasUndocked()),
this, TQ_SLOT(slotParametersClosed()));
// Apparently, hasUndocked() is emitted when the dock widget's
// 'close' button on the dock handle is clicked.
connect(m_mainDockWidget, TQT_SIGNAL(docking(KDockWidget*, KDockWidget::DockPosition)),
TQT_TQOBJECT(this), TQT_SLOT(slotParametersDockedBack(KDockWidget*, KDockWidget::DockPosition)));
connect(m_mainDockWidget, TQ_SIGNAL(docking(KDockWidget*, KDockWidget::DockPosition)),
this, TQ_SLOT(slotParametersDockedBack(KDockWidget*, KDockWidget::DockPosition)));
Composition &comp = doc->getComposition();
@ -188,10 +188,10 @@ MatrixView::MatrixView(RosegardenGUIDoc *doc,
initStatusBar();
connect(m_toolBox, TQT_SIGNAL(showContextHelp(const TQString &)),
TQT_TQOBJECT(this), TQT_SLOT(slotToolHelpChanged(const TQString &)));
connect(m_toolBox, TQ_SIGNAL(showContextHelp(const TQString &)),
this, TQ_SLOT(slotToolHelpChanged(const TQString &)));
TQCanvas *tCanvas = new TQCanvas(TQT_TQOBJECT(this));
TQCanvas *tCanvas = new TQCanvas(this);
m_config->setGroup(MatrixViewConfigGroup);
if (m_config->readBoolEntry("backgroundtextures-1.6-plus", true)) {
@ -276,33 +276,33 @@ MatrixView::MatrixView(RosegardenGUIDoc *doc,
RosegardenGUIApp *app = RosegardenGUIApp::self();
connect(app,
TQT_SIGNAL(pluginSelected(InstrumentId, int, int)),
TQ_SIGNAL(pluginSelected(InstrumentId, int, int)),
m_parameterBox,
TQT_SLOT(slotPluginSelected(InstrumentId, int, int)));
TQ_SLOT(slotPluginSelected(InstrumentId, int, int)));
connect(app,
TQT_SIGNAL(pluginBypassed(InstrumentId, int, bool)),
TQ_SIGNAL(pluginBypassed(InstrumentId, int, bool)),
m_parameterBox,
TQT_SLOT(slotPluginBypassed(InstrumentId, int, bool)));
TQ_SLOT(slotPluginBypassed(InstrumentId, int, bool)));
connect(app,
TQT_SIGNAL(instrumentParametersChanged(InstrumentId)),
TQ_SIGNAL(instrumentParametersChanged(InstrumentId)),
m_parameterBox,
TQT_SLOT(slotInstrumentParametersChanged(InstrumentId)));
TQ_SLOT(slotInstrumentParametersChanged(InstrumentId)));
connect(m_parameterBox,
TQT_SIGNAL(instrumentParametersChanged(InstrumentId)),
TQ_SIGNAL(instrumentParametersChanged(InstrumentId)),
app,
TQT_SIGNAL(instrumentParametersChanged(InstrumentId)));
TQ_SIGNAL(instrumentParametersChanged(InstrumentId)));
connect(m_parameterBox,
TQT_SIGNAL(selectPlugin(TQWidget *, InstrumentId, int)),
TQ_SIGNAL(selectPlugin(TQWidget *, InstrumentId, int)),
app,
TQT_SLOT(slotShowPluginDialog(TQWidget *, InstrumentId, int)));
TQ_SLOT(slotShowPluginDialog(TQWidget *, InstrumentId, int)));
connect(m_parameterBox,
TQT_SIGNAL(showPluginGUI(InstrumentId, int)),
TQ_SIGNAL(showPluginGUI(InstrumentId, int)),
app,
TQT_SLOT(slotShowPluginGUI(InstrumentId, int)));
TQ_SLOT(slotShowPluginGUI(InstrumentId, int)));
connect(parent, // RosegardenGUIView
TQT_SIGNAL(checkTrackAssignments()),
TQ_SIGNAL(checkTrackAssignments()),
this,
TQT_SLOT(slotCheckTrackAssignments()));
TQ_SLOT(slotCheckTrackAssignments()));
// Assign the instrument
//
@ -310,9 +310,9 @@ MatrixView::MatrixView(RosegardenGUIDoc *doc,
if (m_drumMode) {
connect(m_parameterBox,
TQT_SIGNAL(instrumentPercussionSetChanged(Instrument *)),
TQ_SIGNAL(instrumentPercussionSetChanged(Instrument *)),
this,
TQT_SLOT(slotPercussionSetChanged(Instrument *)));
TQ_SLOT(slotPercussionSetChanged(Instrument *)));
}
// Set the snap grid from the stored size in the segment
@ -350,83 +350,83 @@ MatrixView::MatrixView(RosegardenGUIDoc *doc,
// Connect vertical scrollbars between matrix and piano
//
connect(m_canvasView->verticalScrollBar(), TQT_SIGNAL(valueChanged(int)),
TQT_TQOBJECT(this), TQT_SLOT(slotVerticalScrollPianoKeyboard(int)));
connect(m_canvasView->verticalScrollBar(), TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotVerticalScrollPianoKeyboard(int)));
connect(m_canvasView->verticalScrollBar(), TQT_SIGNAL(sliderMoved(int)),
TQT_TQOBJECT(this), TQT_SLOT(slotVerticalScrollPianoKeyboard(int)));
connect(m_canvasView->verticalScrollBar(), TQ_SIGNAL(sliderMoved(int)),
this, TQ_SLOT(slotVerticalScrollPianoKeyboard(int)));
connect(m_canvasView, TQT_SIGNAL(zoomIn()), TQT_TQOBJECT(this), TQT_SLOT(slotZoomIn()));
connect(m_canvasView, TQT_SIGNAL(zoomOut()), TQT_TQOBJECT(this), TQT_SLOT(slotZoomOut()));
connect(m_canvasView, TQ_SIGNAL(zoomIn()), this, TQ_SLOT(slotZoomIn()));
connect(m_canvasView, TQ_SIGNAL(zoomOut()), this, TQ_SLOT(slotZoomOut()));
connect(m_pianoView, TQT_SIGNAL(gotWheelEvent(TQWheelEvent*)),
m_canvasView, TQT_SLOT(slotExternalWheelEvent(TQWheelEvent*)));
connect(m_pianoView, TQ_SIGNAL(gotWheelEvent(TQWheelEvent*)),
m_canvasView, TQ_SLOT(slotExternalWheelEvent(TQWheelEvent*)));
// ensure the piano keyb keeps the right margins when the user toggles
// the canvas view rulers
//
connect(m_canvasView, TQT_SIGNAL(bottomWidgetHeightChanged(int)),
TQT_TQOBJECT(this), TQT_SLOT(slotCanvasBottomWidgetHeightChanged(int)));
connect(m_canvasView, TQ_SIGNAL(bottomWidgetHeightChanged(int)),
this, TQ_SLOT(slotCanvasBottomWidgetHeightChanged(int)));
connect(m_canvasView, TQT_SIGNAL(mouseEntered()),
TQT_TQOBJECT(this), TQT_SLOT(slotMouseEnteredCanvasView()));
connect(m_canvasView, TQ_SIGNAL(mouseEntered()),
this, TQ_SLOT(slotMouseEnteredCanvasView()));
connect(m_canvasView, TQT_SIGNAL(mouseLeft()),
TQT_TQOBJECT(this), TQT_SLOT(slotMouseLeftCanvasView()));
connect(m_canvasView, TQ_SIGNAL(mouseLeft()),
this, TQ_SLOT(slotMouseLeftCanvasView()));
/*
TQObject::connect
(getCanvasView(), TQT_SIGNAL(activeItemPressed(TQMouseEvent*, TQCanvasItem*)),
this, TQT_SLOT (activeItemPressed(TQMouseEvent*, TQCanvasItem*)));
(getCanvasView(), TQ_SIGNAL(activeItemPressed(TQMouseEvent*, TQCanvasItem*)),
this, TQ_SLOT (activeItemPressed(TQMouseEvent*, TQCanvasItem*)));
*/
TQObject::connect
(getCanvasView(),
TQT_SIGNAL(mousePressed(timeT,
TQ_SIGNAL(mousePressed(timeT,
int, TQMouseEvent*, MatrixElement*)),
this,
TQT_SLOT(slotMousePressed(timeT,
TQ_SLOT(slotMousePressed(timeT,
int, TQMouseEvent*, MatrixElement*)));
TQObject::connect
(getCanvasView(),
TQT_SIGNAL(mouseMoved(timeT, int, TQMouseEvent*)),
TQ_SIGNAL(mouseMoved(timeT, int, TQMouseEvent*)),
this,
TQT_SLOT(slotMouseMoved(timeT, int, TQMouseEvent*)));
TQ_SLOT(slotMouseMoved(timeT, int, TQMouseEvent*)));
TQObject::connect
(getCanvasView(),
TQT_SIGNAL(mouseReleased(timeT, int, TQMouseEvent*)),
TQ_SIGNAL(mouseReleased(timeT, int, TQMouseEvent*)),
this,
TQT_SLOT(slotMouseReleased(timeT, int, TQMouseEvent*)));
TQ_SLOT(slotMouseReleased(timeT, int, TQMouseEvent*)));
TQObject::connect
(getCanvasView(), TQT_SIGNAL(hoveredOverNoteChanged(int, bool, timeT)),
TQT_TQOBJECT(this), TQT_SLOT(slotHoveredOverNoteChanged(int, bool, timeT)));
(getCanvasView(), TQ_SIGNAL(hoveredOverNoteChanged(int, bool, timeT)),
this, TQ_SLOT(slotHoveredOverNoteChanged(int, bool, timeT)));
TQObject::connect
(m_pitchRuler, TQT_SIGNAL(hoveredOverKeyChanged(unsigned int)),
TQT_TQOBJECT(this), TQT_SLOT (slotHoveredOverKeyChanged(unsigned int)));
(m_pitchRuler, TQ_SIGNAL(hoveredOverKeyChanged(unsigned int)),
this, TQ_SLOT (slotHoveredOverKeyChanged(unsigned int)));
TQObject::connect
(m_pitchRuler, TQT_SIGNAL(keyPressed(unsigned int, bool)),
TQT_TQOBJECT(this), TQT_SLOT (slotKeyPressed(unsigned int, bool)));
(m_pitchRuler, TQ_SIGNAL(keyPressed(unsigned int, bool)),
this, TQ_SLOT (slotKeyPressed(unsigned int, bool)));
TQObject::connect
(m_pitchRuler, TQT_SIGNAL(keySelected(unsigned int, bool)),
TQT_TQOBJECT(this), TQT_SLOT (slotKeySelected(unsigned int, bool)));
(m_pitchRuler, TQ_SIGNAL(keySelected(unsigned int, bool)),
this, TQ_SLOT (slotKeySelected(unsigned int, bool)));
TQObject::connect
(m_pitchRuler, TQT_SIGNAL(keyReleased(unsigned int, bool)),
TQT_TQOBJECT(this), TQT_SLOT (slotKeyReleased(unsigned int, bool)));
(m_pitchRuler, TQ_SIGNAL(keyReleased(unsigned int, bool)),
this, TQ_SLOT (slotKeyReleased(unsigned int, bool)));
TQObject::connect
(getCanvasView(), TQT_SIGNAL(hoveredOverAbsoluteTimeChanged(unsigned int)),
TQT_TQOBJECT(this), TQT_SLOT (slotHoveredOverAbsoluteTimeChanged(unsigned int)));
(getCanvasView(), TQ_SIGNAL(hoveredOverAbsoluteTimeChanged(unsigned int)),
this, TQ_SLOT (slotHoveredOverAbsoluteTimeChanged(unsigned int)));
TQObject::connect
(doc, TQT_SIGNAL(pointerPositionChanged(timeT)),
TQT_TQOBJECT(this), TQT_SLOT(slotSetPointerPosition(timeT)));
(doc, TQ_SIGNAL(pointerPositionChanged(timeT)),
this, TQ_SLOT(slotSetPointerPosition(timeT)));
MATRIX_DEBUG << "MatrixView : applying layout\n";
@ -463,32 +463,32 @@ MatrixView::MatrixView(RosegardenGUIDoc *doc,
TQObject::disconnect
(topStandardRuler->getLoopRuler(),
TQT_SIGNAL(setPointerPosition(timeT)), 0, 0);
TQ_SIGNAL(setPointerPosition(timeT)), 0, 0);
TQObject::connect
(topStandardRuler->getLoopRuler(),
TQT_SIGNAL(setPointerPosition(timeT)),
TQT_TQOBJECT(this), TQT_SLOT(slotSetInsertCursorPosition(timeT)));
TQ_SIGNAL(setPointerPosition(timeT)),
this, TQ_SLOT(slotSetInsertCursorPosition(timeT)));
TQObject::connect
(topStandardRuler,
TQT_SIGNAL(dragPointerToPosition(timeT)),
TQT_TQOBJECT(this), TQT_SLOT(slotSetInsertCursorPosition(timeT)));
TQ_SIGNAL(dragPointerToPosition(timeT)),
this, TQ_SLOT(slotSetInsertCursorPosition(timeT)));
topStandardRuler->getLoopRuler()->setBackgroundColor
(GUIPalette::getColour(GUIPalette::InsertCursorRuler));
connect(topStandardRuler->getLoopRuler(), TQT_SIGNAL(startMouseMove(int)),
m_canvasView, TQT_SLOT(startAutoScroll(int)));
connect(topStandardRuler->getLoopRuler(), TQT_SIGNAL(stopMouseMove()),
m_canvasView, TQT_SLOT(stopAutoScroll()));
connect(topStandardRuler->getLoopRuler(), TQ_SIGNAL(startMouseMove(int)),
m_canvasView, TQ_SLOT(startAutoScroll(int)));
connect(topStandardRuler->getLoopRuler(), TQ_SIGNAL(stopMouseMove()),
m_canvasView, TQ_SLOT(stopAutoScroll()));
connect(bottomStandardRuler->getLoopRuler(), TQT_SIGNAL(startMouseMove(int)),
m_canvasView, TQT_SLOT(startAutoScroll(int)));
connect(bottomStandardRuler->getLoopRuler(), TQT_SIGNAL(stopMouseMove()),
m_canvasView, TQT_SLOT(stopAutoScroll()));
connect(m_bottomStandardRuler, TQT_SIGNAL(dragPointerToPosition(timeT)),
TQT_TQOBJECT(this), TQT_SLOT(slotSetPointerPosition(timeT)));
connect(bottomStandardRuler->getLoopRuler(), TQ_SIGNAL(startMouseMove(int)),
m_canvasView, TQ_SLOT(startAutoScroll(int)));
connect(bottomStandardRuler->getLoopRuler(), TQ_SIGNAL(stopMouseMove()),
m_canvasView, TQ_SLOT(stopAutoScroll()));
connect(m_bottomStandardRuler, TQ_SIGNAL(dragPointerToPosition(timeT)),
this, TQ_SLOT(slotSetPointerPosition(timeT)));
// Force height for the moment
//
@ -637,148 +637,148 @@ void MatrixView::setupActions()
TQIconSet icon(TQPixmap(pixmapDir + "/toolbar/select.xpm"));
toolAction = new TDERadioAction(i18n("&Select and Edit"), icon, Key_F2,
TQT_TQOBJECT(this), TQT_SLOT(slotSelectSelected()),
this, TQ_SLOT(slotSelectSelected()),
actionCollection(), "select");
toolAction->setExclusiveGroup("tools");
toolAction = new TDERadioAction(i18n("&Draw"), "pencil", Key_F3,
TQT_TQOBJECT(this), TQT_SLOT(slotPaintSelected()),
this, TQ_SLOT(slotPaintSelected()),
actionCollection(), "draw");
toolAction->setExclusiveGroup("tools");
toolAction = new TDERadioAction(i18n("&Erase"), "eraser", Key_F4,
TQT_TQOBJECT(this), TQT_SLOT(slotEraseSelected()),
this, TQ_SLOT(slotEraseSelected()),
actionCollection(), "erase");
toolAction->setExclusiveGroup("tools");
toolAction = new TDERadioAction(i18n("&Move"), "move", Key_F5,
TQT_TQOBJECT(this), TQT_SLOT(slotMoveSelected()),
this, TQ_SLOT(slotMoveSelected()),
actionCollection(), "move");
toolAction->setExclusiveGroup("tools");
TQCanvasPixmap pixmap(pixmapDir + "/toolbar/resize.xpm");
icon = TQIconSet(pixmap);
toolAction = new TDERadioAction(i18n("Resi&ze"), icon, Key_F6,
TQT_TQOBJECT(this), TQT_SLOT(slotResizeSelected()),
this, TQ_SLOT(slotResizeSelected()),
actionCollection(), "resize");
toolAction->setExclusiveGroup("tools");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap("chord")));
(new TDEToggleAction(i18n("C&hord Insert Mode"), icon, Key_H,
TQT_TQOBJECT(this), TQT_SLOT(slotUpdateInsertModeStatus()),
this, TQ_SLOT(slotUpdateInsertModeStatus()),
actionCollection(), "chord_mode"))->
setChecked(false);
pixmap.load(pixmapDir + "/toolbar/step_by_step.xpm");
icon = TQIconSet(pixmap);
new TDEToggleAction(i18n("Ste&p Recording"), icon, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotToggleStepByStep()), actionCollection(),
new TDEToggleAction(i18n("Ste&p Recording"), icon, 0, this,
TQ_SLOT(slotToggleStepByStep()), actionCollection(),
"toggle_step_by_step");
pixmap.load(pixmapDir + "/toolbar/quantize.png");
icon = TQIconSet(pixmap);
new TDEAction(EventQuantizeCommand::getGlobalName(), icon, Key_Equal, TQT_TQOBJECT(this),
TQT_SLOT(slotTransformsQuantize()), actionCollection(),
new TDEAction(EventQuantizeCommand::getGlobalName(), icon, Key_Equal, this,
TQ_SLOT(slotTransformsQuantize()), actionCollection(),
"quantize");
new TDEAction(i18n("Repeat Last Quantize"), Key_Plus, TQT_TQOBJECT(this),
TQT_SLOT(slotTransformsRepeatQuantize()), actionCollection(),
new TDEAction(i18n("Repeat Last Quantize"), Key_Plus, this,
TQ_SLOT(slotTransformsRepeatQuantize()), actionCollection(),
"repeat_quantize");
new TDEAction(CollapseNotesCommand::getGlobalName(), Key_Equal + CTRL, TQT_TQOBJECT(this),
TQT_SLOT(slotTransformsCollapseNotes()), actionCollection(),
new TDEAction(CollapseNotesCommand::getGlobalName(), Key_Equal + CTRL, this,
TQ_SLOT(slotTransformsCollapseNotes()), actionCollection(),
"collapse_notes");
new TDEAction(i18n("&Legato"), Key_Minus, TQT_TQOBJECT(this),
TQT_SLOT(slotTransformsLegato()), actionCollection(),
new TDEAction(i18n("&Legato"), Key_Minus, this,
TQ_SLOT(slotTransformsLegato()), actionCollection(),
"legatoize");
new TDEAction(ChangeVelocityCommand::getGlobalName(10), 0,
Key_Up + SHIFT, TQT_TQOBJECT(this),
TQT_SLOT(slotVelocityUp()), actionCollection(),
Key_Up + SHIFT, this,
TQ_SLOT(slotVelocityUp()), actionCollection(),
"velocity_up");
new TDEAction(ChangeVelocityCommand::getGlobalName( -10), 0,
Key_Down + SHIFT, TQT_TQOBJECT(this),
TQT_SLOT(slotVelocityDown()), actionCollection(),
Key_Down + SHIFT, this,
TQ_SLOT(slotVelocityDown()), actionCollection(),
"velocity_down");
new TDEAction(i18n("Set to Current Velocity"), 0, TQT_TQOBJECT(this),
TQT_SLOT(slotSetVelocitiesToCurrent()), actionCollection(),
new TDEAction(i18n("Set to Current Velocity"), 0, this,
TQ_SLOT(slotSetVelocitiesToCurrent()), actionCollection(),
"set_to_current_velocity");
new TDEAction(i18n("Set Event &Velocities..."), 0, TQT_TQOBJECT(this),
TQT_SLOT(slotSetVelocities()), actionCollection(),
new TDEAction(i18n("Set Event &Velocities..."), 0, this,
TQ_SLOT(slotSetVelocities()), actionCollection(),
"set_velocities");
new TDEAction(i18n("Trigger Se&gment..."), 0, TQT_TQOBJECT(this),
TQT_SLOT(slotTriggerSegment()), actionCollection(),
new TDEAction(i18n("Trigger Se&gment..."), 0, this,
TQ_SLOT(slotTriggerSegment()), actionCollection(),
"trigger_segment");
new TDEAction(i18n("Remove Triggers..."), 0, TQT_TQOBJECT(this),
TQT_SLOT(slotRemoveTriggers()), actionCollection(),
new TDEAction(i18n("Remove Triggers..."), 0, this,
TQ_SLOT(slotRemoveTriggers()), actionCollection(),
"remove_trigger");
new TDEAction(i18n("Select &All"), Key_A + CTRL, TQT_TQOBJECT(this),
TQT_SLOT(slotSelectAll()), actionCollection(),
new TDEAction(i18n("Select &All"), Key_A + CTRL, this,
TQ_SLOT(slotSelectAll()), actionCollection(),
"select_all");
new TDEAction(i18n("&Delete"), Key_Delete, TQT_TQOBJECT(this),
TQT_SLOT(slotEditDelete()), actionCollection(),
new TDEAction(i18n("&Delete"), Key_Delete, this,
TQ_SLOT(slotEditDelete()), actionCollection(),
"delete");
new TDEAction(i18n("Cursor &Back"), 0, Key_Left, TQT_TQOBJECT(this),
TQT_SLOT(slotStepBackward()), actionCollection(),
new TDEAction(i18n("Cursor &Back"), 0, Key_Left, this,
TQ_SLOT(slotStepBackward()), actionCollection(),
"cursor_back");
new TDEAction(i18n("Cursor &Forward"), 0, Key_Right, TQT_TQOBJECT(this),
TQT_SLOT(slotStepForward()), actionCollection(),
new TDEAction(i18n("Cursor &Forward"), 0, Key_Right, this,
TQ_SLOT(slotStepForward()), actionCollection(),
"cursor_forward");
new TDEAction(i18n("Cursor Ba&ck Bar"), 0, Key_Left + CTRL, TQT_TQOBJECT(this),
TQT_SLOT(slotJumpBackward()), actionCollection(),
new TDEAction(i18n("Cursor Ba&ck Bar"), 0, Key_Left + CTRL, this,
TQ_SLOT(slotJumpBackward()), actionCollection(),
"cursor_back_bar");
new TDEAction(i18n("Cursor For&ward Bar"), 0, Key_Right + CTRL, TQT_TQOBJECT(this),
TQT_SLOT(slotJumpForward()), actionCollection(),
new TDEAction(i18n("Cursor For&ward Bar"), 0, Key_Right + CTRL, this,
TQ_SLOT(slotJumpForward()), actionCollection(),
"cursor_forward_bar");
new TDEAction(i18n("Cursor Back and Se&lect"), SHIFT + Key_Left, TQT_TQOBJECT(this),
TQT_SLOT(slotExtendSelectionBackward()), actionCollection(),
new TDEAction(i18n("Cursor Back and Se&lect"), SHIFT + Key_Left, this,
TQ_SLOT(slotExtendSelectionBackward()), actionCollection(),
"extend_selection_backward");
new TDEAction(i18n("Cursor Forward and &Select"), SHIFT + Key_Right, TQT_TQOBJECT(this),
TQT_SLOT(slotExtendSelectionForward()), actionCollection(),
new TDEAction(i18n("Cursor Forward and &Select"), SHIFT + Key_Right, this,
TQ_SLOT(slotExtendSelectionForward()), actionCollection(),
"extend_selection_forward");
new TDEAction(i18n("Cursor Back Bar and Select"), SHIFT + CTRL + Key_Left, TQT_TQOBJECT(this),
TQT_SLOT(slotExtendSelectionBackwardBar()), actionCollection(),
new TDEAction(i18n("Cursor Back Bar and Select"), SHIFT + CTRL + Key_Left, this,
TQ_SLOT(slotExtendSelectionBackwardBar()), actionCollection(),
"extend_selection_backward_bar");
new TDEAction(i18n("Cursor Forward Bar and Select"), SHIFT + CTRL + Key_Right, TQT_TQOBJECT(this),
TQT_SLOT(slotExtendSelectionForwardBar()), actionCollection(),
new TDEAction(i18n("Cursor Forward Bar and Select"), SHIFT + CTRL + Key_Right, this,
TQ_SLOT(slotExtendSelectionForwardBar()), actionCollection(),
"extend_selection_forward_bar");
new TDEAction(i18n("Cursor to St&art"), 0,
/* #1025717: conflicting meanings for ctrl+a - dupe with Select All
Key_A + CTRL, */ TQT_TQOBJECT(this),
TQT_SLOT(slotJumpToStart()), actionCollection(),
Key_A + CTRL, */ this,
TQ_SLOT(slotJumpToStart()), actionCollection(),
"cursor_start");
new TDEAction(i18n("Cursor to &End"), 0, Key_E + CTRL, TQT_TQOBJECT(this),
TQT_SLOT(slotJumpToEnd()), actionCollection(),
new TDEAction(i18n("Cursor to &End"), 0, Key_E + CTRL, this,
TQ_SLOT(slotJumpToEnd()), actionCollection(),
"cursor_end");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-cursor-to-pointer")));
new TDEAction(i18n("Cursor to &Playback Pointer"), icon, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotJumpCursorToPlayback()), actionCollection(),
new TDEAction(i18n("Cursor to &Playback Pointer"), icon, 0, this,
TQ_SLOT(slotJumpCursorToPlayback()), actionCollection(),
"cursor_to_playback_pointer");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-play")));
TDEAction *play = new TDEAction(i18n("&Play"), icon, Key_Enter, TQT_TQOBJECT(this),
TQT_SIGNAL(play()), actionCollection(), "play");
TDEAction *play = new TDEAction(i18n("&Play"), icon, Key_Enter, this,
TQ_SIGNAL(play()), actionCollection(), "play");
// Alternative shortcut for Play
TDEShortcut playShortcut = play->shortcut();
playShortcut.append( KKey(Key_Return + CTRL) );
@ -786,71 +786,71 @@ void MatrixView::setupActions()
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-stop")));
new TDEAction(i18n("&Stop"), icon, Key_Insert, TQT_TQOBJECT(this),
TQT_SIGNAL(stop()), actionCollection(), "stop");
new TDEAction(i18n("&Stop"), icon, Key_Insert, this,
TQ_SIGNAL(stop()), actionCollection(), "stop");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-rewind")));
new TDEAction(i18n("Re&wind"), icon, Key_End, TQT_TQOBJECT(this),
TQT_SIGNAL(rewindPlayback()), actionCollection(),
new TDEAction(i18n("Re&wind"), icon, Key_End, this,
TQ_SIGNAL(rewindPlayback()), actionCollection(),
"playback_pointer_back_bar");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-ffwd")));
new TDEAction(i18n("&Fast Forward"), icon, Key_PageDown, TQT_TQOBJECT(this),
TQT_SIGNAL(fastForwardPlayback()), actionCollection(),
new TDEAction(i18n("&Fast Forward"), icon, Key_PageDown, this,
TQ_SIGNAL(fastForwardPlayback()), actionCollection(),
"playback_pointer_forward_bar");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-rewind-end")));
new TDEAction(i18n("Rewind to &Beginning"), icon, 0, TQT_TQOBJECT(this),
TQT_SIGNAL(rewindPlaybackToBeginning()), actionCollection(),
new TDEAction(i18n("Rewind to &Beginning"), icon, 0, this,
TQ_SIGNAL(rewindPlaybackToBeginning()), actionCollection(),
"playback_pointer_start");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-ffwd-end")));
new TDEAction(i18n("Fast Forward to &End"), icon, 0, TQT_TQOBJECT(this),
TQT_SIGNAL(fastForwardPlaybackToEnd()), actionCollection(),
new TDEAction(i18n("Fast Forward to &End"), icon, 0, this,
TQ_SIGNAL(fastForwardPlaybackToEnd()), actionCollection(),
"playback_pointer_end");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-pointer-to-cursor")));
new TDEAction(i18n("Playback Pointer to &Cursor"), icon, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotJumpPlaybackToCursor()), actionCollection(),
new TDEAction(i18n("Playback Pointer to &Cursor"), icon, 0, this,
TQ_SLOT(slotJumpPlaybackToCursor()), actionCollection(),
"playback_pointer_to_cursor");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-solo")));
new TDEToggleAction(i18n("&Solo"), icon, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotToggleSolo()), actionCollection(),
new TDEToggleAction(i18n("&Solo"), icon, 0, this,
TQ_SLOT(slotToggleSolo()), actionCollection(),
"toggle_solo");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-tracking")));
(new TDEToggleAction(i18n("Scro&ll to Follow Playback"), icon, Key_Pause, TQT_TQOBJECT(this),
TQT_SLOT(slotToggleTracking()), actionCollection(),
(new TDEToggleAction(i18n("Scro&ll to Follow Playback"), icon, Key_Pause, this,
TQ_SLOT(slotToggleTracking()), actionCollection(),
"toggle_tracking"))->setChecked(m_playTracking);
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-panic")));
new TDEAction(i18n("Panic"), icon, Key_P + CTRL + ALT, TQT_TQOBJECT(this),
TQT_SIGNAL(panic()), actionCollection(), "panic");
new TDEAction(i18n("Panic"), icon, Key_P + CTRL + ALT, this,
TQ_SIGNAL(panic()), actionCollection(), "panic");
new TDEAction(i18n("Set Loop to Selection"), Key_Semicolon + CTRL, TQT_TQOBJECT(this),
TQT_SLOT(slotPreviewSelection()), actionCollection(),
new TDEAction(i18n("Set Loop to Selection"), Key_Semicolon + CTRL, this,
TQ_SLOT(slotPreviewSelection()), actionCollection(),
"preview_selection");
new TDEAction(i18n("Clear L&oop"), Key_Colon + CTRL, TQT_TQOBJECT(this),
TQT_SLOT(slotClearLoop()), actionCollection(),
new TDEAction(i18n("Clear L&oop"), Key_Colon + CTRL, this,
TQ_SLOT(slotClearLoop()), actionCollection(),
"clear_loop");
new TDEAction(i18n("Clear Selection"), Key_Escape, TQT_TQOBJECT(this),
TQT_SLOT(slotClearSelection()), actionCollection(),
new TDEAction(i18n("Clear Selection"), Key_Escape, this,
TQ_SLOT(slotClearSelection()), actionCollection(),
"clear_selection");
// icon = TQIconSet(TQCanvasPixmap(pixmapDir + "/toolbar/eventfilter.xpm"));
new TDEAction(i18n("&Filter Selection"), "filter", Key_F + CTRL, TQT_TQOBJECT(this),
TQT_SLOT(slotFilterSelection()), actionCollection(),
new TDEAction(i18n("&Filter Selection"), "filter", Key_F + CTRL, this,
TQ_SLOT(slotFilterSelection()), actionCollection(),
"filter_selection");
timeT crotchetDuration = Note(Note::Crotchet).getDuration();
@ -874,17 +874,17 @@ void MatrixView::setupActions()
timeT d = m_snapValues[i];
if (d == SnapGrid::NoSnap) {
new TDEAction(i18n("&No Snap"), 0, TQT_TQOBJECT(this),
TQT_SLOT(slotSetSnapFromAction()),
new TDEAction(i18n("&No Snap"), 0, this,
TQ_SLOT(slotSetSnapFromAction()),
actionCollection(), "snap_none");
} else if (d == SnapGrid::SnapToUnit) {
} else if (d == SnapGrid::SnapToBeat) {
new TDEAction(i18n("Snap to Bea&t"), Key_1, TQT_TQOBJECT(this),
TQT_SLOT(slotSetSnapFromAction()),
new TDEAction(i18n("Snap to Bea&t"), Key_1, this,
TQ_SLOT(slotSetSnapFromAction()),
actionCollection(), "snap_beat");
} else if (d == SnapGrid::SnapToBar) {
new TDEAction(i18n("Snap to &Bar"), Key_5, TQT_TQOBJECT(this),
TQT_SLOT(slotSetSnapFromAction()),
new TDEAction(i18n("Snap to &Bar"), Key_5, this,
TQ_SLOT(slotSetSnapFromAction()),
actionCollection(), "snap_bar");
} else {
@ -903,8 +903,8 @@ void MatrixView::setupActions()
TQString actionName = TQString("snap_%1").arg(int((crotchetDuration * 4) / d));
if (d == (crotchetDuration * 3) / 2) actionName = "snap_3";
new TDEAction(i18n("Snap to %1").arg(label), pixmap, cut, TQT_TQOBJECT(this),
TQT_SLOT(slotSetSnapFromAction()), actionCollection(),
new TDEAction(i18n("Snap to %1").arg(label), pixmap, cut, this,
TQ_SLOT(slotSetSnapFromAction()), actionCollection(),
actionName.ascii());
}
}
@ -912,17 +912,17 @@ void MatrixView::setupActions()
//
// Settings menu
//
new TDEAction(i18n("Show Instrument Parameters"), 0, TQT_TQOBJECT(this),
TQT_SLOT(slotDockParametersBack()),
new TDEAction(i18n("Show Instrument Parameters"), 0, this,
TQ_SLOT(slotDockParametersBack()),
actionCollection(),
"show_inst_parameters");
new TDEToggleAction(i18n("Show Ch&ord Name Ruler"), 0, TQT_TQOBJECT(this),
TQT_SLOT(slotToggleChordsRuler()),
new TDEToggleAction(i18n("Show Ch&ord Name Ruler"), 0, this,
TQ_SLOT(slotToggleChordsRuler()),
actionCollection(), "show_chords_ruler");
new TDEToggleAction(i18n("Show &Tempo Ruler"), 0, TQT_TQOBJECT(this),
TQT_SLOT(slotToggleTempoRuler()),
new TDEToggleAction(i18n("Show &Tempo Ruler"), 0, this,
TQ_SLOT(slotToggleTempoRuler()),
actionCollection(), "show_tempo_ruler");
createGUI(getRCFileName(), false);
@ -1312,11 +1312,11 @@ void MatrixView::slotSelectSelected()
{
EditTool* selector = m_toolBox->getTool(MatrixSelector::ToolName);
connect(selector, TQT_SIGNAL(gotSelection()),
TQT_TQOBJECT(this), TQT_SLOT(slotNewSelection()));
connect(selector, TQ_SIGNAL(gotSelection()),
this, TQ_SLOT(slotNewSelection()));
connect(selector, TQT_SIGNAL(editTriggerSegment(int)),
TQT_TQOBJECT(this), TQT_SIGNAL(editTriggerSegment(int)));
connect(selector, TQ_SIGNAL(editTriggerSegment(int)),
this, TQ_SIGNAL(editTriggerSegment(int)));
setTool(selector);
}
@ -1396,7 +1396,7 @@ void MatrixView::slotMousePressed(timeT time, int pitch,
m_tool->handleMousePress(time, pitch, 0, e, el);
if (e->button() != Qt::RightButton) {
if (e->button() != TQt::RightButton) {
getCanvasView()->startAutoScroll();
}
@ -1808,7 +1808,7 @@ void MatrixView::slotVerticalScrollPianoKeyboard(int y)
void MatrixView::slotInsertNoteFromAction()
{
const TQObject *s = TQT_TQOBJECT_CONST(const_cast<const TQT_BASE_OBJECT_NAME*>(sender()));
const TQObject *s = sender();
TQString name = s->name();
Segment &segment = *getCurrentSegment();
@ -2015,7 +2015,7 @@ MatrixView::slotSetSnapFromIndex(int s)
void
MatrixView::slotSetSnapFromAction()
{
const TQObject *s = TQT_TQOBJECT_CONST(const_cast<const TQT_BASE_OBJECT_NAME*>(sender()));
const TQObject *s = sender();
TQString name = s->name();
if (name.left(5) == "snap_") {
@ -2147,8 +2147,8 @@ MatrixView::initActionsToolbar()
}
}
connect(m_snapGridCombo, TQT_SIGNAL(activated(int)),
TQT_TQOBJECT(this), TQT_SLOT(slotSetSnapFromIndex(int)));
connect(m_snapGridCombo, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotSetSnapFromIndex(int)));
// Velocity combo. Not a spin box, because the spin box is too
// slow to use unless we make it typeable into, and then it takes
@ -2181,8 +2181,8 @@ MatrixView::initActionsToolbar()
m_quantizeCombo->insertItem(noMap, i18n("Off"));
connect(m_quantizeCombo, TQT_SIGNAL(activated(int)),
TQT_TQOBJECT(this), TQT_SLOT(slotQuantizeSelection(int)));
connect(m_quantizeCombo, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotQuantizeSelection(int)));
}
void
@ -2215,17 +2215,17 @@ MatrixView::initZoomToolbar()
}
m_hZoomSlider = new ZoomSlider<double>
(zoomSizes, -1, Qt::Horizontal, zoomToolbar, "tde toolbar widget");
(zoomSizes, -1, TQt::Horizontal, zoomToolbar, "tde toolbar widget");
m_hZoomSlider->setTracking(true);
m_hZoomSlider->setFocusPolicy(TQ_NoFocus);
m_hZoomSlider->setFocusPolicy(TQWidget::NoFocus);
m_zoomLabel = new TQLabel(zoomToolbar, "tde toolbar widget");
m_zoomLabel->setIndent(10);
m_zoomLabel->setFixedWidth(80);
connect(m_hZoomSlider,
TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotChangeHorizontalZoom(int)));
TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotChangeHorizontalZoom(int)));
}
@ -2919,7 +2919,7 @@ MatrixView::slotToggleStepByStep()
return ;
}
if (action->isChecked()) { // after toggling, that is
emit stepByStepTargetRequested(TQT_TQOBJECT(this));
emit stepByStepTargetRequested(this);
} else {
emit stepByStepTargetRequested(0);
}
@ -2946,7 +2946,7 @@ MatrixView::slotStepByStepTargetRequested(TQObject *obj)
MATRIX_DEBUG << "WARNING: No toggle_step_by_step action" << endl;
return ;
}
action->setChecked(TQT_BASE_OBJECT(obj) == TQT_BASE_OBJECT(this));
action->setChecked(obj == this);
}
void
@ -3023,20 +3023,20 @@ MatrixView::slotPercussionSetChanged(Instrument * newInstr)
TQObject::connect
(pitchRuler, TQT_SIGNAL(hoveredOverKeyChanged(unsigned int)),
TQT_TQOBJECT(this), TQT_SLOT (slotHoveredOverKeyChanged(unsigned int)));
(pitchRuler, TQ_SIGNAL(hoveredOverKeyChanged(unsigned int)),
this, TQ_SLOT (slotHoveredOverKeyChanged(unsigned int)));
TQObject::connect
(pitchRuler, TQT_SIGNAL(keyPressed(unsigned int, bool)),
TQT_TQOBJECT(this), TQT_SLOT (slotKeyPressed(unsigned int, bool)));
(pitchRuler, TQ_SIGNAL(keyPressed(unsigned int, bool)),
this, TQ_SLOT (slotKeyPressed(unsigned int, bool)));
TQObject::connect
(pitchRuler, TQT_SIGNAL(keySelected(unsigned int, bool)),
TQT_TQOBJECT(this), TQT_SLOT (slotKeySelected(unsigned int, bool)));
(pitchRuler, TQ_SIGNAL(keySelected(unsigned int, bool)),
this, TQ_SLOT (slotKeySelected(unsigned int, bool)));
TQObject::connect
(pitchRuler, TQT_SIGNAL(keyReleased(unsigned int, bool)),
TQT_TQOBJECT(this), TQT_SLOT (slotKeyReleased(unsigned int, bool)));
(pitchRuler, TQ_SIGNAL(keyReleased(unsigned int, bool)),
this, TQ_SLOT (slotKeyReleased(unsigned int, bool)));
// Replace the old pitchruler widget
m_pitchRuler = pitchRuler;

6
src/gui/editors/matrix/MatrixView.h
Unescape View File

@ -78,7 +78,7 @@ class LevelInfo;
*/
class MatrixView : public EditView
{
Q_OBJECT
TQ_OBJECT
friend class MatrixSelector;
@ -666,12 +666,12 @@ protected:
};
// Commented this out - was a MatrixView inner class, but we get a warning
// that Q_OBJECT can't be used in an inner class - gl
// that TQ_OBJECT can't be used in an inner class - gl
//
// class NoteSender : public TQObject
// {
// Q_OBJECT
// TQ_OBJECT
//
// public:

6
src/gui/editors/matrix/PianoKeyboard.cpp
Unescape View File

@ -256,7 +256,7 @@ void PianoKeyboard::mouseMoveEvent(TQMouseEvent* e)
}
}
if (e->state() & Qt::LeftButton) {
if (e->state() & TQt::LeftButton) {
if (m_selecting)
emit keySelected(e->y(), true);
else
@ -272,7 +272,7 @@ void PianoKeyboard::mousePressEvent(TQMouseEvent *e)
{
TQt::ButtonState bs = e->state();
if (e->button() == Qt::LeftButton) {
if (e->button() == TQt::LeftButton) {
m_mouseDown = true;
m_selecting = (bs & TQt::ShiftButton);
m_lastKeyPressed = e->y();
@ -286,7 +286,7 @@ void PianoKeyboard::mousePressEvent(TQMouseEvent *e)
void PianoKeyboard::mouseReleaseEvent(TQMouseEvent *e)
{
if (e->button() == Qt::LeftButton) {
if (e->button() == TQt::LeftButton) {
m_mouseDown = false;
m_selecting = false;
emit keyReleased(e->y(), false);

2
src/gui/editors/matrix/PianoKeyboard.h
Unescape View File

@ -41,7 +41,7 @@ namespace Rosegarden
class PianoKeyboard : public PitchRuler
{
Q_OBJECT
TQ_OBJECT
public:
PianoKeyboard(TQWidget *parent, int keys = 88);

2
src/gui/editors/matrix/QCanvasMatrixDiamond.cpp
Unescape View File

@ -50,7 +50,7 @@ TQPointArray QCanvasMatrixDiamond::areaPoints() const
int pw = (pen().width() + 1) / 2;
if ( pw < 1 )
pw = 1;
if ( pen() == Qt::NoPen )
if ( pen() == TQt::NoPen )
pw = 0;
pa[0] = TQPoint((int)x() - height() / 2 - pw, (int)y() - pw);
pa[1] = pa[0] + TQPoint(height() + pw * 2, 0);

6
src/gui/editors/notation/ClefInserter.cpp
Unescape View File

@ -49,18 +49,18 @@ ClefInserter::ClefInserter(NotationView* view)
TQIconSet icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("select")));
new TDEAction(i18n("Switch to Select Tool"), icon, 0, this,
TQT_SLOT(slotSelectSelected()), actionCollection(),
TQ_SLOT(slotSelectSelected()), actionCollection(),
"select");
new TDEAction(i18n("Switch to Erase Tool"), "eraser", 0, this,
TQT_SLOT(slotEraseSelected()), actionCollection(),
TQ_SLOT(slotEraseSelected()), actionCollection(),
"erase");
icon = TQIconSet
(NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("crotchet")));
new TDEAction(i18n("Switch to Inserting Notes"), icon, 0, this,
TQT_SLOT(slotNotesSelected()), actionCollection(),
TQ_SLOT(slotNotesSelected()), actionCollection(),
"notes");
createMenu("clefinserter.rc");

2
src/gui/editors/notation/ClefInserter.h
Unescape View File

@ -44,7 +44,7 @@ class NotationView;
*/
class ClefInserter : public NotationTool
{
Q_OBJECT
TQ_OBJECT
friend class NotationToolBox;

12
src/gui/editors/notation/FontViewFrame.cpp
Unescape View File

@ -73,7 +73,7 @@ FontViewFrame::loadFont()
{
#ifdef HAVE_XFT
if (m_tableFont) {
XftFontClose(TQT_TQPAINTDEVICE(this)->x11AppDisplay(), (XftFont *)m_tableFont);
XftFontClose(this->x11AppDisplay(), (XftFont *)m_tableFont);
}
m_tableFont = 0;
@ -108,7 +108,7 @@ FontViewFrame::loadFont()
m_fontName = (const char *)matchFamily;
}
m_tableFont = XftFontOpenPattern(TQT_TQPAINTDEVICE(this)->x11AppDisplay(), match);
m_tableFont = XftFontOpenPattern(this->x11AppDisplay(), match);
if (!m_tableFont) {
KMessageBox::error(this, i18n("Error: Unable to open best-match font %1").
@ -159,8 +159,8 @@ void FontViewFrame::paintEvent( TQPaintEvent* e )
TQColor rpositive(128, 128, 255);
Drawable drawable = (Drawable)handle();
XftDraw *draw = XftDrawCreate(TQT_TQPAINTDEVICE(this)->x11AppDisplay(), drawable,
(Visual *)TQT_TQPAINTDEVICE(this)->x11Visual(), TQT_TQPAINTDEVICE(this)->x11Colormap());
XftDraw *draw = XftDrawCreate(this->x11AppDisplay(), drawable,
(Visual *)this->x11Visual(), this->x11Colormap());
TQColor pen(TQt::black);
XftColor col;
@ -207,7 +207,7 @@ void FontViewFrame::paintEvent( TQPaintEvent* e )
XftDrawGlyphs(draw, &col, (XftFont *)m_tableFont, x, y, &ui, 1);
} else {
FcChar32 ch = m_row * 256 + (j - 1) * 16 + i - 1;
if (XftCharExists(TQT_TQPAINTDEVICE(this)->x11AppDisplay(), (XftFont *)m_tableFont, ch)) {
if (XftCharExists(this->x11AppDisplay(), (XftFont *)m_tableFont, ch)) {
XftDrawString32(draw, &col, (XftFont *)m_tableFont, x, y, &ch, 1);
}
}
@ -231,7 +231,7 @@ FontViewFrame::hasRow(int r) const
for (int c = 0; c < 256; ++c) {
FcChar32 ch = r * 256 + c;
if (XftCharExists(TQT_TQPAINTDEVICE_CONST(this)->x11AppDisplay(), (XftFont *)m_tableFont, ch)) {
if (XftCharExists(x11AppDisplay(), (XftFont *)m_tableFont, ch)) {
return true;
}
}

2
src/gui/editors/notation/FontViewFrame.h
Unescape View File

@ -39,7 +39,7 @@ namespace Rosegarden
class FontViewFrame : public TQFrame
{
Q_OBJECT
TQ_OBJECT
public:

6
src/gui/editors/notation/GuitarChordInserter.cpp
Unescape View File

@ -55,11 +55,11 @@ GuitarChordInserter::GuitarChordInserter(NotationView* view)
makeToolbarPixmap("select")));
new TDEAction(i18n("Switch to Select Tool"), icon, 0, this,
TQT_SLOT(slotSelectSelected()), actionCollection(),
TQ_SLOT(slotSelectSelected()), actionCollection(),
"select");
new TDEAction(i18n("Switch to Erase Tool"), "eraser", 0, this,
TQT_SLOT(slotEraseSelected()), actionCollection(),
TQ_SLOT(slotEraseSelected()), actionCollection(),
"erase");
icon = TQIconSet
@ -67,7 +67,7 @@ GuitarChordInserter::GuitarChordInserter(NotationView* view)
makeToolbarPixmap("crotchet")));
new TDEAction(i18n("Switch to Inserting Notes"), icon, 0, this,
TQT_SLOT(slotNoteSelected()), actionCollection(),
TQ_SLOT(slotNoteSelected()), actionCollection(),
"notes");
m_guitarChordSelector = new GuitarChordSelectorDialog(m_nParentView);

2
src/gui/editors/notation/GuitarChordInserter.h
Unescape View File

@ -44,7 +44,7 @@ class GuitarChordSelectorDialog;
*/
class GuitarChordInserter : public NotationTool
{
Q_OBJECT
TQ_OBJECT
friend class NotationToolBox;

2
src/gui/editors/notation/HeadersGroup.h
Unescape View File

@ -50,7 +50,7 @@ class TrackHeader;
class HeadersGroup : public TQVBox
{
Q_OBJECT
TQ_OBJECT
public:
/**

2
src/gui/editors/notation/NotationCanvasView.h
Unescape View File

@ -62,7 +62,7 @@ class LinedStaffManager;
class NotationCanvasView : public RosegardenCanvasView
{
Q_OBJECT
TQ_OBJECT
public:

6
src/gui/editors/notation/NotationEraser.cpp
Unescape View File

@ -50,20 +50,20 @@ NotationEraser::NotationEraser(NotationView* view)
m_collapseRest = config->readBoolEntry("collapse", false);
new TDEToggleAction(i18n("Collapse rests after erase"), 0, this,
TQT_SLOT(slotToggleRestCollapse()), actionCollection(),
TQ_SLOT(slotToggleRestCollapse()), actionCollection(),
"toggle_rest_collapse");
TQIconSet icon
(NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("crotchet")));
new TDEAction(i18n("Switch to Insert Tool"), icon, 0, this,
TQT_SLOT(slotInsertSelected()), actionCollection(),
TQ_SLOT(slotInsertSelected()), actionCollection(),
"insert");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("select")));
new TDEAction(i18n("Switch to Select Tool"), icon, 0, this,
TQT_SLOT(slotSelectSelected()), actionCollection(),
TQ_SLOT(slotSelectSelected()), actionCollection(),
"select");
createMenu("notationeraser.rc");

2
src/gui/editors/notation/NotationEraser.h
Unescape View File

@ -43,7 +43,7 @@ class NotationView;
*/
class NotationEraser : public NotationTool
{
Q_OBJECT
TQ_OBJECT
friend class NotationToolBox;

36
src/gui/editors/notation/NotationSelector.cpp
Unescape View File

@ -69,68 +69,68 @@ NotationSelector::NotationSelector(NotationView* view)
m_justSelectedBar(false),
m_wholeStaffSelectionComplete(false)
{
connect(m_parentView, TQT_SIGNAL(usedSelection()),
this, TQT_SLOT(slotHideSelection()));
connect(m_parentView, TQ_SIGNAL(usedSelection()),
this, TQ_SLOT(slotHideSelection()));
connect(this, TQT_SIGNAL(editElement(NotationStaff *, NotationElement *, bool)),
m_parentView, TQT_SLOT(slotEditElement(NotationStaff *, NotationElement *, bool)));
connect(this, TQ_SIGNAL(editElement(NotationStaff *, NotationElement *, bool)),
m_parentView, TQ_SLOT(slotEditElement(NotationStaff *, NotationElement *, bool)));
TQIconSet icon
(NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("crotchet")));
new TDEToggleAction(i18n("Switch to Insert Tool"), icon, 0, this,
TQT_SLOT(slotInsertSelected()), actionCollection(),
TQ_SLOT(slotInsertSelected()), actionCollection(),
"insert");
new TDEAction(i18n("Switch to Erase Tool"), "eraser", 0, this,
TQT_SLOT(slotEraseSelected()), actionCollection(),
TQ_SLOT(slotEraseSelected()), actionCollection(),
"erase");
// (this crashed, and it might be superfluous with ^N anyway, so I'm
// commenting it out, but leaving it here in case I change my mind about
// fooling with it.) (DMM)
// new TDEAction(i18n("Normalize Rests"), 0, 0, this,
// TQT_SLOT(slotCollapseRests()), actionCollection(),
// TQ_SLOT(slotCollapseRests()), actionCollection(),
// "collapse_rests");
new TDEAction(i18n("Collapse Rests"), 0, 0, this,
TQT_SLOT(slotCollapseRestsHard()), actionCollection(),
TQ_SLOT(slotCollapseRestsHard()), actionCollection(),
"collapse_rests_aggressively");
new TDEAction(i18n("Respell as Flat"), 0, 0, this,
TQT_SLOT(slotRespellFlat()), actionCollection(),
TQ_SLOT(slotRespellFlat()), actionCollection(),
"respell_flat");
new TDEAction(i18n("Respell as Sharp"), 0, 0, this,
TQT_SLOT(slotRespellSharp()), actionCollection(),
TQ_SLOT(slotRespellSharp()), actionCollection(),
"respell_sharp");
new TDEAction(i18n("Respell as Natural"), 0, 0, this,
TQT_SLOT(slotRespellNatural()), actionCollection(),
TQ_SLOT(slotRespellNatural()), actionCollection(),
"respell_natural");
new TDEAction(i18n("Collapse Notes"), 0, 0, this,
TQT_SLOT(slotCollapseNotes()), actionCollection(),
TQ_SLOT(slotCollapseNotes()), actionCollection(),
"collapse_notes");
new TDEAction(i18n("Interpret"), 0, 0, this,
TQT_SLOT(slotInterpret()), actionCollection(),
TQ_SLOT(slotInterpret()), actionCollection(),
"interpret");
new TDEAction(i18n("Move to Staff Above"), 0, 0, this,
TQT_SLOT(slotStaffAbove()), actionCollection(),
TQ_SLOT(slotStaffAbove()), actionCollection(),
"move_events_up_staff");
new TDEAction(i18n("Move to Staff Below"), 0, 0, this,
TQT_SLOT(slotStaffBelow()), actionCollection(),
TQ_SLOT(slotStaffBelow()), actionCollection(),
"move_events_down_staff");
new TDEAction(i18n("Make Invisible"), 0, 0, this,
TQT_SLOT(slotMakeInvisible()), actionCollection(),
TQ_SLOT(slotMakeInvisible()), actionCollection(),
"make_invisible");
new TDEAction(i18n("Make Visible"), 0, 0, this,
TQT_SLOT(slotMakeVisible()), actionCollection(),
TQ_SLOT(slotMakeVisible()), actionCollection(),
"make_visible");
createMenu("notationselector.rc");
@ -256,7 +256,7 @@ void NotationSelector::handleMouseDoubleClick(timeT,
m_justSelectedBar = true;
TQTimer::singleShot(TQApplication::doubleClickInterval(), this,
TQT_SLOT(slotClickTimeout()));
TQ_SLOT(slotClickTimeout()));
}
return ;

2
src/gui/editors/notation/NotationSelector.h
Unescape View File

@ -50,7 +50,7 @@ class Event;
*/
class NotationSelector : public NotationTool
{
Q_OBJECT
TQ_OBJECT
friend class NotationToolBox;

2
src/gui/editors/notation/NotationToolBox.h
Unescape View File

@ -43,7 +43,7 @@ class EditTool;
*/
class NotationToolBox : public EditToolBox
{
Q_OBJECT
TQ_OBJECT
public:
NotationToolBox(NotationView* parent);

848
src/gui/editors/notation/NotationView.cpp
View File

File diff suppressed because it is too large Load Diff

2
src/gui/editors/notation/NotationView.h
Unescape View File

@ -106,7 +106,7 @@ class NotationView : public EditView,
friend class NotationSelectionPaster;
friend class LilyPondExporter;
Q_OBJECT
TQ_OBJECT
public:

2
src/gui/editors/notation/NoteFont.cpp
Unescape View File

@ -202,7 +202,7 @@ NoteFont::lookupDrawRep(TQPixmap *pixmap) const
return 0;
if (image.depth() > 1) {
image = image.convertDepth(1, Qt::MonoOnly | Qt::ThresholdDither);
image = image.convertDepth(1, TQt::MonoOnly | TQt::ThresholdDither);
}
NoteCharacterDrawRep *a = new NoteCharacterDrawRep();

12
src/gui/editors/notation/NoteFontViewer.cpp
Unescape View File

@ -107,14 +107,14 @@ NoteFontViewer::NoteFontViewer(TQWidget *parent, TQString noteFontName,
m_frame = new FontViewFrame(pixelSize, box);
connect(m_font, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotFontChanged(const TQString &)));
connect(m_font, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotFontChanged(const TQString &)));
connect(m_view, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotViewChanged(int)));
connect(m_view, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotViewChanged(int)));
connect(m_rows, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotRowChanged(const TQString &)));
connect(m_rows, TQ_SIGNAL(activated(const TQString &)),
this, TQ_SLOT(slotRowChanged(const TQString &)));
slotFontChanged(m_font->currentText());
}

2
src/gui/editors/notation/NoteFontViewer.h
Unescape View File

@ -40,7 +40,7 @@ class FontViewFrame;
class NoteFontViewer : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

18
src/gui/editors/notation/NoteInserter.cpp
Unescape View File

@ -78,7 +78,7 @@ NoteInserter::NoteInserter(NotationView* view)
TDEToggleAction *autoBeamAction =
new TDEToggleAction(i18n("Auto-Beam when appropriate"), 0, this,
TQT_SLOT(slotToggleAutoBeam()), actionCollection(),
TQ_SLOT(slotToggleAutoBeam()), actionCollection(),
"toggle_auto_beam");
autoBeamAction->setChecked(m_autoBeam);
@ -99,30 +99,30 @@ NoteInserter::NoteInserter(NotationView* view)
(NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("dotted-crotchet")));
new TDEToggleAction(i18n("Dotted note"), icon, 0, this,
TQT_SLOT(slotToggleDot()), actionCollection(),
TQ_SLOT(slotToggleDot()), actionCollection(),
"toggle_dot");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("select")));
new TDEAction(i18n("Switch to Select Tool"), icon, 0, this,
TQT_SLOT(slotSelectSelected()), actionCollection(),
TQ_SLOT(slotSelectSelected()), actionCollection(),
"select");
new TDEAction(i18n("Switch to Erase Tool"), "eraser", 0, this,
TQT_SLOT(slotEraseSelected()), actionCollection(),
TQ_SLOT(slotEraseSelected()), actionCollection(),
"erase");
icon = TQIconSet
(NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("rest-crotchet")));
new TDEAction(i18n("Switch to Inserting Rests"), icon, 0, this,
TQT_SLOT(slotRestsSelected()), actionCollection(),
TQ_SLOT(slotRestsSelected()), actionCollection(),
"rests");
createMenu("noteinserter.rc");
connect(m_parentView, TQT_SIGNAL(changeAccidental(Accidental, bool)),
this, TQT_SLOT(slotSetAccidental(Accidental, bool)));
connect(m_parentView, TQ_SIGNAL(changeAccidental(Accidental, bool)),
this, TQ_SLOT(slotSetAccidental(Accidental, bool)));
}
NoteInserter::NoteInserter(const TQString& menuName, NotationView* view)
@ -135,8 +135,8 @@ NoteInserter::NoteInserter(const TQString& menuName, NotationView* view)
m_lastAccidental(Accidentals::NoAccidental),
m_followAccidental(false)
{
connect(m_parentView, TQT_SIGNAL(changeAccidental(Accidental, bool)),
this, TQT_SLOT(slotSetAccidental(Accidental, bool)));
connect(m_parentView, TQ_SIGNAL(changeAccidental(Accidental, bool)),
this, TQ_SLOT(slotSetAccidental(Accidental, bool)));
}
NoteInserter::~NoteInserter()

2
src/gui/editors/notation/NoteInserter.h
Unescape View File

@ -48,7 +48,7 @@ class Event;
*/
class NoteInserter : public NotationTool
{
Q_OBJECT
TQ_OBJECT
friend class NotationToolBox;

6
src/gui/editors/notation/NotePixmapFactory.cpp
Unescape View File

@ -1255,7 +1255,7 @@ NotePixmapFactory::drawFlags(int flagCount,
y,
*flagChar.getPixmap());
m_p->begin(TQT_TQPAINTDEVICE(m_generatedPixmap), TQT_TQPAINTDEVICE(m_generatedMask));
m_p->begin(m_generatedPixmap, m_generatedMask);
} else {
@ -2921,7 +2921,7 @@ NotePixmapFactory::drawOttavaAux(int length, int octavesUp,
m_p->drawLine(x0, y0, x1, y0);
pen.setStyle(Qt::SolidLine);
pen.setStyle(TQt::SolidLine);
m_p->painter().setPen(pen);
// if (!m_inPrinterMethod) m_p->maskPainter().setPen(pen);
@ -3446,7 +3446,7 @@ NotePixmapFactory::createPixmapAndMask(int width, int height,
m_generatedMask->fill(TQt::color0);
// initiate painting
m_p->begin(TQT_TQPAINTDEVICE(m_generatedPixmap), TQT_TQPAINTDEVICE(m_generatedMask));
m_p->begin(m_generatedPixmap, m_generatedMask);
m_p->painter().setPen(TQt::black);
m_p->painter().setBrush(TQt::black);

4
src/gui/editors/notation/NotePixmapPainter.h
Unescape View File

@ -42,8 +42,8 @@ public:
m_externalPainter = painter;
m_useMask = false;
painter->setPen(TQPen(Qt::black, 1, Qt::SolidLine,
Qt::RoundCap, Qt::RoundJoin));
painter->setPen(TQPen(TQt::black, 1, TQt::SolidLine,
TQt::RoundCap, TQt::RoundJoin));
if (m_externalPainter) {
m_painter = m_externalPainter;

8
src/gui/editors/notation/RestInserter.cpp
Unescape View File

@ -58,24 +58,24 @@ RestInserter::RestInserter(NotationView* view)
(NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("dotted-rest-crotchet")));
new TDEToggleAction(i18n("Dotted rest"), icon, 0, this,
TQT_SLOT(slotToggleDot()), actionCollection(),
TQ_SLOT(slotToggleDot()), actionCollection(),
"toggle_dot");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("select")));
new TDEAction(i18n("Switch to Select Tool"), icon, 0, this,
TQT_SLOT(slotSelectSelected()), actionCollection(),
TQ_SLOT(slotSelectSelected()), actionCollection(),
"select");
new TDEAction(i18n("Switch to Erase Tool"), "eraser", 0, this,
TQT_SLOT(slotEraseSelected()), actionCollection(),
TQ_SLOT(slotEraseSelected()), actionCollection(),
"erase");
icon = TQIconSet
(NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("crotchet")));
new TDEAction(i18n("Switch to Inserting Notes"), icon, 0, this,
TQT_SLOT(slotNotesSelected()), actionCollection(),
TQ_SLOT(slotNotesSelected()), actionCollection(),
"notes");
createMenu("restinserter.rc");

2
src/gui/editors/notation/RestInserter.h
Unescape View File

@ -44,7 +44,7 @@ class Event;
*/
class RestInserter : public NoteInserter
{
Q_OBJECT
TQ_OBJECT
friend class NotationToolBox;

6
src/gui/editors/notation/TextInserter.cpp
Unescape View File

@ -53,18 +53,18 @@ TextInserter::TextInserter(NotationView* view)
TQIconSet icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("select")));
new TDEAction(i18n("Switch to Select Tool"), icon, 0, this,
TQT_SLOT(slotSelectSelected()), actionCollection(),
TQ_SLOT(slotSelectSelected()), actionCollection(),
"select");
new TDEAction(i18n("Switch to Erase Tool"), "eraser", 0, this,
TQT_SLOT(slotEraseSelected()), actionCollection(),
TQ_SLOT(slotEraseSelected()), actionCollection(),
"erase");
icon = TQIconSet
(NotePixmapFactory::toTQPixmap(NotePixmapFactory::
makeToolbarPixmap("crotchet")));
new TDEAction(i18n("Switch to Inserting Notes"), icon, 0, this,
TQT_SLOT(slotNotesSelected()), actionCollection(),
TQ_SLOT(slotNotesSelected()), actionCollection(),
"notes");
createMenu("textinserter.rc");

2
src/gui/editors/notation/TextInserter.h
Unescape View File

@ -44,7 +44,7 @@ class NotationView;
*/
class TextInserter : public NotationTool
{
Q_OBJECT
TQ_OBJECT
friend class NotationToolBox;

2
src/gui/editors/notation/TrackHeader.cpp
Unescape View File

@ -272,7 +272,7 @@ TrackHeader::lookAtStaff(double x, int maxWidth)
int staff;
Composition *comp =
static_cast<HeadersGroup *>(TQT_TQWIDGET(parent()))->getComposition();
static_cast<HeadersGroup *>(parent())->getComposition();
Track *track = comp->getTrackById(m_track);
int trackPos = comp->getTrackPositionById(m_track);

2
src/gui/editors/notation/TrackHeader.h
Unescape View File

@ -49,7 +49,7 @@ class Segment;
class TrackHeader : public TQLabel
{
Q_OBJECT
TQ_OBJECT
public:
/**

36
src/gui/editors/parameters/AudioInstrumentParameterPanel.cpp
Unescape View File

@ -254,32 +254,32 @@ AudioInstrumentParameterPanel::AudioInstrumentParameterPanel(RosegardenGUIDoc* d
gridLayout->setRowStretch(2, 1);
connect(m_audioFader, TQT_SIGNAL(audioChannelsChanged(int)),
this, TQT_SLOT(slotAudioChannels(int)));
connect(m_audioFader, TQ_SIGNAL(audioChannelsChanged(int)),
this, TQ_SLOT(slotAudioChannels(int)));
connect(m_audioFader->m_signalMapper, TQT_SIGNAL(mapped(int)),
this, TQT_SLOT(slotSelectPlugin(int)));
connect(m_audioFader->m_signalMapper, TQ_SIGNAL(mapped(int)),
this, TQ_SLOT(slotSelectPlugin(int)));
connect(m_audioFader->m_fader, TQT_SIGNAL(faderChanged(float)),
this, TQT_SLOT(slotSelectAudioLevel(float)));
connect(m_audioFader->m_fader, TQ_SIGNAL(faderChanged(float)),
this, TQ_SLOT(slotSelectAudioLevel(float)));
connect(m_audioFader->m_recordFader, TQT_SIGNAL(faderChanged(float)),
this, TQT_SLOT(slotSelectAudioRecordLevel(float)));
connect(m_audioFader->m_recordFader, TQ_SIGNAL(faderChanged(float)),
this, TQ_SLOT(slotSelectAudioRecordLevel(float)));
connect(m_audioFader->m_pan, TQT_SIGNAL(valueChanged(float)),
this, TQT_SLOT(slotSetPan(float)));
connect(m_audioFader->m_pan, TQ_SIGNAL(valueChanged(float)),
this, TQ_SLOT(slotSetPan(float)));
connect(m_audioFader->m_audioOutput, TQT_SIGNAL(changed()),
this, TQT_SLOT(slotAudioRoutingChanged()));
connect(m_audioFader->m_audioOutput, TQ_SIGNAL(changed()),
this, TQ_SLOT(slotAudioRoutingChanged()));
connect(m_audioFader->m_audioInput, TQT_SIGNAL(changed()),
this, TQT_SLOT(slotAudioRoutingChanged()));
connect(m_audioFader->m_audioInput, TQ_SIGNAL(changed()),
this, TQ_SLOT(slotAudioRoutingChanged()));
connect(m_audioFader->m_synthButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotSynthButtonClicked()));
connect(m_audioFader->m_synthButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotSynthButtonClicked()));
connect(m_audioFader->m_synthGUIButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotSynthGUIButtonClicked()));
connect(m_audioFader->m_synthGUIButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotSynthGUIButtonClicked()));
}
void

2
src/gui/editors/parameters/AudioInstrumentParameterPanel.h
Unescape View File

@ -43,7 +43,7 @@ class AudioFaderBox;
class AudioInstrumentParameterPanel : public InstrumentParameterPanel
{
Q_OBJECT
TQ_OBJECT
public:
AudioInstrumentParameterPanel(RosegardenGUIDoc* doc, TQWidget* parent);

32
src/gui/editors/parameters/InstrumentParameterBox.cpp
Unescape View File

@ -84,39 +84,39 @@ InstrumentParameterBox::InstrumentParameterBox(RosegardenGUIDoc *doc,
m_audioInstrumentParameters->adjustSize();
m_noInstrumentParameters->adjustSize();
connect(m_audioInstrumentParameters, TQT_SIGNAL(updateAllBoxes()),
this, TQT_SLOT(slotUpdateAllBoxes()));
connect(m_audioInstrumentParameters, TQ_SIGNAL(updateAllBoxes()),
this, TQ_SLOT(slotUpdateAllBoxes()));
connect(m_audioInstrumentParameters,
TQT_SIGNAL(instrumentParametersChanged(InstrumentId)),
TQ_SIGNAL(instrumentParametersChanged(InstrumentId)),
this,
TQT_SIGNAL(instrumentParametersChanged(InstrumentId)));
TQ_SIGNAL(instrumentParametersChanged(InstrumentId)));
connect(m_audioInstrumentParameters,
TQT_SIGNAL(selectPlugin(TQWidget *, InstrumentId, int)),
TQ_SIGNAL(selectPlugin(TQWidget *, InstrumentId, int)),
this,
TQT_SIGNAL(selectPlugin(TQWidget *, InstrumentId, int)));
TQ_SIGNAL(selectPlugin(TQWidget *, InstrumentId, int)));
connect(m_audioInstrumentParameters,
TQT_SIGNAL(showPluginGUI(InstrumentId, int)),
TQ_SIGNAL(showPluginGUI(InstrumentId, int)),
this,
TQT_SIGNAL(showPluginGUI(InstrumentId, int)));
TQ_SIGNAL(showPluginGUI(InstrumentId, int)));
connect(m_midiInstrumentParameters, TQT_SIGNAL(updateAllBoxes()),
this, TQT_SLOT(slotUpdateAllBoxes()));
connect(m_midiInstrumentParameters, TQ_SIGNAL(updateAllBoxes()),
this, TQ_SLOT(slotUpdateAllBoxes()));
connect(m_midiInstrumentParameters,
TQT_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)),
this, TQT_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)));
TQ_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)),
this, TQ_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)));
connect(m_audioInstrumentParameters,
TQT_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)),
this, TQT_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)));
TQ_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)),
this, TQ_SIGNAL(changeInstrumentLabel(InstrumentId, TQString)));
connect(m_midiInstrumentParameters,
TQT_SIGNAL(instrumentParametersChanged(InstrumentId)),
TQ_SIGNAL(instrumentParametersChanged(InstrumentId)),
this,
TQT_SIGNAL(instrumentParametersChanged(InstrumentId)));
TQ_SIGNAL(instrumentParametersChanged(InstrumentId)));
// Layout the groups left to right.

2
src/gui/editors/parameters/InstrumentParameterBox.h
Unescape View File

@ -49,7 +49,7 @@ class AudioInstrumentParameterPanel;
*/
class InstrumentParameterBox : public RosegardenParameterBox
{
Q_OBJECT
TQ_OBJECT
public:

2
src/gui/editors/parameters/InstrumentParameterPanel.h
Unescape View File

@ -46,7 +46,7 @@ typedef std::vector<std::pair<int, RotaryPair> > RotaryMap;
class InstrumentParameterPanel : public TQFrame
{
Q_OBJECT
TQ_OBJECT
public:
InstrumentParameterPanel(RosegardenGUIDoc *doc, TQWidget* parent);

44
src/gui/editors/parameters/MIDIInstrumentParameterPanel.cpp
Unescape View File

@ -61,7 +61,7 @@ namespace Rosegarden
MIDIInstrumentParameterPanel::MIDIInstrumentParameterPanel(RosegardenGUIDoc *doc, TQWidget* parent):
InstrumentParameterPanel(doc, parent),
m_rotaryFrame(0),
m_rotaryMapper(new TQSignalMapper(TQT_TQOBJECT(this)))
m_rotaryMapper(new TQSignalMapper(this))
{
m_mainGrid = new TQGridLayout(this, 10, 3, 2, 1);
@ -150,32 +150,32 @@ MIDIInstrumentParameterPanel::MIDIInstrumentParameterPanel(RosegardenGUIDoc *doc
// Connect up the toggle boxes
//
connect(m_percussionCheckBox, TQT_SIGNAL(toggled(bool)),
this, TQT_SLOT(slotTogglePercussion(bool)));
connect(m_percussionCheckBox, TQ_SIGNAL(toggled(bool)),
this, TQ_SLOT(slotTogglePercussion(bool)));
connect(m_programCheckBox, TQT_SIGNAL(toggled(bool)),
this, TQT_SLOT(slotToggleProgramChange(bool)));
connect(m_programCheckBox, TQ_SIGNAL(toggled(bool)),
this, TQ_SLOT(slotToggleProgramChange(bool)));
connect(m_bankCheckBox, TQT_SIGNAL(toggled(bool)),
this, TQT_SLOT(slotToggleBank(bool)));
connect(m_bankCheckBox, TQ_SIGNAL(toggled(bool)),
this, TQ_SLOT(slotToggleBank(bool)));
connect(m_variationCheckBox, TQT_SIGNAL(toggled(bool)),
this, TQT_SLOT(slotToggleVariation(bool)));
connect(m_variationCheckBox, TQ_SIGNAL(toggled(bool)),
this, TQ_SLOT(slotToggleVariation(bool)));
// Connect activations
//
connect(m_bankValue, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotSelectBank(int)));
connect(m_bankValue, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotSelectBank(int)));
connect(m_variationValue, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotSelectVariation(int)));
connect(m_variationValue, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotSelectVariation(int)));
connect(m_programValue, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotSelectProgram(int)));
connect(m_programValue, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotSelectProgram(int)));
connect(m_channelValue, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotSelectChannel(int)));
connect(m_channelValue, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotSelectChannel(int)));
// don't select any of the options in any dropdown
m_programValue->setCurrentItem( -1);
@ -183,8 +183,8 @@ MIDIInstrumentParameterPanel::MIDIInstrumentParameterPanel(RosegardenGUIDoc *doc
m_channelValue->setCurrentItem( -1);
m_variationValue->setCurrentItem( -1);
connect(m_rotaryMapper, TQT_SIGNAL(mapped(int)),
this, TQT_SLOT(slotControllerChanged(int)));
connect(m_rotaryMapper, TQ_SIGNAL(mapped(int)),
this, TQ_SLOT(slotControllerChanged(int)));
}
void
@ -415,15 +415,15 @@ MIDIInstrumentParameterPanel::setupControllers(MidiDevice *md)
// Connect
//
connect(rotary, TQT_SIGNAL(valueChanged(float)),
m_rotaryMapper, TQT_SLOT(map()));
connect(rotary, TQ_SIGNAL(valueChanged(float)),
m_rotaryMapper, TQ_SLOT(map()));
rmi = m_rotaries.end();
}
// Add signal mapping
//
m_rotaryMapper->setMapping(TQT_TQOBJECT(rotary),
m_rotaryMapper->setMapping(rotary,
int(it->getControllerValue()));
count++;

2
src/gui/editors/parameters/MIDIInstrumentParameterPanel.h
Unescape View File

@ -48,7 +48,7 @@ class Instrument;
class MIDIInstrumentParameterPanel : public InstrumentParameterPanel
{
Q_OBJECT
TQ_OBJECT
public:

2
src/gui/editors/parameters/RosegardenParameterArea.h
Unescape View File

@ -48,7 +48,7 @@ class RosegardenParameterBox;
*/
class RosegardenParameterArea : public TQWidgetStack
{
Q_OBJECT
TQ_OBJECT
public:

2
src/gui/editors/parameters/RosegardenParameterBox.h
Unescape View File

@ -47,7 +47,7 @@ namespace Rosegarden
class RosegardenParameterBox : public TQFrame
{
Q_OBJECT
TQ_OBJECT
public:
RosegardenParameterBox(const TQString &shortLabel, // e.g. i18n("Track")

66
src/gui/editors/parameters/SegmentParameterBox.cpp
Unescape View File

@ -96,8 +96,8 @@ SegmentParameterBox::SegmentParameterBox(RosegardenGUIDoc* doc,
m_doc->getComposition().addObserver(this);
connect(getCommandHistory(), TQT_SIGNAL(commandExecuted()),
this, TQT_SLOT(update()));
connect(getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQ_SLOT(update()));
}
SegmentParameterBox::~SegmentParameterBox()
@ -143,15 +143,15 @@ SegmentParameterBox::initBox()
m_labelButton->setFont(font);
// m_labelButton->setFixedWidth(50);
connect(m_labelButton, TQT_SIGNAL(released()),
TQT_SLOT(slotEditSegmentLabel()));
connect(m_labelButton, TQ_SIGNAL(released()),
TQ_SLOT(slotEditSegmentLabel()));
m_repeatValue = new TristateCheckBox(this);
m_repeatValue->setFont(font);
//m_repeatValue->setFixedHeight(comboHeight);
// handle state changes
connect(m_repeatValue, TQT_SIGNAL(pressed()), TQT_SLOT(slotRepeatPressed()));
connect(m_repeatValue, TQ_SIGNAL(pressed()), TQ_SLOT(slotRepeatPressed()));
// non-reversing motif style read-only combo
m_quantizeValue = new KComboBox(this);
@ -159,8 +159,8 @@ SegmentParameterBox::initBox()
//m_quantizeValue->setFixedHeight(comboHeight);
// handle quantize changes from drop down
connect(m_quantizeValue, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotQuantizeSelected(int)));
connect(m_quantizeValue, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotQuantizeSelected(int)));
// reversing motif style read-write combo
m_transposeValue = new KComboBox(this);
@ -168,12 +168,12 @@ SegmentParameterBox::initBox()
//m_transposeValue->setFixedHeight(comboHeight);
// handle transpose combo changes
connect(m_transposeValue, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotTransposeSelected(int)));
connect(m_transposeValue, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotTransposeSelected(int)));
// and text changes
connect(m_transposeValue, TQT_SIGNAL(textChanged(const TQString&)),
TQT_SLOT(slotTransposeTextChanged(const TQString&)));
connect(m_transposeValue, TQ_SIGNAL(textChanged(const TQString&)),
TQ_SLOT(slotTransposeTextChanged(const TQString&)));
// reversing motif style read-write combo
m_delayValue = new KComboBox(this);
@ -181,16 +181,16 @@ SegmentParameterBox::initBox()
//m_delayValue->setFixedHeight(comboHeight);
// handle delay combo changes
connect(m_delayValue, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotDelaySelected(int)));
connect(m_delayValue, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotDelaySelected(int)));
// Detect when the document colours are updated
connect(m_doc, TQT_SIGNAL(docColoursChanged()),
this, TQT_SLOT(slotDocColoursChanged()));
connect(m_doc, TQ_SIGNAL(docColoursChanged()),
this, TQ_SLOT(slotDocColoursChanged()));
// handle text changes for delay
connect(m_delayValue, TQT_SIGNAL(textChanged(const TQString&)),
TQT_SLOT(slotDelayTextChanged(const TQString &)));
connect(m_delayValue, TQ_SIGNAL(textChanged(const TQString&)),
TQ_SLOT(slotDelayTextChanged(const TQString &)));
// set up combo box for colours
m_colourValue = new KComboBox(false, this);
@ -200,8 +200,8 @@ SegmentParameterBox::initBox()
m_colourValue->setSizeLimit(20);
// handle colour combo changes
connect(m_colourValue, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotColourSelected(int)));
connect(m_colourValue, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotColourSelected(int)));
// pre-set width of buttons so they don't grow later
// width = fontMetrics.width(i18n("used internally for spacing", "High: ----"));
@ -214,8 +214,8 @@ SegmentParameterBox::initBox()
// m_highButton->setFont(font);
// m_highButton->setMinimumWidth(width);
// connect(m_highButton, TQT_SIGNAL(released()),
// TQT_SLOT(slotHighestPressed()));
// connect(m_highButton, TQ_SIGNAL(released()),
// TQ_SLOT(slotHighestPressed()));
// lowest playable note
//
@ -225,14 +225,14 @@ SegmentParameterBox::initBox()
// m_lowButton->setFont(font);
// m_lowButton->setMinimumWidth(width);
// connect(m_lowButton, TQT_SIGNAL(released()),
// TQT_SLOT(slotLowestPressed()));
// connect(m_lowButton, TQ_SIGNAL(released()),
// TQ_SLOT(slotLowestPressed()));
// Audio autofade enabled
//
// m_autoFadeBox = new TQCheckBox(this);
// connect(m_autoFadeBox, TQT_SIGNAL(stateChanged(int)),
// this, TQT_SLOT(slotAudioFadeChanged(int)));
// connect(m_autoFadeBox, TQ_SIGNAL(stateChanged(int)),
// this, TQ_SLOT(slotAudioFadeChanged(int)));
// Fade in and out times
//
@ -240,15 +240,15 @@ SegmentParameterBox::initBox()
// m_fadeInSpin->setMinValue(0);
// m_fadeInSpin->setMaxValue(5000);
// m_fadeInSpin->setSuffix(i18n(" ms"));
// connect(m_fadeInSpin, TQT_SIGNAL(valueChanged(int)),
// this, TQT_SLOT(slotFadeInChanged(int)));
// connect(m_fadeInSpin, TQ_SIGNAL(valueChanged(int)),
// this, TQ_SLOT(slotFadeInChanged(int)));
// m_fadeOutSpin = new TQSpinBox(this);
// m_fadeOutSpin->setMinValue(0);
// m_fadeOutSpin->setMaxValue(5000);
// m_fadeOutSpin->setSuffix(i18n(" ms"));
// connect(m_fadeOutSpin, TQT_SIGNAL(valueChanged(int)),
// this, TQT_SLOT(slotFadeOutChanged(int)));
// connect(m_fadeOutSpin, TQ_SIGNAL(valueChanged(int)),
// this, TQ_SLOT(slotFadeOutChanged(int)));
label->setFont(font);
repeatLabel->setFont(font);
@ -382,14 +382,14 @@ void
SegmentParameterBox::setDocument(RosegardenGUIDoc* doc)
{
if (m_doc != 0)
disconnect(m_doc, TQT_SIGNAL(docColoursChanged()),
this, TQT_SLOT(slotDocColoursChanged()));
disconnect(m_doc, TQ_SIGNAL(docColoursChanged()),
this, TQ_SLOT(slotDocColoursChanged()));
m_doc = doc;
// Detect when the document colours are updated
connect (m_doc, TQT_SIGNAL(docColoursChanged()),
this, TQT_SLOT(slotDocColoursChanged()));
connect (m_doc, TQ_SIGNAL(docColoursChanged()),
this, TQ_SLOT(slotDocColoursChanged()));
slotDocColoursChanged(); // repopulate combo
}

2
src/gui/editors/parameters/SegmentParameterBox.h
Unescape View File

@ -56,7 +56,7 @@ class Composition;
class SegmentParameterBox : public RosegardenParameterBox,
public CompositionObserver
{
Q_OBJECT
TQ_OBJECT
public:

52
src/gui/editors/parameters/TrackParameterBox.cpp
Unescape View File

@ -304,8 +304,8 @@ TrackParameterBox::TrackParameterBox( RosegardenGUIDoc *doc,
groupLayout->addMultiCellWidget(m_transpLbl, row, row, 3, 4, AlignRight);
m_defTranspose = new KComboBox(m_defaultsGroup);
connect(m_defTranspose, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotTransposeIndexChanged(int)));
connect(m_defTranspose, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotTransposeIndexChanged(int)));
int transposeRange = 48;
for (int i = -transposeRange; i < transposeRange + 1; i++) {
@ -359,43 +359,43 @@ TrackParameterBox::TrackParameterBox( RosegardenGUIDoc *doc,
mainLayout->setRowStretch(mainLayout->numRows() - 1, 1);
// Connections
connect( m_playDevice, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotPlaybackDeviceChanged(int)));
connect( m_playDevice, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotPlaybackDeviceChanged(int)));
connect( m_instrument, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotInstrumentChanged(int)));
connect( m_instrument, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotInstrumentChanged(int)));
connect( m_recDevice, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotRecordingDeviceChanged(int)));
connect( m_recDevice, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotRecordingDeviceChanged(int)));
connect( m_recChannel, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotRecordingChannelChanged(int)));
connect( m_recChannel, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotRecordingChannelChanged(int)));
connect( m_defClef, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotClefChanged(int)));
connect( m_defClef, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotClefChanged(int)));
// Detect when the document colours are updated
connect(m_doc, TQT_SIGNAL(docColoursChanged()),
this, TQT_SLOT(slotDocColoursChanged()));
connect(m_doc, TQ_SIGNAL(docColoursChanged()),
this, TQ_SLOT(slotDocColoursChanged()));
// handle colour combo changes
connect(m_defColor, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotColorChanged(int)));
connect(m_defColor, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotColorChanged(int)));
connect(m_highButton, TQT_SIGNAL(released()),
TQT_SLOT(slotHighestPressed()));
connect(m_highButton, TQ_SIGNAL(released()),
TQ_SLOT(slotHighestPressed()));
connect(m_lowButton, TQT_SIGNAL(released()),
TQT_SLOT(slotLowestPressed()));
connect(m_lowButton, TQ_SIGNAL(released()),
TQ_SLOT(slotLowestPressed()));
connect(m_presetButton, TQT_SIGNAL(released()),
TQT_SLOT(slotPresetPressed()));
connect(m_presetButton, TQ_SIGNAL(released()),
TQ_SLOT(slotPresetPressed()));
connect(m_staffSizeCombo, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotStaffSizeChanged(int)));
connect(m_staffSizeCombo, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotStaffSizeChanged(int)));
connect(m_staffBracketCombo, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotStaffBracketChanged(int)));
connect(m_staffBracketCombo, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotStaffBracketChanged(int)));
}
TrackParameterBox::~TrackParameterBox()

2
src/gui/editors/parameters/TrackParameterBox.h
Unescape View File

@ -54,7 +54,7 @@ class RosegardenGUIDoc;
class TrackParameterBox : public RosegardenParameterBox
{
Q_OBJECT
TQ_OBJECT
public:

22
src/gui/editors/segment/ControlEditorDialog.cpp
Unescape View File

@ -149,20 +149,20 @@ ControlEditorDialog::ControlEditorDialog(TQWidget *parent,
layout->addWidget(m_closeButton);
layout->addSpacing(5);
connect(m_addButton, TQT_SIGNAL(released()),
TQT_SLOT(slotAdd()));
connect(m_addButton, TQ_SIGNAL(released()),
TQ_SLOT(slotAdd()));
connect(m_deleteButton, TQT_SIGNAL(released()),
TQT_SLOT(slotDelete()));
connect(m_deleteButton, TQ_SIGNAL(released()),
TQ_SLOT(slotDelete()));
setupActions();
m_doc->getCommandHistory()->attachView(actionCollection());
connect(m_doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()),
this, TQT_SLOT(slotUpdate()));
connect(m_doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQ_SLOT(slotUpdate()));
connect(m_listView, TQT_SIGNAL(doubleClicked(TQListViewItem *)),
TQT_SLOT(slotEdit(TQListViewItem *)));
connect(m_listView, TQ_SIGNAL(doubleClicked(TQListViewItem *)),
TQ_SLOT(slotEdit(TQListViewItem *)));
// Highlight all columns - enable extended selection mode
//
@ -335,12 +335,12 @@ ControlEditorDialog::slotClose()
void
ControlEditorDialog::setupActions()
{
TDEAction* close = KStdAction::close(TQT_TQOBJECT(this),
TQT_SLOT(slotClose()),
TDEAction* close = KStdAction::close(this,
TQ_SLOT(slotClose()),
actionCollection());
m_closeButton->setText(close->text());
connect(m_closeButton, TQT_SIGNAL(released()), this, TQT_SLOT(slotClose()));
connect(m_closeButton, TQ_SIGNAL(released()), this, TQ_SLOT(slotClose()));
// some adjustments
new TDEToolBarPopupAction(i18n("Und&o"),

2
src/gui/editors/segment/ControlEditorDialog.h
Unescape View File

@ -46,7 +46,7 @@ class MultiViewCommandHistory;
class ControlEditorDialog : public TDEMainWindow
{
Q_OBJECT
TQ_OBJECT
public:

38
src/gui/editors/segment/ControlParameterEditDialog.cpp
Unescape View File

@ -66,7 +66,7 @@ ControlParameterEditDialog::ControlParameterEditDialog(
TQVBox *vbox = makeVBoxMainWidget();
TQGroupBox *groupBox = new TQGroupBox
(1, Qt::Horizontal, i18n("Control Event Properties"), vbox);
(1, TQt::Horizontal, i18n("Control Event Properties"), vbox);
TQFrame *frame = new TQFrame(groupBox);
@ -112,32 +112,32 @@ ControlParameterEditDialog::ControlParameterEditDialog(
m_ipbPosition = new KComboBox(frame);
layout->addMultiCellWidget(m_ipbPosition, 8, 8, 1, 2);
connect(m_nameEdit, TQT_SIGNAL(textChanged(const TQString&)),
TQT_SLOT(slotNameChanged(const TQString&)));
connect(m_nameEdit, TQ_SIGNAL(textChanged(const TQString&)),
TQ_SLOT(slotNameChanged(const TQString&)));
connect(m_typeCombo, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotTypeChanged(int)));
connect(m_typeCombo, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotTypeChanged(int)));
connect(m_description, TQT_SIGNAL(textChanged(const TQString&)),
TQT_SLOT(slotDescriptionChanged(const TQString &)));
connect(m_description, TQ_SIGNAL(textChanged(const TQString&)),
TQ_SLOT(slotDescriptionChanged(const TQString &)));
connect(m_controllerBox, TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotControllerChanged(int)));
connect(m_controllerBox, TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotControllerChanged(int)));
connect(m_minBox, TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotMinChanged(int)));
connect(m_minBox, TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotMinChanged(int)));
connect(m_maxBox, TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotMaxChanged(int)));
connect(m_maxBox, TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotMaxChanged(int)));
connect(m_defaultBox, TQT_SIGNAL(valueChanged(int)),
TQT_SLOT(slotDefaultChanged(int)));
connect(m_defaultBox, TQ_SIGNAL(valueChanged(int)),
TQ_SLOT(slotDefaultChanged(int)));
connect(m_colourCombo, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotColourChanged(int)));
connect(m_colourCombo, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotColourChanged(int)));
connect(m_ipbPosition, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotIPBPositionChanged(int)));
connect(m_ipbPosition, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotIPBPositionChanged(int)));
//m_nameEdit->selectAll();
//m_description->selectAll();

2
src/gui/editors/segment/ControlParameterEditDialog.h
Unescape View File

@ -43,7 +43,7 @@ class RosegardenGUIDoc;
class ControlParameterEditDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:
ControlParameterEditDialog(TQWidget *parent,

48
src/gui/editors/segment/MarkerEditor.cpp
Unescape View File

@ -89,7 +89,7 @@ MarkerEditor::MarkerEditor(TQWidget *parent,
for (int i = 0; i < 3; ++i)
m_listView->setColumnAlignment(i, TQt::AlignHCenter);
TQGroupBox *posGroup = new TQGroupBox(2, Qt::Horizontal,
TQGroupBox *posGroup = new TQGroupBox(2, TQt::Horizontal,
i18n("Pointer position"), mainFrame);
new TQLabel(i18n("Absolute time:"), posGroup);
@ -139,29 +139,29 @@ MarkerEditor::MarkerEditor(TQWidget *parent,
layout->addWidget(m_closeButton);
layout->addSpacing(5);
connect(m_addButton, TQT_SIGNAL(released()),
TQT_SLOT(slotAdd()));
connect(m_addButton, TQ_SIGNAL(released()),
TQ_SLOT(slotAdd()));
connect(m_deleteButton, TQT_SIGNAL(released()),
TQT_SLOT(slotDelete()));
connect(m_deleteButton, TQ_SIGNAL(released()),
TQ_SLOT(slotDelete()));
connect(m_closeButton, TQT_SIGNAL(released()),
TQT_SLOT(slotClose()));
connect(m_closeButton, TQ_SIGNAL(released()),
TQ_SLOT(slotClose()));
connect(m_deleteAllButton, TQT_SIGNAL(released()),
TQT_SLOT(slotDeleteAll()));
connect(m_deleteAllButton, TQ_SIGNAL(released()),
TQ_SLOT(slotDeleteAll()));
setupActions();
m_doc->getCommandHistory()->attachView(actionCollection());
connect(m_doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()),
this, TQT_SLOT(slotUpdate()));
connect(m_doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQ_SLOT(slotUpdate()));
connect(m_listView, TQT_SIGNAL(doubleClicked(TQListViewItem *)),
TQT_SLOT(slotEdit(TQListViewItem *)));
connect(m_listView, TQ_SIGNAL(doubleClicked(TQListViewItem *)),
TQ_SLOT(slotEdit(TQListViewItem *)));
connect(m_listView, TQT_SIGNAL(pressed(TQListViewItem *)),
this, TQT_SLOT(slotItemClicked(TQListViewItem *)));
connect(m_listView, TQ_SIGNAL(pressed(TQListViewItem *)),
this, TQ_SLOT(slotItemClicked(TQListViewItem *)));
// Highlight all columns - enable extended selection mode
//
@ -365,12 +365,12 @@ MarkerEditor::slotClose()
void
MarkerEditor::setupActions()
{
TDEAction* close = KStdAction::close(TQT_TQOBJECT(this),
TQT_SLOT(slotClose()),
TDEAction* close = KStdAction::close(this,
TQ_SLOT(slotClose()),
actionCollection());
m_closeButton->setText(close->text());
connect(m_closeButton, TQT_SIGNAL(released()), this, TQT_SLOT(slotClose()));
connect(m_closeButton, TQ_SIGNAL(released()), this, TQ_SLOT(slotClose()));
// some adjustments
new TDEToolBarPopupAction(i18n("Und&o"),
@ -394,8 +394,8 @@ MarkerEditor::setupActions()
TQCanvasPixmap pixmap(pixmapDir + "/toolbar/time-musical.png");
TQIconSet icon(pixmap);
action = new TDERadioAction(i18n("&Musical Times"), icon, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotMusicalTime()),
action = new TDERadioAction(i18n("&Musical Times"), icon, 0, this,
TQ_SLOT(slotMusicalTime()),
actionCollection(), "time_musical");
action->setExclusiveGroup("timeMode");
if (timeMode == 0)
@ -404,8 +404,8 @@ MarkerEditor::setupActions()
pixmap.load(pixmapDir + "/toolbar/time-real.png");
icon = TQIconSet(pixmap);
action = new TDERadioAction(i18n("&Real Times"), icon, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotRealTime()),
action = new TDERadioAction(i18n("&Real Times"), icon, 0, this,
TQ_SLOT(slotRealTime()),
actionCollection(), "time_real");
action->setExclusiveGroup("timeMode");
if (timeMode == 1)
@ -414,8 +414,8 @@ MarkerEditor::setupActions()
pixmap.load(pixmapDir + "/toolbar/time-raw.png");
icon = TQIconSet(pixmap);
action = new TDERadioAction(i18n("Ra&w Times"), icon, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotRawTime()),
action = new TDERadioAction(i18n("Ra&w Times"), icon, 0, this,
TQ_SLOT(slotRawTime()),
actionCollection(), "time_raw");
action->setExclusiveGroup("timeMode");
if (timeMode == 2)

2
src/gui/editors/segment/MarkerEditor.h
Unescape View File

@ -47,7 +47,7 @@ class MultiViewCommandHistory;
class MarkerEditor : public TDEMainWindow
{
Q_OBJECT
TQ_OBJECT
public:

32
src/gui/editors/segment/PlayList.cpp
Unescape View File

@ -78,29 +78,29 @@ PlayList::PlayList(TQWidget *parent, const char *name)
m_deleteButton ->setText(i18n("Delete"));
m_clearButton ->setText(i18n("Clear"));
connect(m_openButton, TQT_SIGNAL(clicked()),
TQT_SLOT(slotOpenFiles()));
connect(m_openButton, TQ_SIGNAL(clicked()),
TQ_SLOT(slotOpenFiles()));
connect(m_playButton, TQT_SIGNAL(clicked()),
TQT_SLOT(slotPlay()));
connect(m_playButton, TQ_SIGNAL(clicked()),
TQ_SLOT(slotPlay()));
connect(m_deleteButton, TQT_SIGNAL(clicked()),
TQT_SLOT(slotDeleteCurrent()));
connect(m_deleteButton, TQ_SIGNAL(clicked()),
TQ_SLOT(slotDeleteCurrent()));
connect(m_clearButton, TQT_SIGNAL(clicked()),
TQT_SLOT(slotClear()));
connect(m_clearButton, TQ_SIGNAL(clicked()),
TQ_SLOT(slotClear()));
connect(m_moveUpButton, TQT_SIGNAL(clicked()),
TQT_SLOT(slotMoveUp()));
connect(m_moveUpButton, TQ_SIGNAL(clicked()),
TQ_SLOT(slotMoveUp()));
connect(m_moveDownButton, TQT_SIGNAL(clicked()),
TQT_SLOT(slotMoveDown()));
connect(m_moveDownButton, TQ_SIGNAL(clicked()),
TQ_SLOT(slotMoveDown()));
connect(m_listView, TQT_SIGNAL(currentChanged(TQListViewItem*)),
TQT_SLOT(slotCurrentItemChanged(TQListViewItem*)));
connect(m_listView, TQ_SIGNAL(currentChanged(TQListViewItem*)),
TQ_SLOT(slotCurrentItemChanged(TQListViewItem*)));
connect(m_listView, TQT_SIGNAL(dropped(TQDropEvent*, TQListViewItem*)),
TQT_SLOT(slotDropped(TQDropEvent*, TQListViewItem*)));
connect(m_listView, TQ_SIGNAL(dropped(TQDropEvent*, TQListViewItem*)),
TQ_SLOT(slotDropped(TQDropEvent*, TQListViewItem*)));
restore();

2
src/gui/editors/segment/PlayList.h
Unescape View File

@ -42,7 +42,7 @@ class PlayListView;
class PlayList : public TQVBox
{
Q_OBJECT
TQ_OBJECT
public:

2
src/gui/editors/segment/PlayListDialog.h
Unescape View File

@ -39,7 +39,7 @@ class PlayList;
class PlayListDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

58
src/gui/editors/segment/TrackButtons.cpp
Unescape View File

@ -76,10 +76,10 @@ TrackButtons::TrackButtons(RosegardenGUIDoc* doc,
: TQFrame(parent, name, f),
m_doc(doc),
m_layout(new TQVBoxLayout(this)),
m_recordSigMapper(new TQSignalMapper(TQT_TQOBJECT(this))),
m_muteSigMapper(new TQSignalMapper(TQT_TQOBJECT(this))),
m_clickedSigMapper(new TQSignalMapper(TQT_TQOBJECT(this))),
m_instListSigMapper(new TQSignalMapper(TQT_TQOBJECT(this))),
m_recordSigMapper(new TQSignalMapper(this)),
m_muteSigMapper(new TQSignalMapper(this)),
m_clickedSigMapper(new TQSignalMapper(this)),
m_instListSigMapper(new TQSignalMapper(this)),
m_tracks(doc->getComposition().getNbTracks()),
m_offset(4),
m_cellSize(trackCellHeight),
@ -106,18 +106,18 @@ TrackButtons::TrackButtons(RosegardenGUIDoc* doc,
m_layout->addStretch(20);
connect(m_recordSigMapper, TQT_SIGNAL(mapped(int)),
this, TQT_SLOT(slotToggleRecordTrack(int)));
connect(m_recordSigMapper, TQ_SIGNAL(mapped(int)),
this, TQ_SLOT(slotToggleRecordTrack(int)));
connect(m_muteSigMapper, TQT_SIGNAL(mapped(int)),
this, TQT_SLOT(slotToggleMutedTrack(int)));
connect(m_muteSigMapper, TQ_SIGNAL(mapped(int)),
this, TQ_SLOT(slotToggleMutedTrack(int)));
// connect signal mappers
connect(m_instListSigMapper, TQT_SIGNAL(mapped(int)),
this, TQT_SLOT(slotInstrumentSelection(int)));
connect(m_instListSigMapper, TQ_SIGNAL(mapped(int)),
this, TQ_SLOT(slotInstrumentSelection(int)));
connect(m_clickedSigMapper, TQT_SIGNAL(mapped(int)),
this, TQT_SIGNAL(trackSelected(int)));
connect(m_clickedSigMapper, TQ_SIGNAL(mapped(int)),
this, TQ_SIGNAL(trackSelected(int)));
// // Populate instrument popup menu just once at start-up
// //
@ -192,7 +192,7 @@ TrackButtons::populateButtons()
// reset track tokens
m_trackLabels[i]->setId(track->getId());
setButtonMapping(TQT_TQOBJECT(m_trackLabels[i]), track->getId());
setButtonMapping(m_trackLabels[i], track->getId());
m_trackLabels[i]->setPosition(i);
}
@ -357,7 +357,7 @@ TrackButtons::slotUpdateTracks()
// RG_DEBUG << "TrackButtons::slotUpdateTracks - set button mapping at pos "
// << i << " to track id " << track->getId() << endl;
setButtonMapping(TQT_TQOBJECT(m_trackLabels[i]), track->getId());
setButtonMapping(m_trackLabels[i], track->getId());
}
}
m_tracks = newNbTracks;
@ -767,8 +767,8 @@ TrackButtons::populateInstrumentPopup(Instrument *thisTrackInstr, TQPopupMenu* i
// Connect up the submenu
//
connect(subMenu, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotInstrumentPopupActivated(int)));
connect(subMenu, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotInstrumentPopupActivated(int)));
} else if (!instrUsedByMe) {
@ -1066,12 +1066,12 @@ TQFrame* TrackButtons::makeButton(Rosegarden::TrackId trackId)
record->off();
// Connect them to their sigmappers
connect(record, TQT_SIGNAL(stateChanged(bool)),
m_recordSigMapper, TQT_SLOT(map()));
connect(mute, TQT_SIGNAL(stateChanged(bool)),
m_muteSigMapper, TQT_SLOT(map()));
m_recordSigMapper->setMapping(TQT_TQOBJECT(record), track->getPosition());
m_muteSigMapper->setMapping(TQT_TQOBJECT(mute), track->getPosition());
connect(record, TQ_SIGNAL(stateChanged(bool)),
m_recordSigMapper, TQ_SLOT(map()));
connect(mute, TQ_SIGNAL(stateChanged(bool)),
m_muteSigMapper, TQ_SLOT(map()));
m_recordSigMapper->setMapping(record, track->getPosition());
m_muteSigMapper->setMapping(mute, track->getPosition());
// Store the KLedButton
//
@ -1101,20 +1101,20 @@ TQFrame* TrackButtons::makeButton(Rosegarden::TrackId trackId)
trackLabel->setFixedHeight(m_cellSize - buttonGap);
trackLabel->setIndent(7);
connect(trackLabel, TQT_SIGNAL(renameTrack(TQString, TrackId)),
TQT_SLOT(slotRenameTrack(TQString, TrackId)));
connect(trackLabel, TQ_SIGNAL(renameTrack(TQString, TrackId)),
TQ_SLOT(slotRenameTrack(TQString, TrackId)));
// Store the TrackLabel pointer
//
m_trackLabels.push_back(trackLabel);
// Connect it
setButtonMapping(TQT_TQOBJECT(trackLabel), trackId);
setButtonMapping(trackLabel, trackId);
connect(trackLabel, TQT_SIGNAL(changeToInstrumentList()),
m_instListSigMapper, TQT_SLOT(map()));
connect(trackLabel, TQT_SIGNAL(clicked()),
m_clickedSigMapper, TQT_SLOT(map()));
connect(trackLabel, TQ_SIGNAL(changeToInstrumentList()),
m_instListSigMapper, TQ_SLOT(map()));
connect(trackLabel, TQ_SIGNAL(clicked()),
m_clickedSigMapper, TQ_SLOT(map()));
//
// instrument label

2
src/gui/editors/segment/TrackButtons.h
Unescape View File

@ -50,7 +50,7 @@ class Instrument;
class TrackButtons : public TQFrame
{
Q_OBJECT
TQ_OBJECT
public:

142
src/gui/editors/segment/TrackEditor.cpp
Unescape View File

@ -162,10 +162,10 @@ TrackEditor::init(TQWidget* rosegardenguiview)
m_doc->getStudio(),
m_rulerScale, getTrackCellHeight());
connect(rosegardenguiview, TQT_SIGNAL(instrumentParametersChanged(InstrumentId)),
m_compositionModel, TQT_SLOT(slotInstrumentParametersChanged(InstrumentId)));
connect(rosegardenguiview->parent(), TQT_SIGNAL(instrumentParametersChanged(InstrumentId)),
m_compositionModel, TQT_SLOT(slotInstrumentParametersChanged(InstrumentId)));
connect(rosegardenguiview, TQ_SIGNAL(instrumentParametersChanged(InstrumentId)),
m_compositionModel, TQ_SLOT(slotInstrumentParametersChanged(InstrumentId)));
connect(rosegardenguiview->parent(), TQ_SIGNAL(instrumentParametersChanged(InstrumentId)),
m_compositionModel, TQ_SLOT(slotInstrumentParametersChanged(InstrumentId)));
m_segmentCanvas = new CompositionView(m_doc, m_compositionModel, this);
@ -221,105 +221,105 @@ TrackEditor::init(TQWidget* rosegardenguiview)
m_trackButtonScroll->setBottomMargin(m_bottomStandardRuler->height() +
m_segmentCanvas->horizontalScrollBar()->height());
connect(m_trackButtons, TQT_SIGNAL(widthChanged()),
this, TQT_SLOT(slotTrackButtonsWidthChanged()));
connect(m_trackButtons, TQ_SIGNAL(widthChanged()),
this, TQ_SLOT(slotTrackButtonsWidthChanged()));
connect(m_trackButtons, TQT_SIGNAL(trackSelected(int)),
rosegardenguiview, TQT_SLOT(slotSelectTrackSegments(int)));
connect(m_trackButtons, TQ_SIGNAL(trackSelected(int)),
rosegardenguiview, TQ_SLOT(slotSelectTrackSegments(int)));
connect(m_trackButtons, TQT_SIGNAL(instrumentSelected(int)),
rosegardenguiview, TQT_SLOT(slotUpdateInstrumentParameterBox(int)));
connect(m_trackButtons, TQ_SIGNAL(instrumentSelected(int)),
rosegardenguiview, TQ_SLOT(slotUpdateInstrumentParameterBox(int)));
connect(this, TQT_SIGNAL(stateChange(TQString, bool)),
rosegardenguiview, TQT_SIGNAL(stateChange(TQString, bool)));
connect(this, TQ_SIGNAL(stateChange(TQString, bool)),
rosegardenguiview, TQ_SIGNAL(stateChange(TQString, bool)));
connect(m_trackButtons, TQT_SIGNAL(modified()),
m_doc, TQT_SLOT(slotDocumentModified()));
connect(m_trackButtons, TQ_SIGNAL(modified()),
m_doc, TQ_SLOT(slotDocumentModified()));
connect(m_trackButtons, TQT_SIGNAL(muteButton(TrackId, bool)),
rosegardenguiview, TQT_SLOT(slotSetMuteButton(TrackId, bool)));
connect(m_trackButtons, TQ_SIGNAL(muteButton(TrackId, bool)),
rosegardenguiview, TQ_SLOT(slotSetMuteButton(TrackId, bool)));
// connect loop rulers' follow-scroll signals
connect(m_topStandardRuler->getLoopRuler(), TQT_SIGNAL(startMouseMove(int)),
m_segmentCanvas, TQT_SLOT(startAutoScroll(int)));
connect(m_topStandardRuler->getLoopRuler(), TQT_SIGNAL(stopMouseMove()),
m_segmentCanvas, TQT_SLOT(stopAutoScroll()));
connect(m_bottomStandardRuler->getLoopRuler(), TQT_SIGNAL(startMouseMove(int)),
m_segmentCanvas, TQT_SLOT(startAutoScroll(int)));
connect(m_bottomStandardRuler->getLoopRuler(), TQT_SIGNAL(stopMouseMove()),
m_segmentCanvas, TQT_SLOT(stopAutoScroll()));
connect(m_segmentCanvas, TQT_SIGNAL(contentsMoving(int, int)),
this, TQT_SLOT(slotCanvasScrolled(int, int)));
connect(m_topStandardRuler->getLoopRuler(), TQ_SIGNAL(startMouseMove(int)),
m_segmentCanvas, TQ_SLOT(startAutoScroll(int)));
connect(m_topStandardRuler->getLoopRuler(), TQ_SIGNAL(stopMouseMove()),
m_segmentCanvas, TQ_SLOT(stopAutoScroll()));
connect(m_bottomStandardRuler->getLoopRuler(), TQ_SIGNAL(startMouseMove(int)),
m_segmentCanvas, TQ_SLOT(startAutoScroll(int)));
connect(m_bottomStandardRuler->getLoopRuler(), TQ_SIGNAL(stopMouseMove()),
m_segmentCanvas, TQ_SLOT(stopAutoScroll()));
connect(m_segmentCanvas, TQ_SIGNAL(contentsMoving(int, int)),
this, TQ_SLOT(slotCanvasScrolled(int, int)));
// Synchronize bar buttons' scrollview with segment canvas' scrollbar
//
connect(m_segmentCanvas->verticalScrollBar(), TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotVerticalScrollTrackButtons(int)));
connect(m_segmentCanvas->verticalScrollBar(), TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotVerticalScrollTrackButtons(int)));
connect(m_segmentCanvas->verticalScrollBar(), TQT_SIGNAL(sliderMoved(int)),
this, TQT_SLOT(slotVerticalScrollTrackButtons(int)));
connect(m_segmentCanvas->verticalScrollBar(), TQ_SIGNAL(sliderMoved(int)),
this, TQ_SLOT(slotVerticalScrollTrackButtons(int)));
// scrolling with mouse wheel
connect(m_trackButtonScroll, TQT_SIGNAL(gotWheelEvent(TQWheelEvent*)),
m_segmentCanvas, TQT_SLOT(slotExternalWheelEvent(TQWheelEvent*)));
connect(m_trackButtonScroll, TQ_SIGNAL(gotWheelEvent(TQWheelEvent*)),
m_segmentCanvas, TQ_SLOT(slotExternalWheelEvent(TQWheelEvent*)));
// Connect horizontal scrollbar
//
connect(m_segmentCanvas->horizontalScrollBar(), TQT_SIGNAL(valueChanged(int)),
m_topStandardRuler, TQT_SLOT(slotScrollHoriz(int)));
connect(m_segmentCanvas->horizontalScrollBar(), TQT_SIGNAL(sliderMoved(int)),
m_topStandardRuler, TQT_SLOT(slotScrollHoriz(int)));
connect(m_segmentCanvas->horizontalScrollBar(), TQ_SIGNAL(valueChanged(int)),
m_topStandardRuler, TQ_SLOT(slotScrollHoriz(int)));
connect(m_segmentCanvas->horizontalScrollBar(), TQ_SIGNAL(sliderMoved(int)),
m_topStandardRuler, TQ_SLOT(slotScrollHoriz(int)));
connect(m_segmentCanvas->horizontalScrollBar(), TQT_SIGNAL(valueChanged(int)),
m_bottomStandardRuler, TQT_SLOT(slotScrollHoriz(int)));
connect(m_segmentCanvas->horizontalScrollBar(), TQT_SIGNAL(sliderMoved(int)),
m_bottomStandardRuler, TQT_SLOT(slotScrollHoriz(int)));
connect(m_segmentCanvas->horizontalScrollBar(), TQ_SIGNAL(valueChanged(int)),
m_bottomStandardRuler, TQ_SLOT(slotScrollHoriz(int)));
connect(m_segmentCanvas->horizontalScrollBar(), TQ_SIGNAL(sliderMoved(int)),
m_bottomStandardRuler, TQ_SLOT(slotScrollHoriz(int)));
connect(m_segmentCanvas->horizontalScrollBar(), TQT_SIGNAL(valueChanged(int)),
m_tempoRuler, TQT_SLOT(slotScrollHoriz(int)));
connect(m_segmentCanvas->horizontalScrollBar(), TQT_SIGNAL(sliderMoved(int)),
m_tempoRuler, TQT_SLOT(slotScrollHoriz(int)));
connect(m_segmentCanvas->horizontalScrollBar(), TQ_SIGNAL(valueChanged(int)),
m_tempoRuler, TQ_SLOT(slotScrollHoriz(int)));
connect(m_segmentCanvas->horizontalScrollBar(), TQ_SIGNAL(sliderMoved(int)),
m_tempoRuler, TQ_SLOT(slotScrollHoriz(int)));
connect(m_segmentCanvas->horizontalScrollBar(), TQT_SIGNAL(valueChanged(int)),
m_chordNameRuler, TQT_SLOT(slotScrollHoriz(int)));
connect(m_segmentCanvas->horizontalScrollBar(), TQT_SIGNAL(sliderMoved(int)),
m_chordNameRuler, TQT_SLOT(slotScrollHoriz(int)));
connect(m_segmentCanvas->horizontalScrollBar(), TQ_SIGNAL(valueChanged(int)),
m_chordNameRuler, TQ_SLOT(slotScrollHoriz(int)));
connect(m_segmentCanvas->horizontalScrollBar(), TQ_SIGNAL(sliderMoved(int)),
m_chordNameRuler, TQ_SLOT(slotScrollHoriz(int)));
connect(this, TQT_SIGNAL(needUpdate()), m_segmentCanvas, TQT_SLOT(slotUpdateSegmentsDrawBuffer()));
connect(this, TQ_SIGNAL(needUpdate()), m_segmentCanvas, TQ_SLOT(slotUpdateSegmentsDrawBuffer()));
connect(m_segmentCanvas->getModel(),
TQT_SIGNAL(selectedSegments(const SegmentSelection &)),
TQ_SIGNAL(selectedSegments(const SegmentSelection &)),
rosegardenguiview,
TQT_SLOT(slotSelectedSegments(const SegmentSelection &)));
TQ_SLOT(slotSelectedSegments(const SegmentSelection &)));
connect(m_segmentCanvas, TQT_SIGNAL(zoomIn()),
RosegardenGUIApp::self(), TQT_SLOT(slotZoomIn()));
connect(m_segmentCanvas, TQT_SIGNAL(zoomOut()),
RosegardenGUIApp::self(), TQT_SLOT(slotZoomOut()));
connect(m_segmentCanvas, TQ_SIGNAL(zoomIn()),
RosegardenGUIApp::self(), TQ_SLOT(slotZoomIn()));
connect(m_segmentCanvas, TQ_SIGNAL(zoomOut()),
RosegardenGUIApp::self(), TQ_SLOT(slotZoomOut()));
connect(getCommandHistory(), TQT_SIGNAL(commandExecuted()),
this, TQT_SLOT(update()));
connect(getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQ_SLOT(update()));
connect(m_doc, TQT_SIGNAL(pointerPositionChanged(timeT)),
this, TQT_SLOT(slotSetPointerPosition(timeT)));
connect(m_doc, TQ_SIGNAL(pointerPositionChanged(timeT)),
this, TQ_SLOT(slotSetPointerPosition(timeT)));
//
// pointer and loop drag signals from top and bottom bar buttons (loop rulers actually)
//
connect(m_topStandardRuler, TQT_SIGNAL(dragPointerToPosition(timeT)),
this, TQT_SLOT(slotPointerDraggedToPosition(timeT)));
connect(m_bottomStandardRuler, TQT_SIGNAL(dragPointerToPosition(timeT)),
this, TQT_SLOT(slotPointerDraggedToPosition(timeT)));
connect(m_topStandardRuler, TQ_SIGNAL(dragPointerToPosition(timeT)),
this, TQ_SLOT(slotPointerDraggedToPosition(timeT)));
connect(m_bottomStandardRuler, TQ_SIGNAL(dragPointerToPosition(timeT)),
this, TQ_SLOT(slotPointerDraggedToPosition(timeT)));
connect(m_topStandardRuler, TQT_SIGNAL(dragLoopToPosition(timeT)),
this, TQT_SLOT(slotLoopDraggedToPosition(timeT)));
connect(m_bottomStandardRuler, TQT_SIGNAL(dragLoopToPosition(timeT)),
this, TQT_SLOT(slotLoopDraggedToPosition(timeT)));
connect(m_topStandardRuler, TQ_SIGNAL(dragLoopToPosition(timeT)),
this, TQ_SLOT(slotLoopDraggedToPosition(timeT)));
connect(m_bottomStandardRuler, TQ_SIGNAL(dragLoopToPosition(timeT)),
this, TQ_SLOT(slotLoopDraggedToPosition(timeT)));
connect(m_doc, TQT_SIGNAL(loopChanged(timeT,
connect(m_doc, TQ_SIGNAL(loopChanged(timeT,
timeT)),
this, TQT_SLOT(slotSetLoop(timeT, timeT)));
this, TQ_SLOT(slotSetLoop(timeT, timeT)));
}
void TrackEditor::slotReadjustCanvasSize()
@ -756,7 +756,7 @@ void TrackEditor::dropEvent(TQDropEvent* event)
// WARNING
//
// DO NOT PERFORM ANY OPERATIONS AFTER THAT
// EMITTING THIS TQT_SIGNAL TRIGGERS THE LOADING OF A NEW DOCUMENT
// EMITTING THIS TQ_SIGNAL TRIGGERS THE LOADING OF A NEW DOCUMENT
// AND AS A CONSEQUENCE THE DELETION OF THIS TrackEditor OBJECT
//
} else {

2
src/gui/editors/segment/TrackEditor.h
Unescape View File

@ -64,7 +64,7 @@ class StandardRuler;
*/
class TrackEditor : public TQWidget, virtual public TrackEditorIface
{
Q_OBJECT
TQ_OBJECT
public:
/**

6
src/gui/editors/segment/TrackHeader.cpp
Unescape View File

@ -40,7 +40,7 @@ TrackHeader::paintEvent(TQPaintEvent *e)
{
TQPainter p( this );
p.setPen( colorGroup().buttonText() );
int pos = (orientation() == Qt::Horizontal)
int pos = (orientation() == TQt::Horizontal)
? e->rect().left()
: e->rect().top();
int id = mapToIndex( sectionAt( pos + offset() ) );
@ -52,8 +52,8 @@ TrackHeader::paintEvent(TQPaintEvent *e)
for ( int i = id; i < count(); i++ ) {
TQRect r = sRect( i );
paintSection( &p, i, r );
if ( orientation() == Qt::Horizontal && r. right() >= e->rect().right() ||
orientation() == Qt::Vertical && r. bottom() >= e->rect().bottom() )
if ( orientation() == TQt::Horizontal && r. right() >= e->rect().right() ||
orientation() == TQt::Vertical && r. bottom() >= e->rect().bottom() )
return ;
}

14
src/gui/editors/segment/TrackLabel.cpp
Unescape View File

@ -68,8 +68,8 @@ TrackLabel::TrackLabel(TrackId id,
m_pressTimer = new TQTimer(this);
connect(m_pressTimer, TQT_SIGNAL(timeout()),
this, TQT_SIGNAL(changeToInstrumentList()));
connect(m_pressTimer, TQ_SIGNAL(timeout()),
this, TQ_SIGNAL(changeToInstrumentList()));
TQToolTip::add
(this, i18n("Click and hold with left mouse button to assign this Track to an Instrument."));
@ -142,12 +142,12 @@ TrackLabel::setSelected(bool on)
void
TrackLabel::mousePressEvent(TQMouseEvent *e)
{
if (e->button() == Qt::RightButton) {
if (e->button() == TQt::RightButton) {
emit clicked();
emit changeToInstrumentList();
} else if (e->button() == Qt::LeftButton) {
} else if (e->button() == TQt::LeftButton) {
// start a timer on this hold
m_pressTimer->start(200, true); // 200ms, single shot
@ -161,7 +161,7 @@ TrackLabel::mouseReleaseEvent(TQMouseEvent *e)
if (m_pressTimer->isActive())
m_pressTimer->stop();
if (e->button() == Qt::LeftButton) {
if (e->button() == TQt::LeftButton) {
emit clicked();
}
}
@ -169,7 +169,7 @@ TrackLabel::mouseReleaseEvent(TQMouseEvent *e)
void
TrackLabel::mouseDoubleClickEvent(TQMouseEvent *e)
{
if (e->button() != Qt::LeftButton)
if (e->button() != TQt::LeftButton)
return ;
// Highlight this label alone and cheat using
@ -184,7 +184,7 @@ TrackLabel::mouseDoubleClickEvent(TQMouseEvent *e)
bool ok = false;
TQRegExpValidator validator(TQRegExp(".*"), TQT_TQOBJECT(this)); // empty is OK
TQRegExpValidator validator(TQRegExp(".*"), this); // empty is OK
TQString newText = KLineEditDlg::getText(i18n("Change track name"),
i18n("Enter new track name"),

2
src/gui/editors/segment/TrackLabel.h
Unescape View File

@ -46,7 +46,7 @@ namespace Rosegarden
*/
class TrackLabel : public TQWidgetStack
{
Q_OBJECT
TQ_OBJECT
public:

50
src/gui/editors/segment/TriggerSegmentManager.cpp
Unescape View File

@ -133,29 +133,29 @@ TriggerSegmentManager::TriggerSegmentManager(TQWidget *parent,
layout->addWidget(m_closeButton);
layout->addSpacing(5);
connect(m_addButton, TQT_SIGNAL(released()),
TQT_SLOT(slotAdd()));
connect(m_addButton, TQ_SIGNAL(released()),
TQ_SLOT(slotAdd()));
connect(m_deleteButton, TQT_SIGNAL(released()),
TQT_SLOT(slotDelete()));
connect(m_deleteButton, TQ_SIGNAL(released()),
TQ_SLOT(slotDelete()));
connect(m_closeButton, TQT_SIGNAL(released()),
TQT_SLOT(slotClose()));
connect(m_closeButton, TQ_SIGNAL(released()),
TQ_SLOT(slotClose()));
connect(m_deleteAllButton, TQT_SIGNAL(released()),
TQT_SLOT(slotDeleteAll()));
connect(m_deleteAllButton, TQ_SIGNAL(released()),
TQ_SLOT(slotDeleteAll()));
setupActions();
m_doc->getCommandHistory()->attachView(actionCollection());
connect(m_doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()),
this, TQT_SLOT(slotUpdate()));
connect(m_doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQ_SLOT(slotUpdate()));
connect(m_listView, TQT_SIGNAL(doubleClicked(TQListViewItem *)),
TQT_SLOT(slotEdit(TQListViewItem *)));
connect(m_listView, TQ_SIGNAL(doubleClicked(TQListViewItem *)),
TQ_SLOT(slotEdit(TQListViewItem *)));
connect(m_listView, TQT_SIGNAL(pressed(TQListViewItem *)),
this, TQT_SLOT(slotItemClicked(TQListViewItem *)));
connect(m_listView, TQ_SIGNAL(pressed(TQListViewItem *)),
this, TQ_SLOT(slotItemClicked(TQListViewItem *)));
// Highlight all columns - enable extended selection mode
//
@ -373,12 +373,12 @@ TriggerSegmentManager::slotClose()
void
TriggerSegmentManager::setupActions()
{
TDEAction* close = KStdAction::close(TQT_TQOBJECT(this),
TQT_SLOT(slotClose()),
TDEAction* close = KStdAction::close(this,
TQ_SLOT(slotClose()),
actionCollection());
m_closeButton->setText(close->text());
connect(m_closeButton, TQT_SIGNAL(released()), TQT_TQOBJECT(this), TQT_SLOT(slotClose()));
connect(m_closeButton, TQ_SIGNAL(released()), this, TQ_SLOT(slotClose()));
TQString pixmapDir = TDEGlobal::dirs()->findResource("appdata", "pixmaps/");
@ -395,8 +395,8 @@ TriggerSegmentManager::setupActions()
actionCollection(),
KStdAction::stdName(KStdAction::Redo));
new TDEAction(i18n("Pa&ste as New Triggered Segment"), CTRL + SHIFT + Key_V, TQT_TQOBJECT(this),
TQT_SLOT(slotPasteAsNew()), actionCollection(),
new TDEAction(i18n("Pa&ste as New Triggered Segment"), CTRL + SHIFT + Key_V, this,
TQ_SLOT(slotPasteAsNew()), actionCollection(),
"paste_to_trigger_segment");
kapp->config()->setGroup(TriggerManagerConfigGroup);
@ -407,8 +407,8 @@ TriggerSegmentManager::setupActions()
TQCanvasPixmap pixmap(pixmapDir + "/toolbar/time-musical.png");
TQIconSet icon(pixmap);
action = new TDERadioAction(i18n("&Musical Times"), icon, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotMusicalTime()),
action = new TDERadioAction(i18n("&Musical Times"), icon, 0, this,
TQ_SLOT(slotMusicalTime()),
actionCollection(), "time_musical");
action->setExclusiveGroup("timeMode");
if (timeMode == 0)
@ -417,8 +417,8 @@ TriggerSegmentManager::setupActions()
pixmap.load(pixmapDir + "/toolbar/time-real.png");
icon = TQIconSet(pixmap);
action = new TDERadioAction(i18n("&Real Times"), icon, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotRealTime()),
action = new TDERadioAction(i18n("&Real Times"), icon, 0, this,
TQ_SLOT(slotRealTime()),
actionCollection(), "time_real");
action->setExclusiveGroup("timeMode");
if (timeMode == 1)
@ -427,8 +427,8 @@ TriggerSegmentManager::setupActions()
pixmap.load(pixmapDir + "/toolbar/time-raw.png");
icon = TQIconSet(pixmap);
action = new TDERadioAction(i18n("Ra&w Times"), icon, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotRawTime()),
action = new TDERadioAction(i18n("Ra&w Times"), icon, 0, this,
TQ_SLOT(slotRawTime()),
actionCollection(), "time_raw");
action->setExclusiveGroup("timeMode");
if (timeMode == 2)

2
src/gui/editors/segment/TriggerSegmentManager.h
Unescape View File

@ -46,7 +46,7 @@ class MultiViewCommandHistory;
class TriggerSegmentManager : public TDEMainWindow
{
Q_OBJECT
TQ_OBJECT
public:

2
src/gui/editors/segment/segmentcanvas/AudioPreviewUpdater.h
Unescape View File

@ -45,7 +45,7 @@ class AudioPreviewThread;
class AudioPreviewUpdater : public TQObject
{
Q_OBJECT
TQ_OBJECT
public:

2
src/gui/editors/segment/segmentcanvas/CompositionModel.h
Unescape View File

@ -52,7 +52,7 @@ typedef std::vector<TQImage> PixmapArray;
class CompositionModel : public TQObject, public CompositionObserver, public SegmentObserver
{
Q_OBJECT
TQ_OBJECT
public:

4
src/gui/editors/segment/segmentcanvas/CompositionModelImpl.cpp
Unescape View File

@ -449,8 +449,8 @@ void CompositionModelImpl::updatePreviewCacheForAudioSegment(const Segment* segm
AudioPreviewUpdater *updater = new AudioPreviewUpdater
(*m_audioPreviewThread, m_composition, segment, segRect, this);
connect(updater, TQT_SIGNAL(audioPreviewComplete(AudioPreviewUpdater*)),
this, TQT_SLOT(slotAudioPreviewComplete(AudioPreviewUpdater*)));
connect(updater, TQ_SIGNAL(audioPreviewComplete(AudioPreviewUpdater*)),
this, TQ_SLOT(slotAudioPreviewComplete(AudioPreviewUpdater*)));
m_audioPreviewUpdaterMap[segment] = updater;

2
src/gui/editors/segment/segmentcanvas/CompositionModelImpl.h
Unescape View File

@ -58,7 +58,7 @@ class AudioPreviewThread;
class CompositionModelImpl : public CompositionModel
{
Q_OBJECT
TQ_OBJECT
public:

88
src/gui/editors/segment/segmentcanvas/CompositionView.cpp
Unescape View File

@ -130,8 +130,8 @@ CompositionView::CompositionView(RosegardenGUIDoc* doc,
if (doc) {
m_toolBox = new SegmentToolBox(this, doc);
connect(m_toolBox, TQT_SIGNAL(showContextHelp(const TQString &)),
this, TQT_SLOT(slotToolHelpChanged(const TQString &)));
connect(m_toolBox, TQ_SIGNAL(showContextHelp(const TQString &)),
this, TQ_SLOT(slotToolHelpChanged(const TQString &)));
}
setDragAutoScroll(true);
@ -144,43 +144,43 @@ CompositionView::CompositionView(RosegardenGUIDoc* doc,
TQScrollBar* hsb = horizontalScrollBar();
// dynamically adjust content size when scrolling past current composition's end
connect(hsb, TQT_SIGNAL(nextLine()),
this, TQT_SLOT(scrollRight()));
connect(hsb, TQT_SIGNAL(prevLine()),
this, TQT_SLOT(scrollLeft()));
// connect(this, TQT_SIGNAL(contentsMoving(int, int)),
// this, TQT_SLOT(slotAllDrawBuffersNeedRefresh()));
// connect(this, TQT_SIGNAL(contentsMoving(int, int)),
// this, TQT_SLOT(slotContentsMoving(int, int)));
connect(model, TQT_SIGNAL(needContentUpdate()),
this, TQT_SLOT(slotUpdateSegmentsDrawBuffer()));
connect(model, TQT_SIGNAL(needContentUpdate(const TQRect&)),
this, TQT_SLOT(slotUpdateSegmentsDrawBuffer(const TQRect&)));
connect(model, TQT_SIGNAL(needArtifactsUpdate()),
this, TQT_SLOT(slotArtifactsDrawBufferNeedsRefresh()));
connect(model, TQT_SIGNAL(needSizeUpdate()),
this, TQT_SLOT(slotUpdateSize()));
connect(hsb, TQ_SIGNAL(nextLine()),
this, TQ_SLOT(scrollRight()));
connect(hsb, TQ_SIGNAL(prevLine()),
this, TQ_SLOT(scrollLeft()));
// connect(this, TQ_SIGNAL(contentsMoving(int, int)),
// this, TQ_SLOT(slotAllDrawBuffersNeedRefresh()));
// connect(this, TQ_SIGNAL(contentsMoving(int, int)),
// this, TQ_SLOT(slotContentsMoving(int, int)));
connect(model, TQ_SIGNAL(needContentUpdate()),
this, TQ_SLOT(slotUpdateSegmentsDrawBuffer()));
connect(model, TQ_SIGNAL(needContentUpdate(const TQRect&)),
this, TQ_SLOT(slotUpdateSegmentsDrawBuffer(const TQRect&)));
connect(model, TQ_SIGNAL(needArtifactsUpdate()),
this, TQ_SLOT(slotArtifactsDrawBufferNeedsRefresh()));
connect(model, TQ_SIGNAL(needSizeUpdate()),
this, TQ_SLOT(slotUpdateSize()));
if (doc) {
connect(doc, TQT_SIGNAL(docColoursChanged()),
this, TQT_SLOT(slotRefreshColourCache()));
connect(doc, TQ_SIGNAL(docColoursChanged()),
this, TQ_SLOT(slotRefreshColourCache()));
// recording-related signals
connect(doc, TQT_SIGNAL(newMIDIRecordingSegment(Segment*)),
this, TQT_SLOT(slotNewMIDIRecordingSegment(Segment*)));
connect(doc, TQT_SIGNAL(newAudioRecordingSegment(Segment*)),
this, TQT_SLOT(slotNewAudioRecordingSegment(Segment*)));
// connect(doc, TQT_SIGNAL(recordMIDISegmentUpdated(Segment*, timeT)),
// this, TQT_SLOT(slotRecordMIDISegmentUpdated(Segment*, timeT)));
connect(doc, TQT_SIGNAL(stoppedAudioRecording()),
this, TQT_SLOT(slotStoppedRecording()));
connect(doc, TQT_SIGNAL(stoppedMIDIRecording()),
this, TQT_SLOT(slotStoppedRecording()));
connect(doc, TQT_SIGNAL(audioFileFinalized(Segment*)),
getModel(), TQT_SLOT(slotAudioFileFinalized(Segment*)));
connect(doc, TQ_SIGNAL(newMIDIRecordingSegment(Segment*)),
this, TQ_SLOT(slotNewMIDIRecordingSegment(Segment*)));
connect(doc, TQ_SIGNAL(newAudioRecordingSegment(Segment*)),
this, TQ_SLOT(slotNewAudioRecordingSegment(Segment*)));
// connect(doc, TQ_SIGNAL(recordMIDISegmentUpdated(Segment*, timeT)),
// this, TQ_SLOT(slotRecordMIDISegmentUpdated(Segment*, timeT)));
connect(doc, TQ_SIGNAL(stoppedAudioRecording()),
this, TQ_SLOT(slotStoppedRecording()));
connect(doc, TQ_SIGNAL(stoppedMIDIRecording()),
this, TQ_SLOT(slotStoppedRecording()));
connect(doc, TQ_SIGNAL(audioFileFinalized(Segment*)),
getModel(), TQ_SLOT(slotAudioFileFinalized(Segment*)));
}
CompositionModelImpl* cmi = dynamic_cast<CompositionModelImpl*>(model);
@ -189,7 +189,7 @@ CompositionView::CompositionView(RosegardenGUIDoc* doc,
}
if (doc) {
doc->getAudioPreviewThread().setEmptyQueueListener(TQT_TQOBJECT(this));
doc->getAudioPreviewThread().setEmptyQueueListener(this);
}
m_segmentsDrawBuffer.setOptimization(TQPixmap::BestOptim);
@ -878,7 +878,7 @@ void CompositionView::drawAreaAudioPreviews(TQPainter * p, const TQRect& clipRec
// << " - preResizeOrigin : " << api->preResizeOrigin << endl;
p->drawImage(drawBasePoint, api->pixmap[idx], localRect,
Qt::ColorOnly | Qt::ThresholdDither | Qt::AvoidDither);
TQt::ColorOnly | TQt::ThresholdDither | TQt::AvoidDither);
++idx;
if (idx >= api->pixmap.size())
@ -1197,7 +1197,7 @@ void CompositionView::drawIntersections(const CompositionModel::rectcontainer& r
break;
for (; i != rects.end(); ++i) {
CompositionRect ri = TQT_TQRECT_OBJECT(testRect.intersect(*i));
CompositionRect ri = testRect.intersect(*i);
if (!ri.isEmpty()) {
CompositionModel::rectcontainer::iterator t = std::find(intersections.begin(),
intersections.end(), ri);
@ -1244,7 +1244,7 @@ void CompositionView::drawIntersections(const CompositionModel::rectcontainer& r
break;
for (; i != intersections.end(); ++i) {
CompositionRect ri = TQT_TQRECT_OBJECT(testRect.intersect(*i));
CompositionRect ri = testRect.intersect(*i);
if (!ri.isEmpty() && ri != *i) {
CompositionModel::rectcontainer::iterator t = std::find(intersections2.begin(),
intersections2.end(), ri);
@ -1361,8 +1361,8 @@ void CompositionView::contentsMousePressEvent(TQMouseEvent* e)
slotSetPencilOverExisting((bs & TQt::AltButton + TQt::ControlButton) != 0);
switch (e->button()) {
case Qt::LeftButton:
case Qt::MidButton:
case TQt::LeftButton:
case TQt::MidButton:
startAutoScroll();
if (m_tool)
@ -1371,7 +1371,7 @@ void CompositionView::contentsMousePressEvent(TQMouseEvent* e)
RG_DEBUG << "CompositionView::contentsMousePressEvent() :"
<< this << " no tool\n";
break;
case Qt::RightButton:
case TQt::RightButton:
if (m_tool)
m_tool->handleRightButtonPress(e);
else
@ -1392,8 +1392,8 @@ void CompositionView::contentsMouseReleaseEvent(TQMouseEvent* e)
if (!m_tool)
return ;
if (e->button() == Qt::LeftButton ||
e->button() == Qt::MidButton )
if (e->button() == TQt::LeftButton ||
e->button() == TQt::MidButton )
m_tool->handleMouseButtonRelease(e);
}

2
src/gui/editors/segment/segmentcanvas/CompositionView.h
Unescape View File

@ -60,7 +60,7 @@ class CompositionRect;
class CompositionView : public RosegardenScrollView
{
Q_OBJECT
TQ_OBJECT
public:
CompositionView(RosegardenGUIDoc*, CompositionModel*,

2
src/gui/editors/segment/segmentcanvas/SegmentEraser.h
Unescape View File

@ -39,7 +39,7 @@ class CompositionView;
class SegmentEraser : public SegmentTool
{
Q_OBJECT
TQ_OBJECT
friend class SegmentToolBox;

2
src/gui/editors/segment/segmentcanvas/SegmentJoiner.h
Unescape View File

@ -39,7 +39,7 @@ class CompositionView;
class SegmentJoiner : public SegmentTool
{
Q_OBJECT
TQ_OBJECT
friend class SegmentToolBox;

10
src/gui/editors/segment/segmentcanvas/SegmentMover.cpp
Unescape View File

@ -61,22 +61,22 @@ SegmentMover::SegmentMover(CompositionView *c, RosegardenGUIDoc *d)
void SegmentMover::ready()
{
m_canvas->viewport()->setCursor(TQt::sizeAllCursor);
connect(m_canvas, TQT_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotCanvasScrolled(int, int)));
connect(m_canvas, TQ_SIGNAL(contentsMoving (int, int)),
this, TQ_SLOT(slotCanvasScrolled(int, int)));
setBasicContextHelp();
}
void SegmentMover::stow()
{
disconnect(m_canvas, TQT_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotCanvasScrolled(int, int)));
disconnect(m_canvas, TQ_SIGNAL(contentsMoving (int, int)),
this, TQ_SLOT(slotCanvasScrolled(int, int)));
}
void SegmentMover::slotCanvasScrolled(int newX, int newY)
{
TQMouseEvent tmpEvent(TQEvent::MouseMove,
m_canvas->viewport()->mapFromGlobal(TQCursor::pos()) + TQPoint(newX, newY),
Qt::NoButton, Qt::NoButton);
TQt::NoButton, TQt::NoButton);
handleMouseMove(&tmpEvent);
}

2
src/gui/editors/segment/segmentcanvas/SegmentMover.h
Unescape View File

@ -40,7 +40,7 @@ class CompositionView;
class SegmentMover : public SegmentTool
{
Q_OBJECT
TQ_OBJECT
friend class SegmentToolBox;

14
src/gui/editors/segment/segmentcanvas/SegmentPencil.cpp
Unescape View File

@ -63,28 +63,28 @@ SegmentPencil::SegmentPencil(CompositionView *c, RosegardenGUIDoc *d)
void SegmentPencil::ready()
{
m_canvas->viewport()->setCursor(TQt::ibeamCursor);
connect(m_canvas, TQT_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotCanvasScrolled(int, int)));
connect(m_canvas, TQ_SIGNAL(contentsMoving (int, int)),
this, TQ_SLOT(slotCanvasScrolled(int, int)));
setContextHelpFor(TQPoint(0, 0));
}
void SegmentPencil::stow()
{
disconnect(m_canvas, TQT_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotCanvasScrolled(int, int)));
disconnect(m_canvas, TQ_SIGNAL(contentsMoving (int, int)),
this, TQ_SLOT(slotCanvasScrolled(int, int)));
}
void SegmentPencil::slotCanvasScrolled(int newX, int newY)
{
TQMouseEvent tmpEvent(TQEvent::MouseMove,
m_canvas->viewport()->mapFromGlobal(TQCursor::pos()) + TQPoint(newX, newY),
Qt::NoButton, Qt::NoButton);
TQt::NoButton, TQt::NoButton);
handleMouseMove(&tmpEvent);
}
void SegmentPencil::handleMouseButtonPress(TQMouseEvent *e)
{
if (e->button() == Qt::RightButton)
if (e->button() == TQt::RightButton)
return;
// is user holding Ctrl+Alt? (ugly, but we are running short on available
@ -151,7 +151,7 @@ void SegmentPencil::handleMouseButtonPress(TQMouseEvent *e)
void SegmentPencil::handleMouseButtonRelease(TQMouseEvent* e)
{
if (e->button() == Qt::RightButton)
if (e->button() == TQt::RightButton)
return ;
setContextHelpFor(e->pos());

2
src/gui/editors/segment/segmentcanvas/SegmentPencil.h
Unescape View File

@ -43,7 +43,7 @@ class CompositionView;
class SegmentPencil : public SegmentTool
{
Q_OBJECT
TQ_OBJECT
friend class SegmentToolBox;

18
src/gui/editors/segment/segmentcanvas/SegmentResizer.cpp
Unescape View File

@ -68,22 +68,22 @@ SegmentResizer::SegmentResizer(CompositionView *c, RosegardenGUIDoc *d,
void SegmentResizer::ready()
{
m_canvas->viewport()->setCursor(TQt::sizeHorCursor);
connect(m_canvas, TQT_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotCanvasScrolled(int, int)));
connect(m_canvas, TQ_SIGNAL(contentsMoving (int, int)),
this, TQ_SLOT(slotCanvasScrolled(int, int)));
setBasicContextHelp(false);
}
void SegmentResizer::stow()
{
disconnect(m_canvas, TQT_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotCanvasScrolled(int, int)));
disconnect(m_canvas, TQ_SIGNAL(contentsMoving (int, int)),
this, TQ_SLOT(slotCanvasScrolled(int, int)));
}
void SegmentResizer::slotCanvasScrolled(int newX, int newY)
{
TQMouseEvent tmpEvent(TQEvent::MouseMove,
m_canvas->viewport()->mapFromGlobal(TQCursor::pos()) + TQPoint(newX, newY),
Qt::NoButton, Qt::NoButton);
TQt::NoButton, TQt::NoButton);
handleMouseMove(&tmpEvent);
}
@ -177,10 +177,10 @@ void SegmentResizer::handleMouseButtonRelease(TQMouseEvent *e)
progressDlg.setLabel(i18n("Generating audio preview..."));
command->disconnectProgressDialog(&progressDlg);
connect(&m_doc->getAudioFileManager(), TQT_SIGNAL(setProgress(int)),
progressDlg.progressBar(), TQT_SLOT(setValue(int)));
connect(&progressDlg, TQT_SIGNAL(cancelClicked()),
&m_doc->getAudioFileManager(), TQT_SLOT(slotStopPreview()));
connect(&m_doc->getAudioFileManager(), TQ_SIGNAL(setProgress(int)),
progressDlg.progressBar(), TQ_SLOT(setValue(int)));
connect(&progressDlg, TQ_SIGNAL(cancelClicked()),
&m_doc->getAudioFileManager(), TQ_SLOT(slotStopPreview()));
int fid = command->getNewAudioFileId();
if (fid >= 0) {

2
src/gui/editors/segment/segmentcanvas/SegmentResizer.h
Unescape View File

@ -44,7 +44,7 @@ class CompositionView;
*/
class SegmentResizer : public SegmentTool
{
Q_OBJECT
TQ_OBJECT
friend class SegmentToolBox;

10
src/gui/editors/segment/segmentcanvas/SegmentSelector.cpp
Unescape View File

@ -74,8 +74,8 @@ SegmentSelector::~SegmentSelector()
void SegmentSelector::ready()
{
m_canvas->viewport()->setCursor(TQt::arrowCursor);
connect(m_canvas, TQT_SIGNAL(contentsMoving (int, int)),
this, TQT_SLOT(slotCanvasScrolled(int, int)));
connect(m_canvas, TQ_SIGNAL(contentsMoving (int, int)),
this, TQ_SLOT(slotCanvasScrolled(int, int)));
setContextHelp(i18n("Click and drag to select segments"));
}
@ -86,7 +86,7 @@ void SegmentSelector::slotCanvasScrolled(int newX, int newY)
{
TQMouseEvent tmpEvent(TQEvent::MouseMove,
m_canvas->viewport()->mapFromGlobal(TQCursor::pos()) + TQPoint(newX, newY),
Qt::NoButton, Qt::NoButton);
TQt::NoButton, TQt::NoButton);
handleMouseMove(&tmpEvent);
}
@ -172,8 +172,8 @@ SegmentSelector::handleMouseButtonPress(TQMouseEvent *e)
// Add on middle button or ctrl+left - bounding box on rest
//
if (e->button() == Qt::MidButton ||
(e->button() == Qt::LeftButton && (e->state() & TQ_ControlButton))) {
if (e->button() == TQt::MidButton ||
(e->button() == TQt::LeftButton && (e->state() & ControlButton))) {
m_dispatchTool = getToolBox()->getTool(SegmentPencil::ToolName);

2
src/gui/editors/segment/segmentcanvas/SegmentSelector.h
Unescape View File

@ -40,7 +40,7 @@ class CompositionView;
class SegmentSelector : public SegmentTool
{
Q_OBJECT
TQ_OBJECT
friend class SegmentToolBox;

2
src/gui/editors/segment/segmentcanvas/SegmentSplitter.h
Unescape View File

@ -41,7 +41,7 @@ class CompositionView;
class SegmentSplitter : public SegmentTool
{
Q_OBJECT
TQ_OBJECT
friend class SegmentToolBox;

2
src/gui/editors/segment/segmentcanvas/SegmentTool.cpp
Unescape View File

@ -40,7 +40,7 @@ namespace Rosegarden
{
SegmentTool::SegmentTool(CompositionView* canvas, RosegardenGUIDoc *doc)
: BaseTool("segment_tool_menu", dynamic_cast<TDEMainWindow*>(doc->parent())->factory(), TQT_TQOBJECT(canvas)),
: BaseTool("segment_tool_menu", dynamic_cast<TDEMainWindow*>(doc->parent())->factory(), canvas),
m_canvas(canvas),
m_doc(doc),
m_changeMade(false)

2
src/gui/editors/segment/segmentcanvas/SegmentToolBox.h
Unescape View File

@ -39,7 +39,7 @@ class CompositionView;
class SegmentToolBox : public BaseToolBox
{
Q_OBJECT
TQ_OBJECT
public:
SegmentToolBox(CompositionView* parent, RosegardenGUIDoc*);

54
src/gui/editors/tempo/TempoView.cpp
Unescape View File

@ -84,7 +84,7 @@ TempoView::TempoView(RosegardenGUIDoc *doc, TQWidget *parent, timeT openTime):
// define some note filtering buttons in a group
//
m_filterGroup =
new TQButtonGroup(1, Qt::Horizontal, i18n("Filter"), getCentralWidget());
new TQButtonGroup(1, TQt::Horizontal, i18n("Filter"), getCentralWidget());
m_tempoCheckBox = new TQCheckBox(i18n("Tempo"), m_filterGroup);
m_timeSigCheckBox = new TQCheckBox(i18n("Time Signature"), m_filterGroup);
@ -92,8 +92,8 @@ TempoView::TempoView(RosegardenGUIDoc *doc, TQWidget *parent, timeT openTime):
// Connect up
//
connect(m_filterGroup, TQT_SIGNAL(released(int)),
TQT_SLOT(slotModifyFilter(int)));
connect(m_filterGroup, TQ_SIGNAL(released(int)),
TQ_SLOT(slotModifyFilter(int)));
m_list = new TDEListView(getCentralWidget());
m_list->setItemsRenameable(true);
@ -106,8 +106,8 @@ TempoView::TempoView(RosegardenGUIDoc *doc, TQWidget *parent, timeT openTime):
// Connect double clicker
//
connect(m_list, TQT_SIGNAL(doubleClicked(TQListViewItem*)),
TQT_SLOT(slotPopupEditor(TQListViewItem*)));
connect(m_list, TQ_SIGNAL(doubleClicked(TQListViewItem*)),
TQ_SLOT(slotPopupEditor(TQListViewItem*)));
m_list->setAllColumnsShowFocus(true);
m_list->setSelectionMode(TQListView::Extended);
@ -487,12 +487,12 @@ TempoView::slotEditInsertTempo()
dialog.setTempoPosition(insertTime);
connect(&dialog,
TQT_SIGNAL(changeTempo(timeT,
TQ_SIGNAL(changeTempo(timeT,
tempoT,
tempoT,
TempoDialog::TempoDialogAction)),
this,
TQT_SIGNAL(changeTempo(timeT,
TQ_SIGNAL(changeTempo(timeT,
tempoT,
tempoT,
TempoDialog::TempoDialogAction)));
@ -576,37 +576,37 @@ TempoView::setupActions()
TQString pixmapDir = TDEGlobal::dirs()->findResource("appdata", "pixmaps/");
TQIconSet icon(TQPixmap(pixmapDir + "/toolbar/event-insert-tempo.png"));
new TDEAction(AddTempoChangeCommand::getGlobalName(), icon, Key_I, TQT_TQOBJECT(this),
TQT_SLOT(slotEditInsertTempo()), actionCollection(),
new TDEAction(AddTempoChangeCommand::getGlobalName(), icon, Key_I, this,
TQ_SLOT(slotEditInsertTempo()), actionCollection(),
"insert_tempo");
TQCanvasPixmap pixmap(pixmapDir + "/toolbar/event-insert-timesig.png");
icon = TQIconSet(pixmap);
new TDEAction(AddTimeSignatureCommand::getGlobalName(), icon, Key_G, TQT_TQOBJECT(this),
TQT_SLOT(slotEditInsertTimeSignature()), actionCollection(),
new TDEAction(AddTimeSignatureCommand::getGlobalName(), icon, Key_G, this,
TQ_SLOT(slotEditInsertTimeSignature()), actionCollection(),
"insert_timesig");
pixmap.load(pixmapDir + "/toolbar/event-delete.png");
icon = TQIconSet(pixmap);
new TDEAction(i18n("&Delete"), icon, Key_Delete, TQT_TQOBJECT(this),
TQT_SLOT(slotEditDelete()), actionCollection(),
new TDEAction(i18n("&Delete"), icon, Key_Delete, this,
TQ_SLOT(slotEditDelete()), actionCollection(),
"delete");
pixmap.load(pixmapDir + "/toolbar/event-edit.png");
icon = TQIconSet(pixmap);
new TDEAction(i18n("&Edit Item"), icon, Key_E, TQT_TQOBJECT(this),
TQT_SLOT(slotEdit()), actionCollection(),
new TDEAction(i18n("&Edit Item"), icon, Key_E, this,
TQ_SLOT(slotEdit()), actionCollection(),
"edit");
new TDEAction(i18n("Select &All"), 0, TQT_TQOBJECT(this),
TQT_SLOT(slotSelectAll()), actionCollection(),
new TDEAction(i18n("Select &All"), 0, this,
TQ_SLOT(slotSelectAll()), actionCollection(),
"select_all");
new TDEAction(i18n("Clear Selection"), Key_Escape, TQT_TQOBJECT(this),
TQT_SLOT(slotClearSelection()), actionCollection(),
new TDEAction(i18n("Clear Selection"), Key_Escape, this,
TQ_SLOT(slotClearSelection()), actionCollection(),
"clear_selection");
m_config->setGroup(TempoViewConfigGroup);
@ -617,8 +617,8 @@ TempoView::setupActions()
pixmap.load(pixmapDir + "/toolbar/time-musical.png");
icon = TQIconSet(pixmap);
action = new TDERadioAction(i18n("&Musical Times"), icon, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotMusicalTime()),
action = new TDERadioAction(i18n("&Musical Times"), icon, 0, this,
TQ_SLOT(slotMusicalTime()),
actionCollection(), "time_musical");
action->setExclusiveGroup("timeMode");
if (timeMode == 0)
@ -627,8 +627,8 @@ TempoView::setupActions()
pixmap.load(pixmapDir + "/toolbar/time-real.png");
icon = TQIconSet(pixmap);
action = new TDERadioAction(i18n("&Real Times"), icon, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotRealTime()),
action = new TDERadioAction(i18n("&Real Times"), icon, 0, this,
TQ_SLOT(slotRealTime()),
actionCollection(), "time_real");
action->setExclusiveGroup("timeMode");
if (timeMode == 1)
@ -637,8 +637,8 @@ TempoView::setupActions()
pixmap.load(pixmapDir + "/toolbar/time-raw.png");
icon = TQIconSet(pixmap);
action = new TDERadioAction(i18n("Ra&w Times"), icon, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotRawTime()),
action = new TDERadioAction(i18n("Ra&w Times"), icon, 0, this,
TQ_SLOT(slotRawTime()),
actionCollection(), "time_raw");
action->setExclusiveGroup("timeMode");
if (timeMode == 2)
@ -784,12 +784,12 @@ TempoView::slotPopupEditor(TQListViewItem *qitem)
dialog.setTempoPosition(time);
connect(&dialog,
TQT_SIGNAL(changeTempo(timeT,
TQ_SIGNAL(changeTempo(timeT,
tempoT,
tempoT,
TempoDialog::TempoDialogAction)),
this,
TQT_SIGNAL(changeTempo(timeT,
TQ_SIGNAL(changeTempo(timeT,
tempoT,
tempoT,
TempoDialog::TempoDialogAction)));

2
src/gui/editors/tempo/TempoView.h
Unescape View File

@ -58,7 +58,7 @@ class Composition;
class TempoView : public EditViewBase, public CompositionObserver
{
Q_OBJECT
TQ_OBJECT
enum Filter

2
src/gui/general/BaseTool.h
Unescape View File

@ -43,7 +43,7 @@ namespace Rosegarden
*/
class BaseTool : public TQObject
{
Q_OBJECT
TQ_OBJECT
friend class BaseToolBox;

4
src/gui/general/BaseToolBox.cpp
Unescape View File

@ -46,8 +46,8 @@ BaseTool* BaseToolBox::getTool(const TQString& toolName)
if (!tool) tool = createTool(toolName);
connect(tool, TQT_SIGNAL(showContextHelp(const TQString &)),
this, TQT_SIGNAL(showContextHelp(const TQString &)));
connect(tool, TQ_SIGNAL(showContextHelp(const TQString &)),
this, TQ_SIGNAL(showContextHelp(const TQString &)));
return tool;
}

2
src/gui/general/BaseToolBox.h
Unescape View File

@ -44,7 +44,7 @@ class BaseTool;
*/
class BaseToolBox : public TQObject
{
Q_OBJECT
TQ_OBJECT
public:

8
src/gui/general/EditTool.cpp
Unescape View File

@ -39,7 +39,7 @@ namespace Rosegarden
{
EditTool::EditTool(const TQString& menuName, EditView* view)
: BaseTool(menuName, view->factory(), TQT_TQOBJECT(view)),
: BaseTool(menuName, view->factory(), view),
m_parentView(view)
{}
@ -54,7 +54,7 @@ void EditTool::handleMousePress(timeT time,
switch (e->button()) {
case Qt::LeftButton:
case TQt::LeftButton:
if (e->type() == TQEvent::MouseButtonDblClick) {
RG_DEBUG << "EditTool::handleMousePress: it's a double-click"
<< endl;
@ -66,11 +66,11 @@ void EditTool::handleMousePress(timeT time,
}
break;
case Qt::RightButton:
case TQt::RightButton:
handleRightButtonPress(time, height, staffNo, e, el);
break;
case Qt::MidButton:
case TQt::MidButton:
handleMidButtonPress(time, height, staffNo, e, el);
break;

2
src/gui/general/EditToolBox.h
Unescape View File

@ -42,7 +42,7 @@ class EditView;
*/
class EditToolBox : public BaseToolBox
{
Q_OBJECT
TQ_OBJECT
public:
EditToolBox(EditView* parent);

176
src/gui/general/EditView.cpp
Unescape View File

@ -133,8 +133,8 @@ EditView::EditView(RosegardenGUIDoc *doc,
{
m_controlRulers->setHoverCloseButton(true);
m_controlRulers->setHoverCloseButtonDelayed(false);
connect(m_controlRulers, TQT_SIGNAL(closeRequest(TQWidget*)),
this, TQT_SLOT(slotRemoveControlRuler(TQWidget*)));
connect(m_controlRulers, TQ_SIGNAL(closeRequest(TQWidget*)),
this, TQ_SLOT(slotRemoveControlRuler(TQWidget*)));
(dynamic_cast<TQBoxLayout*>(m_bottomBox->layout()))->setDirection(TQBoxLayout::BottomToTop);
@ -281,10 +281,10 @@ void EditView::setTopStandardRuler(StandardRuler* w, TQWidget *leftBox)
m_grid->addLayout(gl, TOPBARBUTTONS_ROW, m_mainCol);
if (m_canvasView) {
connect(m_canvasView->horizontalScrollBar(), TQT_SIGNAL(valueChanged(int)),
m_topStandardRuler, TQT_SLOT(slotScrollHoriz(int)));
connect(m_canvasView->horizontalScrollBar(), TQT_SIGNAL(sliderMoved(int)),
m_topStandardRuler, TQT_SLOT(slotScrollHoriz(int)));
connect(m_canvasView->horizontalScrollBar(), TQ_SIGNAL(valueChanged(int)),
m_topStandardRuler, TQ_SLOT(slotScrollHoriz(int)));
connect(m_canvasView->horizontalScrollBar(), TQ_SIGNAL(sliderMoved(int)),
m_topStandardRuler, TQ_SLOT(slotScrollHoriz(int)));
}
}
@ -296,10 +296,10 @@ void EditView::setBottomStandardRuler(StandardRuler* w)
// m_bottomBox->insertWidget(0, w);
if (m_canvasView) {
connect(m_canvasView->horizontalScrollBar(), TQT_SIGNAL(valueChanged(int)),
m_bottomStandardRuler, TQT_SLOT(slotScrollHoriz(int)));
connect(m_canvasView->horizontalScrollBar(), TQT_SIGNAL(sliderMoved(int)),
m_bottomStandardRuler, TQT_SLOT(slotScrollHoriz(int)));
connect(m_canvasView->horizontalScrollBar(), TQ_SIGNAL(valueChanged(int)),
m_bottomStandardRuler, TQ_SLOT(slotScrollHoriz(int)));
connect(m_canvasView->horizontalScrollBar(), TQ_SIGNAL(sliderMoved(int)),
m_bottomStandardRuler, TQ_SLOT(slotScrollHoriz(int)));
}
}
@ -343,10 +343,10 @@ void EditView::addRuler(TQWidget* w)
m_rulerBox->addWidget(w);
if (m_canvasView) {
connect(m_canvasView->horizontalScrollBar(), TQT_SIGNAL(valueChanged(int)),
w, TQT_SLOT(slotScrollHoriz(int)));
connect(m_canvasView->horizontalScrollBar(), TQT_SIGNAL(sliderMoved(int)),
w, TQT_SLOT(slotScrollHoriz(int)));
connect(m_canvasView->horizontalScrollBar(), TQ_SIGNAL(valueChanged(int)),
w, TQ_SLOT(slotScrollHoriz(int)));
connect(m_canvasView->horizontalScrollBar(), TQ_SIGNAL(sliderMoved(int)),
w, TQ_SLOT(slotScrollHoriz(int)));
}
}
@ -363,14 +363,14 @@ void EditView::addControlRuler(ControlRuler* ruler)
m_controlRulers->showPage(ruler);
if (m_canvasView) {
connect(m_canvasView->horizontalScrollBar(), TQT_SIGNAL(valueChanged(int)),
ruler->horizontalScrollBar(), TQT_SIGNAL(valueChanged(int)));
connect(m_canvasView->horizontalScrollBar(), TQT_SIGNAL(sliderMoved(int)),
ruler->horizontalScrollBar(), TQT_SIGNAL(sliderMoved(int)));
connect(m_canvasView->horizontalScrollBar(), TQ_SIGNAL(valueChanged(int)),
ruler->horizontalScrollBar(), TQ_SIGNAL(valueChanged(int)));
connect(m_canvasView->horizontalScrollBar(), TQ_SIGNAL(sliderMoved(int)),
ruler->horizontalScrollBar(), TQ_SIGNAL(sliderMoved(int)));
}
connect(ruler, TQT_SIGNAL(stateChange(const TQString&, bool)),
this, TQT_SLOT(slotStateChanged(const TQString&, bool)));
connect(ruler, TQ_SIGNAL(stateChange(const TQString&, bool)),
this, TQ_SLOT(slotStateChanged(const TQString&, bool)));
stateChanged("have_control_ruler", KXMLGUIClient::StateReverse);
}
@ -424,10 +424,10 @@ void EditView::setCanvasView(RosegardenCanvasView *canvasView)
// m_horizontalScrollBar->setSteps(m_canvasView->horizontalScrollBar()->lineStep(),
// m_canvasView->horizontalScrollBar()->pageStep());
// connect(m_horizontalScrollBar, TQT_SIGNAL(valueChanged(int)),
// m_canvasView->horizontalScrollBar(), TQT_SIGNAL(valueChanged(int)));
// connect(m_horizontalScrollBar, TQT_SIGNAL(sliderMoved(int)),
// m_canvasView->horizontalScrollBar(), TQT_SIGNAL(sliderMoved(int)));
// connect(m_horizontalScrollBar, TQ_SIGNAL(valueChanged(int)),
// m_canvasView->horizontalScrollBar(), TQ_SIGNAL(valueChanged(int)));
// connect(m_horizontalScrollBar, TQ_SIGNAL(sliderMoved(int)),
// m_canvasView->horizontalScrollBar(), TQ_SIGNAL(sliderMoved(int)));
}
@ -726,132 +726,132 @@ EditView::setupActions()
TQIconSet icon = TQIconSet(pixmap);
new TDEAction(AddTempoChangeCommand::getGlobalName(),
icon, 0,
TQT_TQOBJECT(this), TQT_SLOT(slotAddTempo()),
this, TQ_SLOT(slotAddTempo()),
actionCollection(), "add_tempo");
pixmap.load(pixmapDir + "/toolbar/event-insert-timesig.png");
icon = TQIconSet(pixmap);
new TDEAction(AddTimeSignatureCommand::getGlobalName(),
icon, 0,
TQT_TQOBJECT(this), TQT_SLOT(slotAddTimeSignature()),
this, TQ_SLOT(slotAddTimeSignature()),
actionCollection(), "add_time_signature");
//
// Transforms
//
new TDEAction(i18n("&Halve Durations"), Key_H + CTRL, TQT_TQOBJECT(this),
TQT_SLOT(slotHalveDurations()), actionCollection(),
new TDEAction(i18n("&Halve Durations"), Key_H + CTRL, this,
TQ_SLOT(slotHalveDurations()), actionCollection(),
"halve_durations");
new TDEAction(i18n("&Double Durations"), Key_H + CTRL + SHIFT, TQT_TQOBJECT(this),
TQT_SLOT(slotDoubleDurations()), actionCollection(),
new TDEAction(i18n("&Double Durations"), Key_H + CTRL + SHIFT, this,
TQ_SLOT(slotDoubleDurations()), actionCollection(),
"double_durations");
new TDEAction(RescaleCommand::getGlobalName(), 0, TQT_TQOBJECT(this),
TQT_SLOT(slotRescale()), actionCollection(),
new TDEAction(RescaleCommand::getGlobalName(), 0, this,
TQ_SLOT(slotRescale()), actionCollection(),
"rescale");
new TDEAction(TransposeCommand::getGlobalName(1), 0,
Key_Up, TQT_TQOBJECT(this),
TQT_SLOT(slotTransposeUp()), actionCollection(),
Key_Up, this,
TQ_SLOT(slotTransposeUp()), actionCollection(),
"transpose_up");
new TDEAction(TransposeCommand::getGlobalName(12), 0,
Key_Up + CTRL, TQT_TQOBJECT(this),
TQT_SLOT(slotTransposeUpOctave()), actionCollection(),
Key_Up + CTRL, this,
TQ_SLOT(slotTransposeUpOctave()), actionCollection(),
"transpose_up_octave");
new TDEAction(TransposeCommand::getGlobalName( -1), 0,
Key_Down, TQT_TQOBJECT(this),
TQT_SLOT(slotTransposeDown()), actionCollection(),
Key_Down, this,
TQ_SLOT(slotTransposeDown()), actionCollection(),
"transpose_down");
new TDEAction(TransposeCommand::getGlobalName( -12), 0,
Key_Down + CTRL, TQT_TQOBJECT(this),
TQT_SLOT(slotTransposeDownOctave()), actionCollection(),
Key_Down + CTRL, this,
TQ_SLOT(slotTransposeDownOctave()), actionCollection(),
"transpose_down_octave");
new TDEAction(TransposeCommand::getGlobalName(0), 0, TQT_TQOBJECT(this),
TQT_SLOT(slotTranspose()), actionCollection(),
new TDEAction(TransposeCommand::getGlobalName(0), 0, this,
TQ_SLOT(slotTranspose()), actionCollection(),
"general_transpose");
new TDEAction(TransposeCommand::getDiatonicGlobalName(0,0), 0, TQT_TQOBJECT(this),
TQT_SLOT(slotDiatonicTranspose()), actionCollection(),
new TDEAction(TransposeCommand::getDiatonicGlobalName(0,0), 0, this,
TQ_SLOT(slotDiatonicTranspose()), actionCollection(),
"general_diatonic_transpose");
new TDEAction(InvertCommand::getGlobalName(0), 0, TQT_TQOBJECT(this),
TQT_SLOT(slotInvert()), actionCollection(),
new TDEAction(InvertCommand::getGlobalName(0), 0, this,
TQ_SLOT(slotInvert()), actionCollection(),
"invert");
new TDEAction(RetrogradeCommand::getGlobalName(0), 0, TQT_TQOBJECT(this),
TQT_SLOT(slotRetrograde()), actionCollection(),
new TDEAction(RetrogradeCommand::getGlobalName(0), 0, this,
TQ_SLOT(slotRetrograde()), actionCollection(),
"retrograde");
new TDEAction(RetrogradeInvertCommand::getGlobalName(0), 0, TQT_TQOBJECT(this),
TQT_SLOT(slotRetrogradeInvert()), actionCollection(),
new TDEAction(RetrogradeInvertCommand::getGlobalName(0), 0, this,
TQ_SLOT(slotRetrogradeInvert()), actionCollection(),
"retrograde_invert");
new TDEAction(i18n("Jog &Left"), Key_Left + ALT, TQT_TQOBJECT(this),
TQT_SLOT(slotJogLeft()), actionCollection(),
new TDEAction(i18n("Jog &Left"), Key_Left + ALT, this,
TQ_SLOT(slotJogLeft()), actionCollection(),
"jog_left");
new TDEAction(i18n("Jog &Right"), Key_Right + ALT, TQT_TQOBJECT(this),
TQT_SLOT(slotJogRight()), actionCollection(),
new TDEAction(i18n("Jog &Right"), Key_Right + ALT, this,
TQ_SLOT(slotJogRight()), actionCollection(),
"jog_right");
// Control rulers
//
new TDEAction(i18n("Show Velocity Property Ruler"), 0, TQT_TQOBJECT(this),
TQT_SLOT(slotShowVelocityControlRuler()), actionCollection(),
new TDEAction(i18n("Show Velocity Property Ruler"), 0, this,
TQ_SLOT(slotShowVelocityControlRuler()), actionCollection(),
"show_velocity_control_ruler");
/*
new TDEAction(i18n("Show Controllers Events Ruler"), 0, this,
TQT_SLOT(slotShowControllerEventsRuler()), actionCollection(),
TQ_SLOT(slotShowControllerEventsRuler()), actionCollection(),
"show_controller_events_ruler");
*/
// Disabled for now
//
// new TDEAction(i18n("Add Control Ruler..."), 0, this,
// TQT_SLOT(slotShowPropertyControlRuler()), actionCollection(),
// TQ_SLOT(slotShowPropertyControlRuler()), actionCollection(),
// "add_control_ruler");
//
// Control Ruler context menu
//
new TDEAction(i18n("Insert item"), 0, TQT_TQOBJECT(this),
TQT_SLOT(slotInsertControlRulerItem()), actionCollection(),
new TDEAction(i18n("Insert item"), 0, this,
TQ_SLOT(slotInsertControlRulerItem()), actionCollection(),
"insert_control_ruler_item");
// This was on Key_Delete, but that conflicts with existing Delete commands
// on individual edit views
new TDEAction(i18n("Erase selected items"), 0, TQT_TQOBJECT(this),
TQT_SLOT(slotEraseControlRulerItem()), actionCollection(),
new TDEAction(i18n("Erase selected items"), 0, this,
TQ_SLOT(slotEraseControlRulerItem()), actionCollection(),
"erase_control_ruler_item");
new TDEAction(i18n("Clear ruler"), 0, TQT_TQOBJECT(this),
TQT_SLOT(slotClearControlRulerItem()), actionCollection(),
new TDEAction(i18n("Clear ruler"), 0, this,
TQ_SLOT(slotClearControlRulerItem()), actionCollection(),
"clear_control_ruler_item");
new TDEAction(i18n("Insert line of controllers"), 0, TQT_TQOBJECT(this),
TQT_SLOT(slotStartControlLineItem()), actionCollection(),
new TDEAction(i18n("Insert line of controllers"), 0, this,
TQ_SLOT(slotStartControlLineItem()), actionCollection(),
"start_control_line_item");
new TDEAction(i18n("Flip forward"), Key_BracketRight, TQT_TQOBJECT(this),
TQT_SLOT(slotFlipForwards()), actionCollection(),
new TDEAction(i18n("Flip forward"), Key_BracketRight, this,
TQ_SLOT(slotFlipForwards()), actionCollection(),
"flip_control_events_forward");
new TDEAction(i18n("Flip backwards"), Key_BracketLeft, TQT_TQOBJECT(this),
TQT_SLOT(slotFlipBackwards()), actionCollection(),
new TDEAction(i18n("Flip backwards"), Key_BracketLeft, this,
TQ_SLOT(slotFlipBackwards()), actionCollection(),
"flip_control_events_back");
new TDEAction(i18n("Draw property line"), 0, TQT_TQOBJECT(this),
TQT_SLOT(slotDrawPropertyLine()), actionCollection(),
new TDEAction(i18n("Draw property line"), 0, this,
TQ_SLOT(slotDrawPropertyLine()), actionCollection(),
"draw_property_line");
new TDEAction(i18n("Select all property values"), 0, TQT_TQOBJECT(this),
TQT_SLOT(slotSelectAllProperties()), actionCollection(),
new TDEAction(i18n("Select all property values"), 0, this,
TQ_SLOT(slotSelectAllProperties()), actionCollection(),
"select_all_properties");
}
@ -901,8 +901,8 @@ EditView::setupAddControlRulerMenu()
addControlRulerMenu->insertItem(itemStr, i++);
}
connect(addControlRulerMenu, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotAddControlRuler(int)));
connect(addControlRulerMenu, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotAddControlRuler(int)));
}
}
@ -1080,18 +1080,18 @@ EditView::createInsertPitchActionMenu()
};
TDEActionMenu *insertPitchActionMenu =
new TDEActionMenu(i18n("&Insert Note"), TQT_TQOBJECT(this), "insert_note_actionmenu");
new TDEActionMenu(i18n("&Insert Note"), this, "insert_note_actionmenu");
for (int octave = 0; octave <= 2; ++octave) {
TDEActionMenu *menu = insertPitchActionMenu;
if (octave == 1) {
menu = new TDEActionMenu(i18n("&Upper Octave"), TQT_TQOBJECT(this),
menu = new TDEActionMenu(i18n("&Upper Octave"), this,
"insert_note_actionmenu_upper_octave");
insertPitchActionMenu->insert(new TDEActionSeparator(TQT_TQOBJECT(this)));
insertPitchActionMenu->insert(new TDEActionSeparator(this));
insertPitchActionMenu->insert(menu);
} else if (octave == 2) {
menu = new TDEActionMenu(i18n("&Lower Octave"), TQT_TQOBJECT(this),
menu = new TDEActionMenu(i18n("&Lower Octave"), this,
"insert_note_actionmenu_lower_octave");
insertPitchActionMenu->insert(menu);
}
@ -1114,7 +1114,7 @@ EditView::createInsertPitchActionMenu()
new TDEAction
(flat.arg(notePitchNames[i]),
CTRL + SHIFT + notePitchKeys[octave][i],
TQT_TQOBJECT(this), TQT_SLOT(slotInsertNoteFromAction()), actionCollection(),
this, TQ_SLOT(slotInsertNoteFromAction()), actionCollection(),
TQString("insert_%1_flat%2").arg(i).arg(octaveSuffix).ascii());
menu->insert(insertPitchAction);
@ -1124,7 +1124,7 @@ EditView::createInsertPitchActionMenu()
new TDEAction
(notePitchNames[i],
notePitchKeys[octave][i],
TQT_TQOBJECT(this), TQT_SLOT(slotInsertNoteFromAction()), actionCollection(),
this, TQ_SLOT(slotInsertNoteFromAction()), actionCollection(),
TQString("insert_%1%2").arg(i).arg(octaveSuffix).ascii());
menu->insert(insertPitchAction);
@ -1137,14 +1137,14 @@ EditView::createInsertPitchActionMenu()
new TDEAction
(sharp.arg(notePitchNames[i]),
SHIFT + notePitchKeys[octave][i],
TQT_TQOBJECT(this), TQT_SLOT(slotInsertNoteFromAction()), actionCollection(),
this, TQ_SLOT(slotInsertNoteFromAction()), actionCollection(),
TQString("insert_%1_sharp%2").arg(i).arg(octaveSuffix).ascii());
menu->insert(insertPitchAction);
}
if (i < 6)
menu->insert(new TDEActionSeparator(TQT_TQOBJECT(this)));
menu->insert(new TDEActionSeparator(this));
}
}
@ -1218,12 +1218,12 @@ void EditView::slotAddTempo()
TempoDialog tempoDlg(this, getDocument());
connect(&tempoDlg,
TQT_SIGNAL(changeTempo(timeT,
TQ_SIGNAL(changeTempo(timeT,
tempoT,
tempoT,
TempoDialog::TempoDialogAction)),
this,
TQT_SIGNAL(changeTempo(timeT,
TQ_SIGNAL(changeTempo(timeT,
tempoT,
tempoT,
TempoDialog::TempoDialogAction)));
@ -1672,7 +1672,7 @@ ControlRuler* EditView::findRuler(const ControlParameter& controller, int &index
PropertyControlRuler* EditView::makePropertyControlRuler(PropertyName propertyName)
{
TQCanvas* controlRulerCanvas = new TQCanvas(TQT_TQOBJECT(this));
TQCanvas* controlRulerCanvas = new TQCanvas(this);
TQSize viewSize = getViewSize();
controlRulerCanvas->resize(viewSize.width(), ControlRuler::DefaultRulerHeight); // TODO - keep it in sync with main canvas size
@ -1690,7 +1690,7 @@ PropertyControlRuler* EditView::makePropertyControlRuler(PropertyName propertyNa
ControllerEventsRuler* EditView::makeControllerEventRuler(const ControlParameter *controller)
{
TQCanvas* controlRulerCanvas = new TQCanvas(TQT_TQOBJECT(this));
TQCanvas* controlRulerCanvas = new TQCanvas(this);
TQSize viewSize = getViewSize();
controlRulerCanvas->resize(viewSize.width(), ControlRuler::DefaultRulerHeight); // TODO - keep it in sync with main canvas size
// TQCanvas* controlRulerCanvas = ControlRulerCanvasRepository::getCanvas(getCurrentSegment(), controller,

2
src/gui/general/EditView.h
Unescape View File

@ -65,7 +65,7 @@ class ActiveItem;
class EditView : public EditViewBase
{
Q_OBJECT
TQ_OBJECT
public:

62
src/gui/general/EditViewBase.cpp
Unescape View File

@ -118,12 +118,12 @@ EditViewBase::EditViewBase(RosegardenGUIDoc *doc,
m_doc->attachEditView(this);
TQObject::connect
(getCommandHistory(), TQT_SIGNAL(commandExecuted()),
this, TQT_SLOT(update()));
(getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQ_SLOT(update()));
TQObject::connect
(getCommandHistory(), TQT_SIGNAL(commandExecuted()),
this, TQT_SLOT(slotTestClipboard()));
(getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQ_SLOT(slotTestClipboard()));
// create accelerators
//
@ -156,33 +156,33 @@ void EditViewBase::setupActions(TQString rcFileName, bool haveClipboard)
// Actions all edit views will have
KStdAction::showToolbar(TQT_TQOBJECT(this), TQT_SLOT(slotToggleToolBar()),
KStdAction::showToolbar(this, TQ_SLOT(slotToggleToolBar()),
actionCollection(), "options_show_toolbar");
KStdAction::showStatusbar(TQT_TQOBJECT(this), TQT_SLOT(slotToggleStatusBar()),
KStdAction::showStatusbar(this, TQ_SLOT(slotToggleStatusBar()),
actionCollection(), "options_show_statusbar");
KStdAction::preferences(TQT_TQOBJECT(this),
TQT_SLOT(slotConfigure()),
KStdAction::preferences(this,
TQ_SLOT(slotConfigure()),
actionCollection());
KStdAction::keyBindings(TQT_TQOBJECT(this),
TQT_SLOT(slotEditKeys()),
KStdAction::keyBindings(this,
TQ_SLOT(slotEditKeys()),
actionCollection());
KStdAction::configureToolbars(TQT_TQOBJECT(this),
TQT_SLOT(slotEditToolbars()),
KStdAction::configureToolbars(this,
TQ_SLOT(slotEditToolbars()),
actionCollection());
// File menu
KStdAction::save (TQT_TQOBJECT(this), TQT_SIGNAL(saveFile()), actionCollection());
KStdAction::close(TQT_TQOBJECT(this), TQT_SLOT(slotCloseWindow()), actionCollection());
KStdAction::save (this, TQ_SIGNAL(saveFile()), actionCollection());
KStdAction::close(this, TQ_SLOT(slotCloseWindow()), actionCollection());
if (haveClipboard) {
KStdAction::cut (TQT_TQOBJECT(this), TQT_SLOT(slotEditCut()), actionCollection());
KStdAction::copy (TQT_TQOBJECT(this), TQT_SLOT(slotEditCopy()), actionCollection());
KStdAction::paste (TQT_TQOBJECT(this), TQT_SLOT(slotEditPaste()), actionCollection());
KStdAction::cut (this, TQ_SLOT(slotEditCut()), actionCollection());
KStdAction::copy (this, TQ_SLOT(slotEditCopy()), actionCollection());
KStdAction::paste (this, TQ_SLOT(slotEditPaste()), actionCollection());
}
new TDEToolBarPopupAction(i18n("Und&o"),
@ -201,34 +201,34 @@ void EditViewBase::setupActions(TQString rcFileName, bool haveClipboard)
TQCanvasPixmap pixmap(pixmapDir + "/toolbar/matrix.png");
TQIconSet icon = TQIconSet(pixmap);
new TDEAction(i18n("Open in Matri&x Editor"), icon, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotOpenInMatrix()), actionCollection(),
new TDEAction(i18n("Open in Matri&x Editor"), icon, 0, this,
TQ_SLOT(slotOpenInMatrix()), actionCollection(),
"open_in_matrix");
pixmap.load(pixmapDir + "/toolbar/matrix-percussion.png");
icon = TQIconSet(pixmap);
new TDEAction(i18n("Open in &Percussion Matrix Editor"), icon, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotOpenInPercussionMatrix()), actionCollection(),
new TDEAction(i18n("Open in &Percussion Matrix Editor"), icon, 0, this,
TQ_SLOT(slotOpenInPercussionMatrix()), actionCollection(),
"open_in_percussion_matrix");
pixmap.load(pixmapDir + "/toolbar/notation.png");
icon = TQIconSet(pixmap);
new TDEAction(i18n("Open in &Notation Editor"), icon, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotOpenInNotation()), actionCollection(),
new TDEAction(i18n("Open in &Notation Editor"), icon, 0, this,
TQ_SLOT(slotOpenInNotation()), actionCollection(),
"open_in_notation");
pixmap.load(pixmapDir + "/toolbar/eventlist.png");
icon = TQIconSet(pixmap);
new TDEAction(i18n("Open in &Event List Editor"), icon, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotOpenInEventList()), actionCollection(),
new TDEAction(i18n("Open in &Event List Editor"), icon, 0, this,
TQ_SLOT(slotOpenInEventList()), actionCollection(),
"open_in_event_list");
new TDEAction(i18n("Set Segment Start Time..."), 0, TQT_TQOBJECT(this),
TQT_SLOT(slotSetSegmentStartTime()), actionCollection(),
new TDEAction(i18n("Set Segment Start Time..."), 0, this,
TQ_SLOT(slotSetSegmentStartTime()), actionCollection(),
"set_segment_start");
new TDEAction(i18n("Set Segment Duration..."), 0, TQT_TQOBJECT(this),
TQT_SLOT(slotSetSegmentDuration()), actionCollection(),
new TDEAction(i18n("Set Segment Duration..."), 0, this,
TQ_SLOT(slotSetSegmentDuration()), actionCollection(),
"set_segment_duration");
// add undo and redo to edit menu and toolbar
@ -254,8 +254,8 @@ void EditViewBase::slotEditToolbars()
{
KEditToolbar dlg(actionCollection(), getRCFileName());
connect(&dlg, TQT_SIGNAL(newToolbarConfig()),
TQT_SLOT(slotUpdateToolbars()));
connect(&dlg, TQ_SIGNAL(newToolbarConfig()),
TQ_SLOT(slotUpdateToolbars()));
dlg.exec();
}

2
src/gui/general/EditViewBase.h
Unescape View File

@ -57,7 +57,7 @@ class EditTool;
class EditViewBase : public KDockMainWindow
{
Q_OBJECT
TQ_OBJECT
public:

6
src/gui/general/PresetHandlerDialog.cpp
Unescape View File

@ -96,7 +96,7 @@ PresetHandlerDialog::initDialog()
m_playerCombo->insertItem(i18n("Professional"));
TQGroupBox *scopeBox = new TQButtonGroup
(1, Qt::Horizontal, i18n("Scope"), frame);
(1, TQt::Horizontal, i18n("Scope"), frame);
if (m_fromNotation) {
TQRadioButton *onlySelectedSegments = new
TQRadioButton(i18n("Only selected segments"), scopeBox);
@ -145,8 +145,8 @@ PresetHandlerDialog::initDialog()
}
connect(m_categoryCombo, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotCategoryIndexChanged(int)));
connect(m_categoryCombo, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotCategoryIndexChanged(int)));
}
TQString

2
src/gui/general/PresetHandlerDialog.h
Unescape View File

@ -44,7 +44,7 @@ class PresetGroup;
class PresetHandlerDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:

2
src/gui/general/ProgressReporter.h
Unescape View File

@ -35,7 +35,7 @@ namespace Rosegarden
class ProgressReporter : public TQObject
{
Q_OBJECT
TQ_OBJECT
public:
ProgressReporter(TQObject* parent, const char* name = 0);

4
src/gui/general/RosegardenCanvasView.cpp
Unescape View File

@ -58,8 +58,8 @@ RosegardenCanvasView::RosegardenCanvasView(TQCanvas* canvas,
m_autoScrolling(false)
{
setDragAutoScroll(true);
connect( &m_autoScrollTimer, TQT_SIGNAL( timeout() ),
this, TQT_SLOT( doAutoScroll() ) );
connect( &m_autoScrollTimer, TQ_SIGNAL( timeout() ),
this, TQ_SLOT( doAutoScroll() ) );
}
void RosegardenCanvasView::fitWidthToContents()

2
src/gui/general/RosegardenCanvasView.h
Unescape View File

@ -48,7 +48,7 @@ namespace Rosegarden
class RosegardenCanvasView : public TQCanvasView
{
Q_OBJECT
TQ_OBJECT
public:
RosegardenCanvasView(TQCanvas*,

4
src/gui/general/RosegardenScrollView.cpp
Unescape View File

@ -64,8 +64,8 @@ RosegardenScrollView::RosegardenScrollView(TQWidget* parent,
m_autoScrolling(false)
{
setDragAutoScroll(true);
connect( &m_autoScrollTimer, TQT_SIGNAL( timeout() ),
this, TQT_SLOT( doAutoScroll() ) );
connect( &m_autoScrollTimer, TQ_SIGNAL( timeout() ),
this, TQ_SLOT( doAutoScroll() ) );
}
void RosegardenScrollView::setBottomFixedWidget(TQWidget* w)

2
src/gui/general/RosegardenScrollView.h
Unescape View File

@ -47,7 +47,7 @@ namespace Rosegarden
*/
class RosegardenScrollView : public TQScrollView
{
Q_OBJECT
TQ_OBJECT
public:
RosegardenScrollView(TQWidget* parent=0, const char* name=0, WFlags f=0);

2
src/gui/kdeext/KLedButton.cpp
Unescape View File

@ -48,7 +48,7 @@ KLedButton::~KLedButton()
void KLedButton::mousePressEvent( TQMouseEvent *e )
{
if (e->button() == Qt::LeftButton) {
if (e->button() == TQt::LeftButton) {
toggle();
emit stateChanged( state() );
}

2
src/gui/kdeext/KLedButton.h
Unescape View File

@ -45,7 +45,7 @@ namespace Rosegarden
* Copyright (C) 2000 Stefan Schimanski <1Stein@gmx.de>
*/
class KLedButton : public KLed {
Q_OBJECT
TQ_OBJECT
public:
KLedButton(const TQColor &col=TQt::green, TQWidget *parent=0, const char *name=0);

10
src/gui/kdeext/RGLed.cpp
Unescape View File

@ -292,7 +292,7 @@ KLed::paintFlat() // paint a ROUND FLAT led lamp
// Set the brush to SolidPattern, this fills the entire area
// of the ellipse which is drawn with a thin grey "border" (pen)
brush.setStyle( Qt::SolidPattern );
brush.setStyle( TQt::SolidPattern );
brush.setColor( color );
pen.setWidth( 1 );
@ -337,7 +337,7 @@ KLed::paintRound() // paint a ROUND RAISED led lamp
// Set the brush to SolidPattern, this fills the entire area
// of the ellipse which is drawn first
brush.setStyle( Qt::SolidPattern );
brush.setStyle( TQt::SolidPattern );
brush.setColor( color );
paint.setBrush( brush ); // Assign the brush to the painter
@ -387,7 +387,7 @@ KLed::paintRound() // paint a ROUND RAISED led lamp
color = colorGroup().dark();
pen.setColor( color ); // Set the pen accordingly
paint.setPen( pen ); // Select pen for drawing
brush.setStyle( Qt::NoBrush ); // Switch off the brush
brush.setStyle( TQt::NoBrush ); // Switch off the brush
paint.setBrush( brush ); // This avoids filling of the ellipse
paint.drawEllipse( 1, 1, width, width );
@ -457,7 +457,7 @@ KLed::paintSunken() // paint a ROUND SUNKEN led lamp
// Set the brush to SolidPattern, this fills the entire area
// of the ellipse which is drawn first
brush.setStyle( Qt::SolidPattern );
brush.setStyle( TQt::SolidPattern );
brush.setColor( color );
paint.setBrush( brush ); // Assign the brush to the painter
@ -504,7 +504,7 @@ KLed::paintSunken() // paint a ROUND SUNKEN led lamp
// from the upper left.
pen.setWidth( 2 * scale + 1 ); // ### shouldn't this value be smaller for smaller LEDs?
brush.setStyle( Qt::NoBrush ); // Switch off the brush
brush.setStyle( TQt::NoBrush ); // Switch off the brush
paint.setBrush( brush ); // This avoids filling of the ellipse
// Set the initial color value to colorGroup().light() (bright) and start

2
src/gui/kdeext/TDEStartupLogo.h
Unescape View File

@ -28,7 +28,7 @@
class TDEStartupLogo : public TQWidget
{
Q_OBJECT
TQ_OBJECT
public:

108
src/gui/kdeext/klearlook.cpp
Unescape View File

@ -519,7 +519,7 @@ hoverSect( TQTC_NO_SECT ) {
}
void KlearlookStyle::applicationPolish( const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, void *ptr ) {
if (ceData.widgetObjectTypes.contains(TQAPPLICATION_OBJECT_NAME_STRING)) {
if (ceData.widgetObjectTypes.contains("TQApplication")) {
TQApplication *app = reinterpret_cast<TQApplication*>(ptr);
if ( !qstrcmp( app->argv() [ 0 ], "kicker" ) || !qstrcmp( app->argv() [ 0 ], "appletproxy" ) ) {
@ -589,36 +589,36 @@ void KlearlookStyle::polish( TQPalette &pal ) {
static const char * kdeToolbarWidget = "tde toolbar widget";
void KlearlookStyle::polish( const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, void *ptr ) {
if (ceData.widgetObjectTypes.contains(TQWIDGET_OBJECT_NAME_STRING)) {
if (ceData.widgetObjectTypes.contains("TQWidget")) {
TQWidget *widget = reinterpret_cast<TQWidget*>(ptr);
if ( ::tqqt_cast<TQRadioButton *>( widget )
|| ::tqqt_cast<TQCheckBox *>( widget )
|| ::tqqt_cast<TQSpinWidget *>( widget )
|| widget->inherits( TQSPLITTERHANDLE_OBJECT_NAME_STRING ) ) {
if ( ::tqt_cast<TQRadioButton *>( widget )
|| ::tqt_cast<TQCheckBox *>( widget )
|| ::tqt_cast<TQSpinWidget *>( widget )
|| widget->inherits( "TQSplitterHandle" ) ) {
widget->setMouseTracking( true );
installObjectEventHandler(ceData, elementFlags, ptr, this);
} else if ( ::tqqt_cast<TQButton *>( widget ) || ::tqqt_cast<TQComboBox *>( widget ) ||
} else if ( ::tqt_cast<TQButton *>( widget ) || ::tqt_cast<TQComboBox *>( widget ) ||
widget->inherits( "TQToolBarExtensionWidget" ) ) {
widget->setBackgroundMode( TQWidget::PaletteBackground );
installObjectEventHandler(ceData, elementFlags, ptr, this);
} else if ( ::tqqt_cast<TQMenuBar *>( widget )
|| ::tqqt_cast<TQToolBar *>( widget )
|| ::tqqt_cast<TQPopupMenu *>( widget ) )
} else if ( ::tqt_cast<TQMenuBar *>( widget )
|| ::tqt_cast<TQToolBar *>( widget )
|| ::tqt_cast<TQPopupMenu *>( widget ) )
widget->setBackgroundMode( TQWidget::PaletteBackground );
else if ( widget->inherits( "TDEToolBarSeparator" ) ) {
widget->setBackgroundMode( TQWidget::NoBackground );
installObjectEventHandler(ceData, elementFlags, ptr, this);
} else if ( ::tqqt_cast<TQScrollBar *>( widget ) ) {
} else if ( ::tqt_cast<TQScrollBar *>( widget ) ) {
widget->setMouseTracking( true );
installObjectEventHandler(ceData, elementFlags, ptr, this);
widget->setBackgroundMode( TQWidget::NoBackground );
} else if ( ::tqqt_cast<TQSlider *>( widget ) || ::tqqt_cast<TQHeader *>( widget ) ) {
} else if ( ::tqt_cast<TQSlider *>( widget ) || ::tqt_cast<TQHeader *>( widget ) ) {
widget->setMouseTracking( true );
installObjectEventHandler(ceData, elementFlags, ptr, this);
@ -632,37 +632,37 @@ void KlearlookStyle::polish( const TQStyleControlElementData &ceData, ControlEle
}
void KlearlookStyle::unPolish( const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, void *ptr ) {
if (ceData.widgetObjectTypes.contains(TQWIDGET_OBJECT_NAME_STRING)) {
if (ceData.widgetObjectTypes.contains("TQWidget")) {
TQWidget *widget = reinterpret_cast<TQWidget*>(ptr);
if ( ::tqqt_cast<TQRadioButton *>( widget ) ||
::tqqt_cast<TQCheckBox *>( widget ) ||
::tqqt_cast<TQSpinWidget *>( widget ) ||
widget->inherits( TQSPLITTERHANDLE_OBJECT_NAME_STRING ) ) {
if ( ::tqt_cast<TQRadioButton *>( widget ) ||
::tqt_cast<TQCheckBox *>( widget ) ||
::tqt_cast<TQSpinWidget *>( widget ) ||
widget->inherits( "TQSplitterHandle" ) ) {
widget->setMouseTracking( false );
removeObjectEventHandler(ceData, elementFlags, ptr, this);
} else if ( ::tqqt_cast<TQButton *>( widget ) || ::tqqt_cast<TQComboBox *>( widget ) ||
} else if ( ::tqt_cast<TQButton *>( widget ) || ::tqt_cast<TQComboBox *>( widget ) ||
widget->inherits( "TQToolBarExtensionWidget" ) ) {
widget->setBackgroundMode( TQWidget::PaletteButton );
removeObjectEventHandler(ceData, elementFlags, ptr, this);
} else if ( ::tqqt_cast<TQMenuBar *>( widget ) ||
::tqqt_cast<TQToolBar *>( widget ) ||
::tqqt_cast<TQPopupMenu *>( widget ) )
} else if ( ::tqt_cast<TQMenuBar *>( widget ) ||
::tqt_cast<TQToolBar *>( widget ) ||
::tqt_cast<TQPopupMenu *>( widget ) )
widget->setBackgroundMode( TQWidget::PaletteBackground );
else if ( widget->inherits( "TDEToolBarSeparator" ) ) {
widget->setBackgroundMode( PaletteBackground );
removeObjectEventHandler(ceData, elementFlags, ptr, this);
} else if ( ::tqqt_cast<TQScrollBar *>( widget ) ) {
} else if ( ::tqt_cast<TQScrollBar *>( widget ) ) {
widget->setMouseTracking( false );
removeObjectEventHandler(ceData, elementFlags, ptr, this);
widget->setBackgroundMode( TQWidget::PaletteButton );
} else if ( ::tqqt_cast<TQSlider *>( widget ) ||
::tqqt_cast<TQHeader *>( widget ) ) {
} else if ( ::tqt_cast<TQSlider *>( widget ) ||
::tqt_cast<TQHeader *>( widget ) ) {
widget->setMouseTracking( false );
removeObjectEventHandler(ceData, elementFlags, ptr, this);
@ -676,14 +676,14 @@ void KlearlookStyle::unPolish( const TQStyleControlElementData &ceData, ControlE
}
bool KlearlookStyle::objectEventHandler( const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, void* source, TQEvent *event ) {
if (ceData.widgetObjectTypes.contains(TQOBJECT_OBJECT_NAME_STRING)) {
if (ceData.widgetObjectTypes.contains("TQObject")) {
TQObject* object = reinterpret_cast<TQObject*>(source);
if ( object->parent() && 0 == qstrcmp( object->name(), kdeToolbarWidget ) ) {
// Draw background for custom widgets in the toolbar that have specified a "tde toolbar widget" name.
if ( TQEvent::Paint == event->type() ) {
TQWidget * widget = TQT_TQWIDGET( object ),
*parent = TQT_TQWIDGET( object->parent() );
TQWidget * widget = static_cast<TQWidget*>( object ),
*parent = static_cast<TQWidget*>( object->parent() );
#ifdef TQTC_GRADIENT_TOOLBARS_AND_MENUBARS
// Find the top-level toolbar of this widget, since it may be nested in other
// widgets that are on the toolbar.
@ -693,7 +693,7 @@ bool KlearlookStyle::objectEventHandler( const TQStyleControlElementData &ceData
while ( parent && parent->parent() && !qstrcmp( parent->name(), kdeToolbarWidget ) ) {
x_offset += parent->x();
y_offset += parent->y();
parent = TQT_TQWIDGET( parent->parent() );
parent = static_cast<TQWidget*>( parent->parent() );
}
TQRect pr( parent->rect() );
@ -747,7 +747,7 @@ bool KlearlookStyle::objectEventHandler( const TQStyleControlElementData &ceData
}
break;
case TQEvent::Leave:
if ( hoverWidget && TQT_BASE_OBJECT(object) == TQT_BASE_OBJECT(hoverWidget) ) {
if ( hoverWidget && object == hoverWidget ) {
oldCursor.setX( -1 );
oldCursor.setY( -1 );
hoverWidget = NULL;
@ -1206,7 +1206,7 @@ void KlearlookStyle::drawLightBevel(
}
void KlearlookStyle::drawArrow( TQPainter *p, const TQRect &r, const TQColorGroup &cg, TQStyle::SFlags flags,
TQStyle::TQ_PrimitiveElement pe, bool small, bool checkActive ) const {
TQStyle::PrimitiveElement pe, bool small, bool checkActive ) const {
TQPointArray a;
const TQColor &col = flags & Style_Enabled
? checkActive && flags & Style_Active
@ -1296,7 +1296,7 @@ void KlearlookStyle::drawArrow( TQPainter *p, const TQRect &r, const TQColorGrou
p->restore();
}
void KlearlookStyle::drawPrimitiveMenu( TQ_PrimitiveElement pe, TQPainter *p, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, const TQRect &r, const TQColorGroup &cg,
void KlearlookStyle::drawPrimitiveMenu( PrimitiveElement pe, TQPainter *p, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, const TQRect &r, const TQColorGroup &cg,
SFlags flags, const TQStyleOption &data ) const {
switch ( pe ) {
case PE_CheckMark:
@ -1335,7 +1335,7 @@ void KlearlookStyle::drawPrimitiveMenu( TQ_PrimitiveElement pe, TQPainter *p, co
}
}
void KlearlookStyle::drawPrimitive( TQ_PrimitiveElement pe, TQPainter *p, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, const TQRect &r, const TQColorGroup &cg,
void KlearlookStyle::drawPrimitive( PrimitiveElement pe, TQPainter *p, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, const TQRect &r, const TQColorGroup &cg,
SFlags flags, const TQStyleOption &data ) const {
int x, y, w, h;
@ -2229,7 +2229,7 @@ void KlearlookStyle::drawControl(
bool cornerWidget = false,
firstTab = 0 == tb->indexOf( data.tab() ->identifier() );
if ( ::tqqt_cast<const TQTabWidget *>( tb->parent() ) ) {
if ( ::tqt_cast<const TQTabWidget *>( tb->parent() ) ) {
const TQTabWidget * tw = ( const TQTabWidget* ) tb->parent();
// is there a corner widget in the (top) left edge?
@ -2771,10 +2771,10 @@ void KlearlookStyle::drawControl(
TQPixmap pixmap = *mi->pixmap();
if ( 1 == pixmap.depth() )
p->setBackgroundMode( Qt::OpaqueMode );
p->setBackgroundMode( TQt::OpaqueMode );
p->drawPixmap( ir.x(), ( ir.height() - pixmap.height() ) >> 1, pixmap );
if ( pixmap.depth() == 1 )
p->setBackgroundMode( Qt::TransparentMode );
p->setBackgroundMode( TQt::TransparentMode );
}
if ( mi->popup() )
@ -3107,11 +3107,11 @@ void KlearlookStyle::drawComplexControl(
}
bool onControlButtons = false,
onToolbar = widget->parentWidget() && ::tqqt_cast<TQToolBar *>( widget->parentWidget() ),
onToolbar = widget->parentWidget() && ::tqt_cast<TQToolBar *>( widget->parentWidget() ),
onExtender = !onToolbar &&
widget->parentWidget() &&
widget->parentWidget() ->inherits( "TQToolBarExtensionWidget" ) &&
::tqqt_cast<TQToolBar *>( widget->parentWidget() ->parentWidget() );
::tqt_cast<TQToolBar *>( widget->parentWidget() ->parentWidget() );
if ( !onToolbar && !onExtender && widget->parentWidget() &&
!qstrcmp( widget->parentWidget() ->name(), "qt_maxcontrols" ) )
@ -3147,7 +3147,7 @@ void KlearlookStyle::drawComplexControl(
p->drawTiledPixmap( r,
*( toolbutton->parentWidget() ->backgroundPixmap() ), toolbutton->pos() );
} else if ( widget->parent() ) {
if ( ::tqqt_cast<const TQToolBar *>( widget->parent() ) ) {
if ( ::tqt_cast<const TQToolBar *>( widget->parent() ) ) {
TQToolBar * parent = ( TQToolBar* ) widget->parent();
#ifdef TQTC_GRADIENT_TOOLBARS_AND_MENUBARS
@ -3259,7 +3259,7 @@ void KlearlookStyle::drawComplexControl(
);
if ( ( controls & SC_SpinWidgetUp ) && up.isValid() ) {
TQ_PrimitiveElement pe = PE_SpinWidgetUp;
PrimitiveElement pe = PE_SpinWidgetUp;
SFlags upflags = flags;
if ( spinwidget->buttonSymbols() == TQSpinWidget::PlusMinus )
@ -3273,7 +3273,7 @@ void KlearlookStyle::drawComplexControl(
}
if ( ( controls & SC_SpinWidgetDown ) && down.isValid() ) {
TQ_PrimitiveElement pe = PE_SpinWidgetDown;
PrimitiveElement pe = PE_SpinWidgetDown;
SFlags downflags = flags;
if ( spinwidget->buttonSymbols() == TQSpinWidget::PlusMinus )
@ -3307,7 +3307,7 @@ void KlearlookStyle::drawComplexControl(
( hw && HOVER_SB_SUB == hover ? Style_MouseOver : Style_Default ) |
Style_Enabled |
( ( active == SC_ScrollBarSubLine ) ? Style_Down : Style_Default ) |
( ( scrollbar->orientation() == Qt::Horizontal ) ? Style_Horizontal : Style_Default )
( ( scrollbar->orientation() == TQt::Horizontal ) ? Style_Horizontal : Style_Default )
);
if ( ( controls & SC_ScrollBarAddLine ) && addline.isValid() )
drawPrimitive(
@ -3315,34 +3315,34 @@ void KlearlookStyle::drawComplexControl(
( hw && HOVER_SB_ADD == hover ? Style_MouseOver : Style_Default ) |
Style_Enabled |
( ( active == SC_ScrollBarAddLine ) ? Style_Down : Style_Default ) |
( ( scrollbar->orientation() == Qt::Horizontal ) ? Style_Horizontal : Style_Default )
( ( scrollbar->orientation() == TQt::Horizontal ) ? Style_Horizontal : Style_Default )
);
if ( ( controls & SC_ScrollBarSubPage ) && subpage.isValid() )
drawPrimitive( PE_ScrollBarSubPage, p, ceData, elementFlags, subpage, cg,
Style_Enabled |
( ( active == SC_ScrollBarSubPage ) ? Style_Down : Style_Default ) |
( ( scrollbar->orientation() == Qt::Horizontal ) ? Style_Horizontal : Style_Default ) );
( ( scrollbar->orientation() == TQt::Horizontal ) ? Style_Horizontal : Style_Default ) );
if ( ( controls & SC_ScrollBarAddPage ) && addpage.isValid() )
drawPrimitive( PE_ScrollBarAddPage, p, ceData, elementFlags, addpage, cg,
( ( scrollbar->minValue() == scrollbar->maxValue() ) ? Style_Default : Style_Enabled ) |
( ( active == SC_ScrollBarAddPage ) ? Style_Down : Style_Default ) |
( ( scrollbar->orientation() == Qt::Horizontal ) ? Style_Horizontal : Style_Default ) );
( ( scrollbar->orientation() == TQt::Horizontal ) ? Style_Horizontal : Style_Default ) );
if ( ( controls & SC_ScrollBarFirst ) && first.isValid() )
drawPrimitive( PE_ScrollBarFirst, p, ceData, elementFlags, first, cg,
Style_Enabled |
( ( active == SC_ScrollBarFirst ) ? Style_Down : Style_Default ) |
( ( scrollbar->orientation() == Qt::Horizontal ) ? Style_Horizontal : Style_Default ) );
( ( scrollbar->orientation() == TQt::Horizontal ) ? Style_Horizontal : Style_Default ) );
if ( ( controls & SC_ScrollBarLast ) && last.isValid() )
drawPrimitive( PE_ScrollBarLast, p, ceData, elementFlags, last, cg,
Style_Enabled |
( ( active == SC_ScrollBarLast ) ? Style_Down : Style_Default ) |
( ( scrollbar->orientation() == Qt::Horizontal ) ? Style_Horizontal : Style_Default ) );
( ( scrollbar->orientation() == TQt::Horizontal ) ? Style_Horizontal : Style_Default ) );
if ( ( controls & SC_ScrollBarSlider ) && slider.isValid() ) {
drawPrimitive( PE_ScrollBarSlider, p, ceData, elementFlags, slider, cg,
( hw && HOVER_SB_SLIDER == hover ? Style_MouseOver : Style_Default ) |
Style_Enabled |
( ( active == SC_ScrollBarSlider ) ? Style_Down : Style_Default ) |
( ( scrollbar->orientation() == Qt::Horizontal ) ? Style_Horizontal : Style_Default ) );
( ( scrollbar->orientation() == TQt::Horizontal ) ? Style_Horizontal : Style_Default ) );
// ### perhaps this should not be able to accept focus if maxedOut?
if ( scrollbar->hasFocus() )
@ -3371,7 +3371,7 @@ void KlearlookStyle::drawComplexControl(
}
}
TQRect KlearlookStyle::querySubControlMetrics( TQ_ComplexControl control, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, SubControl sc,
TQRect KlearlookStyle::querySubControlMetrics( ComplexControl control, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, SubControl sc,
const TQStyleOption &data, const TQWidget *widget ) const {
switch ( control ) {
case CC_SpinWidget: {
@ -3425,7 +3425,7 @@ int KlearlookStyle::pixelMetric( PixelMetric metric, const TQStyleControlElement
return 5;
case PM_TabBarTabShiftVertical: {
const TQTabBar *tb = ::tqqt_cast<const TQTabBar *>( widget );
const TQTabBar *tb = ::tqt_cast<const TQTabBar *>( widget );
return TQTabBar::RoundedAbove == tb->shape() || TQTabBar::TriangularAbove == tb->shape()
? 1
@ -3450,9 +3450,9 @@ int KlearlookStyle::pixelMetric( PixelMetric metric, const TQStyleControlElement
case PM_ButtonDefaultIndicator:
return IND_BORDER == defBtnIndicator ? 1 : 0;
case PM_DefaultFrameWidth:
return borderFrame && widget && ( ::tqqt_cast<const TQTabBar *>( widget ) ||
::tqqt_cast<const TQWidgetStack *>( widget ) ||
::tqqt_cast<const TQPopupMenu *>( widget ) )
return borderFrame && widget && ( ::tqt_cast<const TQTabBar *>( widget ) ||
::tqt_cast<const TQWidgetStack *>( widget ) ||
::tqt_cast<const TQPopupMenu *>( widget ) )
? 2
: TQTC_DEF_FRAME_WIDTH;
case PM_SpinBoxFrameWidth:
@ -3576,7 +3576,7 @@ TQSize KlearlookStyle::sizeFromContents( ContentsType t,
}
case CT_ToolButton: {
if ( widget->parent() && ::tqqt_cast<TQToolBar*>( widget->parent() ) )
if ( widget->parent() && ::tqt_cast<TQToolBar*>( widget->parent() ) )
return TQSize( s.width() + 2 * 4, s.height() + 2 * 4 );
else {
return TDEStyle::sizeFromContents ( t, ceData, elementFlags, s, opt, widget );
@ -3855,7 +3855,7 @@ void KlearlookStyle::drawSliderGroove
drawPrimitive( PE_FocusRect, p, ceData, elementFlags, fr, TQColorGroup() );
}
if ( Qt::Horizontal == slider->orientation() ) {
if ( TQt::Horizontal == slider->orientation() ) {
int dh = ( groove.height() - 5 ) >> 1;
groove.addCoords( 0, dh, 0, -dh );

10
src/gui/kdeext/klearlook.h
Unescape View File

@ -185,7 +185,7 @@ extern "C" {
#endif
class KlearlookStyle : public TDEStyle {
Q_OBJECT
TQ_OBJECT
public:
@ -252,11 +252,11 @@ class KlearlookStyle : public TDEStyle {
const TQColor &fill, const TQColor *custom = NULL, bool light = false ) const;
void drawLightBevelButton( TQPainter *p, const TQRect &r, const TQColorGroup &cg, TQStyle::SFlags flags, bool useGrad, ERound round,
const TQColor &fill, const TQColor *custom = NULL, bool light = false ) const;
void drawArrow( TQPainter *p, const TQRect &r, const TQColorGroup &cg, TQStyle::SFlags flags, TQStyle::TQ_PrimitiveElement pe,
void drawArrow( TQPainter *p, const TQRect &r, const TQColorGroup &cg, TQStyle::SFlags flags, TQStyle::PrimitiveElement pe,
bool small = false, bool checkActive = false ) const;
void drawPrimitive( TQ_PrimitiveElement, TQPainter *, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, const TQRect &, const TQColorGroup &, SFlags = Style_Default,
void drawPrimitive( PrimitiveElement, TQPainter *, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, const TQRect &, const TQColorGroup &, SFlags = Style_Default,
const TQStyleOption & = TQStyleOption::Default ) const;
void drawPrimitiveMenu( TQ_PrimitiveElement, TQPainter *, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, const TQRect &, const TQColorGroup &, SFlags = Style_Default,
void drawPrimitiveMenu( PrimitiveElement, TQPainter *, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, const TQRect &, const TQColorGroup &, SFlags = Style_Default,
const TQStyleOption & = TQStyleOption::Default ) const;
void drawTDEStylePrimitive( TDEStylePrimitive kpe, TQPainter* p, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, const TQRect &r,
const TQColorGroup &cg, SFlags flags, const TQStyleOption &opt, const TQWidget* widget = 0 ) const;
@ -270,7 +270,7 @@ class KlearlookStyle : public TDEStyle {
void drawComplexControl( ComplexControl, TQPainter *, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, const TQRect &, const TQColorGroup &,
SFlags = Style_Default, SCFlags = SC_All, SCFlags = SC_None,
const TQStyleOption & = TQStyleOption::Default, const TQWidget * = 0 ) const;
TQRect querySubControlMetrics( TQ_ComplexControl, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, SubControl,
TQRect querySubControlMetrics( ComplexControl, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, SubControl,
const TQStyleOption & = TQStyleOption::Default, const TQWidget * = 0 ) const;
int pixelMetric( PixelMetric, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, const TQWidget *widget = 0 ) const;
int kPixelMetric( TDEStylePixelMetric kpm, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, const TQWidget *widget ) const;

8
src/gui/rulers/ChordNameRuler.cpp
Unescape View File

@ -88,8 +88,8 @@ ChordNameRuler::ChordNameRuler(RulerScale *rulerScale,
m_compositionRefreshStatusId = m_composition->getNewRefreshStatusId();
TQObject::connect(doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()),
this, TQT_SLOT(update()));
TQObject::connect(doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQ_SLOT(update()));
TQToolTip::add
(this, i18n("Chord name ruler.\nTurn it on and off from the Settings->Rulers menu."));
@ -129,8 +129,8 @@ ChordNameRuler::ChordNameRuler(RulerScale *rulerScale,
m_compositionRefreshStatusId = m_composition->getNewRefreshStatusId();
TQObject::connect(doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()),
this, TQT_SLOT(update()));
TQObject::connect(doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQ_SLOT(update()));
for (std::vector<Segment *>::iterator i = segments.begin();
i != segments.end(); ++i) {

2
src/gui/rulers/ChordNameRuler.h
Unescape View File

@ -53,7 +53,7 @@ class Composition;
class ChordNameRuler : public TQWidget
{
Q_OBJECT
TQ_OBJECT
public:

12
src/gui/rulers/ControlRuler.cpp
Unescape View File

@ -86,8 +86,8 @@ ControlRuler::ControlRuler(Segment *segment,
setFixedHeight(sizeHint().height());
connect(this, TQT_SIGNAL(stateChange(const TQString&, bool)),
m_parentEditView, TQT_SLOT(slotStateChanged(const TQString&, bool)));
connect(this, TQ_SIGNAL(stateChange(const TQString&, bool)),
m_parentEditView, TQ_SLOT(slotStateChanged(const TQString&, bool)));
m_numberFloat = new TextFloat(this);
m_numberFloat->hide();
@ -162,7 +162,7 @@ ControlRuler::segmentDeleted(const Segment *)
void ControlRuler::contentsMousePressEvent(TQMouseEvent* e)
{
if (e->button() != Qt::LeftButton) {
if (e->button() != TQt::LeftButton) {
m_numberFloat->hide();
m_selecting = false;
return ;
@ -184,7 +184,7 @@ void ControlRuler::contentsMousePressEvent(TQMouseEvent* e)
// clear selection unless control was pressed, in which case
// add the event to the current selection
if (!(e->state() && TQ_ControlButton)) {
if (!(e->state() && ControlButton)) {
clearSelectedItems();
}
@ -214,7 +214,7 @@ void ControlRuler::contentsMousePressEvent(TQMouseEvent* e)
} else { // select it
if (!(e->state() && TQ_ControlButton)) {
if (!(e->state() && ControlButton)) {
if (item->z() > topItem->z())
topItem = item;
@ -243,7 +243,7 @@ void ControlRuler::contentsMousePressEvent(TQMouseEvent* e)
void ControlRuler::contentsMouseReleaseEvent(TQMouseEvent* e)
{
if (e->button() != Qt::LeftButton) {
if (e->button() != TQt::LeftButton) {
m_numberFloat->hide();
m_selecting = false;
return ;

2
src/gui/rulers/ControlRuler.h
Unescape View File

@ -59,7 +59,7 @@ class EditViewBase;
*/
class ControlRuler : public RosegardenCanvasView, public SegmentObserver
{
Q_OBJECT
TQ_OBJECT
friend class ControlItem;

12
src/gui/rulers/ControllerEventsRuler.cpp
Unescape View File

@ -272,7 +272,7 @@ void ControllerEventsRuler::insertControllerEvent()
number = m_controller->getControllerValue();
} else {
bool ok = false;
TQIntValidator intValidator(0, 128, TQT_TQOBJECT(this));
TQIntValidator intValidator(0, 128, this);
TQString res = KLineEditDlg::getText(i18n("Controller Event Number"), "0",
&ok, this, &intValidator);
if (ok)
@ -340,7 +340,7 @@ void ControllerEventsRuler::startControlLine()
void ControllerEventsRuler::contentsMousePressEvent(TQMouseEvent *e)
{
if (!m_controlLineShowing) {
if (e->button() == Qt::MidButton)
if (e->button() == TQt::MidButton)
m_lastEventPos = inverseMapPoint(e->pos());
ControlRuler::contentsMousePressEvent(e); // send super
@ -349,7 +349,7 @@ void ControllerEventsRuler::contentsMousePressEvent(TQMouseEvent *e)
}
// cancel control line mode
if (e->button() == Qt::RightButton) {
if (e->button() == TQt::RightButton) {
m_controlLineShowing = false;
m_controlLine->hide();
@ -357,7 +357,7 @@ void ControllerEventsRuler::contentsMousePressEvent(TQMouseEvent *e)
return ;
}
if (e->button() == Qt::LeftButton) {
if (e->button() == TQt::LeftButton) {
TQPoint p = inverseMapPoint(e->pos());
m_controlLine->show();
@ -371,7 +371,7 @@ void ControllerEventsRuler::contentsMousePressEvent(TQMouseEvent *e)
void ControllerEventsRuler::contentsMouseReleaseEvent(TQMouseEvent *e)
{
if (!m_controlLineShowing) {
if (e->button() == Qt::MidButton)
if (e->button() == TQt::MidButton)
insertControllerEvent();
ControlRuler::contentsMouseReleaseEvent(e); // send super
@ -407,7 +407,7 @@ void ControllerEventsRuler::contentsMouseMoveEvent(TQMouseEvent *e)
if (!m_controlLineShowing) {
// Don't send super if we're using the middle button
//
if (e->button() == Qt::MidButton) {
if (e->button() == TQt::MidButton) {
m_lastEventPos = inverseMapPoint(e->pos());
return ;
}

6
src/gui/rulers/LoopRuler.cpp
Unescape View File

@ -256,7 +256,7 @@ LoopRuler::mousePressEvent(TQMouseEvent *mE)
TQt::ButtonState bs = mE->state();
setLoopingMode((bs & TQt::ShiftButton) != 0);
if (mE->button() == Qt::LeftButton) {
if (mE->button() == TQt::LeftButton) {
double x = mE->pos().x() / getHScaleFactor() - m_currentXOffset - m_xorigin;
if (m_loopingMode) {
@ -278,7 +278,7 @@ LoopRuler::mousePressEvent(TQMouseEvent *mE)
void
LoopRuler::mouseReleaseEvent(TQMouseEvent *mE)
{
if (mE->button() == Qt::LeftButton) {
if (mE->button() == TQt::LeftButton) {
if (m_loopingMode) {
// Cancel the loop if there was no drag
//
@ -319,7 +319,7 @@ LoopRuler::mouseDoubleClickEvent(TQMouseEvent *mE)
RG_DEBUG << "LoopRuler::mouseDoubleClickEvent: x = " << x << ", looping = " << m_loopingMode << endl;
if (mE->button() == Qt::LeftButton && !m_loopingMode)
if (mE->button() == TQt::LeftButton && !m_loopingMode)
emit setPlayPosition(m_grid->snapX(x));
}

2
src/gui/rulers/LoopRuler.h
Unescape View File

@ -50,7 +50,7 @@ class RosegardenGUIDoc;
*/
class LoopRuler : public TQWidget, public HZoomable
{
Q_OBJECT
TQ_OBJECT
public:

20
src/gui/rulers/MarkerRuler.cpp
Unescape View File

@ -78,7 +78,7 @@ MarkerRuler::MarkerRuler(RosegardenGUIDoc *doc,
// Otherwise we'll end up adding all actions to the same
// (document-level) action collection regardless of which window
// we're in.
TQObject *probe = TQT_TQOBJECT(parent);
TQObject *probe = parent;
while (probe && !dynamic_cast<TDEMainWindow *>(probe)) probe = probe->parent();
if (probe) m_parentMainWindow = dynamic_cast<TDEMainWindow *>(probe);
@ -95,22 +95,22 @@ MarkerRuler::MarkerRuler(RosegardenGUIDoc *doc,
// don't become more event-specific in future...
icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/event-insert.png"));
new TDEAction(i18n("Insert Marker"), icon, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotInsertMarkerHere()), actionCollection(),
new TDEAction(i18n("Insert Marker"), icon, 0, this,
TQ_SLOT(slotInsertMarkerHere()), actionCollection(),
"insert_marker_here");
new TDEAction(i18n("Insert Marker at Playback Position"), 0, TQT_TQOBJECT(this),
TQT_SLOT(slotInsertMarkerAtPointer()), actionCollection(),
new TDEAction(i18n("Insert Marker at Playback Position"), 0, this,
TQ_SLOT(slotInsertMarkerAtPointer()), actionCollection(),
"insert_marker_at_pointer");
icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/event-delete.png"));
new TDEAction(i18n("Delete Marker"), icon, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotDeleteMarker()), actionCollection(),
new TDEAction(i18n("Delete Marker"), icon, 0, this,
TQ_SLOT(slotDeleteMarker()), actionCollection(),
"delete_marker");
icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/event-edit.png"));
new TDEAction(i18n("Edit Marker..."), icon, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotEditMarker()), actionCollection(),
new TDEAction(i18n("Edit Marker..."), icon, 0, this,
TQ_SLOT(slotEditMarker()), actionCollection(),
"edit_marker");
TQToolTip::add
@ -430,7 +430,7 @@ MarkerRuler::mousePressEvent(TQMouseEvent *e)
// if right-click, show popup menu
//
if (e->button() == Qt::RightButton) {
if (e->button() == TQt::RightButton) {
if (!m_menu)
createMenu();
if (m_menu) {

2
src/gui/rulers/MarkerRuler.h
Unescape View File

@ -46,7 +46,7 @@ class RosegardenGUIDoc;
class MarkerRuler : public TQWidget, public HZoomable, public KXMLGUIClient
{
Q_OBJECT
TQ_OBJECT
public:

4
src/gui/rulers/PercussionPitchRuler.cpp
Unescape View File

@ -178,7 +178,7 @@ void PercussionPitchRuler::mousePressEvent(TQMouseEvent *e)
{
TQt::ButtonState bs = e->state();
if (e->button() == Qt::LeftButton) {
if (e->button() == TQt::LeftButton) {
m_mouseDown = true;
m_selecting = (bs & TQt::ShiftButton);
@ -192,7 +192,7 @@ void PercussionPitchRuler::mousePressEvent(TQMouseEvent *e)
void PercussionPitchRuler::mouseReleaseEvent(TQMouseEvent *e)
{
if (e->button() == Qt::LeftButton) {
if (e->button() == TQt::LeftButton) {
m_mouseDown = false;
m_selecting = false;
}

2
src/gui/rulers/PercussionPitchRuler.h
Unescape View File

@ -43,7 +43,7 @@ class MidiKeyMapping;
class PercussionPitchRuler : public PitchRuler
{
Q_OBJECT
TQ_OBJECT
public:
PercussionPitchRuler(TQWidget *parent,

2
src/gui/rulers/PitchRuler.h
Unescape View File

@ -36,7 +36,7 @@ namespace Rosegarden
class PitchRuler : public TQWidget
{
Q_OBJECT
TQ_OBJECT
public:
PitchRuler(TQWidget *parent);

2
src/gui/rulers/PropertyBox.h
Unescape View File

@ -43,7 +43,7 @@ namespace Rosegarden
*/
class PropertyBox : public TQWidget
{
Q_OBJECT
TQ_OBJECT
public:

8
src/gui/rulers/PropertyControlRuler.cpp
Unescape View File

@ -236,7 +236,7 @@ PropertyControlRuler::contentsMousePressEvent(TQMouseEvent *e)
RG_DEBUG << "PropertyControlRuler::contentsMousePressEvent\n";
if (!m_propertyLineShowing) {
if (e->button() == Qt::MidButton)
if (e->button() == TQt::MidButton)
m_lastEventPos = inverseMapPoint(e->pos());
ControlRuler::contentsMousePressEvent(e); // send super
@ -245,7 +245,7 @@ PropertyControlRuler::contentsMousePressEvent(TQMouseEvent *e)
}
// cancel control line mode
if (e->button() == Qt::RightButton) {
if (e->button() == TQt::RightButton) {
m_propertyLineShowing = false;
m_propertyLine->hide();
@ -253,7 +253,7 @@ PropertyControlRuler::contentsMousePressEvent(TQMouseEvent *e)
return ;
}
if (e->button() == Qt::LeftButton) {
if (e->button() == TQt::LeftButton) {
TQPoint p = inverseMapPoint(e->pos());
m_propertyLine->show();
@ -319,7 +319,7 @@ PropertyControlRuler::contentsMouseMoveEvent(TQMouseEvent *e)
if (!m_propertyLineShowing) {
// Don't send super if we're using the middle button
//
if (e->button() == Qt::MidButton) {
if (e->button() == TQt::MidButton) {
m_lastEventPos = inverseMapPoint(e->pos());
return ;
}

2
src/gui/rulers/PropertyViewRuler.h
Unescape View File

@ -47,7 +47,7 @@ class RulerScale;
*/
class PropertyViewRuler : public TQWidget, public HZoomable
{
Q_OBJECT
TQ_OBJECT
public:

2
src/gui/rulers/RawNoteRuler.h
Unescape View File

@ -51,7 +51,7 @@ class DefaultVelocityColour;
class RawNoteRuler : public TQWidget
{
Q_OBJECT
TQ_OBJECT
public:

48
src/gui/rulers/StandardRuler.cpp
Unescape View File

@ -74,8 +74,8 @@ StandardRuler::StandardRuler(RosegardenGUIDoc *doc,
}
TQObject::connect
(doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()),
this, TQT_SLOT(update()));
(doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQ_SLOT(update()));
}
@ -94,49 +94,49 @@ void StandardRuler::connectRulerToDocPointer(RosegardenGUIDoc *doc)
// so they are re-emitted from the loop ruler by this widget
//
TQObject::connect
(m_loopRuler, TQT_SIGNAL(setPointerPosition(timeT)),
doc, TQT_SLOT(slotSetPointerPosition(timeT)));
(m_loopRuler, TQ_SIGNAL(setPointerPosition(timeT)),
doc, TQ_SLOT(slotSetPointerPosition(timeT)));
TQObject::connect
(m_hButtonBar, TQT_SIGNAL(setPointerPosition(timeT)),
doc, TQT_SLOT(slotSetPointerPosition(timeT)));
(m_hButtonBar, TQ_SIGNAL(setPointerPosition(timeT)),
doc, TQ_SLOT(slotSetPointerPosition(timeT)));
TQObject::connect
(m_hButtonBar, TQT_SIGNAL(editMarkers()),
RosegardenGUIApp::self(), TQT_SLOT(slotEditMarkers()));
(m_hButtonBar, TQ_SIGNAL(editMarkers()),
RosegardenGUIApp::self(), TQ_SLOT(slotEditMarkers()));
TQObject::connect
(m_hButtonBar, TQT_SIGNAL(addMarker(timeT)),
RosegardenGUIApp::self(), TQT_SLOT(slotAddMarker(timeT)));
(m_hButtonBar, TQ_SIGNAL(addMarker(timeT)),
RosegardenGUIApp::self(), TQ_SLOT(slotAddMarker(timeT)));
TQObject::connect
(m_hButtonBar, TQT_SIGNAL(deleteMarker(int, timeT, TQString, TQString)),
RosegardenGUIApp::self(), TQT_SLOT(slotDeleteMarker(int, timeT, TQString, TQString)));
(m_hButtonBar, TQ_SIGNAL(deleteMarker(int, timeT, TQString, TQString)),
RosegardenGUIApp::self(), TQ_SLOT(slotDeleteMarker(int, timeT, TQString, TQString)));
TQObject::connect
(m_loopRuler, TQT_SIGNAL(dragPointerToPosition(timeT)),
this, TQT_SIGNAL(dragPointerToPosition(timeT)));
(m_loopRuler, TQ_SIGNAL(dragPointerToPosition(timeT)),
this, TQ_SIGNAL(dragPointerToPosition(timeT)));
TQObject::connect
(m_loopRuler, TQT_SIGNAL(dragLoopToPosition(timeT)),
this, TQT_SIGNAL(dragLoopToPosition(timeT)));
(m_loopRuler, TQ_SIGNAL(dragLoopToPosition(timeT)),
this, TQ_SIGNAL(dragLoopToPosition(timeT)));
TQObject::connect
(m_loopRuler, TQT_SIGNAL(setPlayPosition(timeT)),
RosegardenGUIApp::self(), TQT_SLOT(slotSetPlayPosition(timeT)));
(m_loopRuler, TQ_SIGNAL(setPlayPosition(timeT)),
RosegardenGUIApp::self(), TQ_SLOT(slotSetPlayPosition(timeT)));
TQObject::connect
(m_hButtonBar, TQT_SIGNAL(setLoop(timeT, timeT)),
doc, TQT_SLOT(slotSetLoop(timeT, timeT)));
(m_hButtonBar, TQ_SIGNAL(setLoop(timeT, timeT)),
doc, TQ_SLOT(slotSetLoop(timeT, timeT)));
TQObject::connect
(m_loopRuler, TQT_SIGNAL(setLoop(timeT, timeT)),
doc, TQT_SLOT(slotSetLoop(timeT, timeT)));
(m_loopRuler, TQ_SIGNAL(setLoop(timeT, timeT)),
doc, TQ_SLOT(slotSetLoop(timeT, timeT)));
TQObject::connect
(doc, TQT_SIGNAL(loopChanged(timeT, timeT)),
(doc, TQ_SIGNAL(loopChanged(timeT, timeT)),
m_loopRuler,
TQT_SLOT(slotSetLoopMarker(timeT, timeT)));
TQ_SLOT(slotSetLoopMarker(timeT, timeT)));
m_loopRuler->setBackgroundColor(GUIPalette::getColour(GUIPalette::PointerRuler));
}

2
src/gui/rulers/StandardRuler.h
Unescape View File

@ -43,7 +43,7 @@ class SnapGrid;
class StandardRuler : public TQVBox
{
Q_OBJECT
TQ_OBJECT
public:

68
src/gui/rulers/TempoRuler.cpp
Unescape View File

@ -115,45 +115,45 @@ TempoRuler::TempoRuler(RulerScale *rulerScale,
setBackgroundMode(TQt::NoBackground);
TQObject::connect
(doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()),
this, TQT_SLOT(update()));
(doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQ_SLOT(update()));
TQString pixmapDir = TDEGlobal::dirs()->findResource("appdata", "pixmaps/");
TQIconSet icon;
icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/event-insert-tempo.png"));
new TDEAction(i18n("Insert Tempo Change"), icon, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotInsertTempoHere()), actionCollection(),
new TDEAction(i18n("Insert Tempo Change"), icon, 0, this,
TQ_SLOT(slotInsertTempoHere()), actionCollection(),
"insert_tempo_here");
new TDEAction(i18n("Insert Tempo Change at Playback Position"), 0, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotInsertTempoAtPointer()), actionCollection(),
new TDEAction(i18n("Insert Tempo Change at Playback Position"), 0, 0, this,
TQ_SLOT(slotInsertTempoAtPointer()), actionCollection(),
"insert_tempo_at_pointer");
icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/event-delete.png"));
new TDEAction(i18n("Delete Tempo Change"), icon, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotDeleteTempoChange()), actionCollection(),
new TDEAction(i18n("Delete Tempo Change"), icon, 0, this,
TQ_SLOT(slotDeleteTempoChange()), actionCollection(),
"delete_tempo");
new TDEAction(i18n("Ramp Tempo to Next Tempo"), 0, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotRampToNext()), actionCollection(),
new TDEAction(i18n("Ramp Tempo to Next Tempo"), 0, 0, this,
TQ_SLOT(slotRampToNext()), actionCollection(),
"ramp_to_next");
new TDEAction(i18n("Un-Ramp Tempo"), 0, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotUnramp()), actionCollection(),
new TDEAction(i18n("Un-Ramp Tempo"), 0, 0, this,
TQ_SLOT(slotUnramp()), actionCollection(),
"unramp");
icon = TQIconSet(TQPixmap(pixmapDir + "/toolbar/event-edit.png"));
new TDEAction(i18n("Edit Tempo..."), icon, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotEditTempo()), actionCollection(),
new TDEAction(i18n("Edit Tempo..."), icon, 0, this,
TQ_SLOT(slotEditTempo()), actionCollection(),
"edit_tempo");
new TDEAction(i18n("Edit Time Signature..."), 0, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotEditTimeSignature()), actionCollection(),
new TDEAction(i18n("Edit Time Signature..."), 0, 0, this,
TQ_SLOT(slotEditTimeSignature()), actionCollection(),
"edit_time_signature");
new TDEAction(i18n("Open Tempo and Time Signature Editor"), 0, 0, TQT_TQOBJECT(this),
TQT_SLOT(slotEditTempos()), actionCollection(),
new TDEAction(i18n("Open Tempo and Time Signature Editor"), 0, 0, this,
TQ_SLOT(slotEditTempos()), actionCollection(),
"edit_tempos");
setMouseTracking(false);
@ -172,47 +172,47 @@ void
TempoRuler::connectSignals()
{
connect(this,
TQT_SIGNAL(doubleClicked(timeT)),
TQ_SIGNAL(doubleClicked(timeT)),
RosegardenGUIApp::self(),
TQT_SLOT(slotEditTempos(timeT)));
TQ_SLOT(slotEditTempos(timeT)));
connect(this,
TQT_SIGNAL(changeTempo(timeT,
TQ_SIGNAL(changeTempo(timeT,
tempoT,
tempoT,
TempoDialog::TempoDialogAction)),
RosegardenGUIApp::self(),
TQT_SLOT(slotChangeTempo(timeT,
TQ_SLOT(slotChangeTempo(timeT,
tempoT,
tempoT,
TempoDialog::TempoDialogAction)));
connect(this,
TQT_SIGNAL(moveTempo(timeT,
TQ_SIGNAL(moveTempo(timeT,
timeT)),
RosegardenGUIApp::self(),
TQT_SLOT(slotMoveTempo(timeT,
TQ_SLOT(slotMoveTempo(timeT,
timeT)));
connect(this,
TQT_SIGNAL(deleteTempo(timeT)),
TQ_SIGNAL(deleteTempo(timeT)),
RosegardenGUIApp::self(),
TQT_SLOT(slotDeleteTempo(timeT)));
TQ_SLOT(slotDeleteTempo(timeT)));
connect(this,
TQT_SIGNAL(editTempo(timeT)),
TQ_SIGNAL(editTempo(timeT)),
RosegardenGUIApp::self(),
TQT_SLOT(slotEditTempo(timeT)));
TQ_SLOT(slotEditTempo(timeT)));
connect(this,
TQT_SIGNAL(editTimeSignature(timeT)),
TQ_SIGNAL(editTimeSignature(timeT)),
RosegardenGUIApp::self(),
TQT_SLOT(slotEditTimeSignature(timeT)));
TQ_SLOT(slotEditTimeSignature(timeT)));
connect(this,
TQT_SIGNAL(editTempos(timeT)),
TQ_SIGNAL(editTempos(timeT)),
RosegardenGUIApp::self(),
TQT_SLOT(slotEditTempos(timeT)));
TQ_SLOT(slotEditTempos(timeT)));
}
void
@ -239,7 +239,7 @@ TempoRuler::slotScrollHoriz(int x)
void
TempoRuler::mousePressEvent(TQMouseEvent *e)
{
if (e->button() == Qt::LeftButton) {
if (e->button() == TQt::LeftButton) {
if (e->type() == TQEvent::MouseButtonDblClick) {
timeT t = m_rulerScale->getTimeForX
@ -291,7 +291,7 @@ TempoRuler::mousePressEvent(TQMouseEvent *e)
m_dragHoriz = false;
}
} else if (e->button() == Qt::RightButton) {
} else if (e->button() == TQt::RightButton) {
m_clickX = e->x();
if (!m_menu)

2
src/gui/rulers/TempoRuler.h
Unescape View File

@ -57,7 +57,7 @@ class Composition;
class TempoRuler : public TQWidget, public KXMLGUIClient
{
Q_OBJECT
TQ_OBJECT
public:

2
src/gui/rulers/TextRuler.h
Unescape View File

@ -54,7 +54,7 @@ class RulerScale;
class TextRuler : public TQWidget
{
Q_OBJECT
TQ_OBJECT
public:

12
src/gui/seqmanager/MidiFilterDialog.cpp
Unescape View File

@ -52,7 +52,7 @@ MidiFilterDialog::MidiFilterDialog(TQWidget *parent,
m_thruBox =
new TQButtonGroup(1,
Qt::Horizontal,
TQt::Horizontal,
i18n("THRU events to ignore"), hBox);
TQCheckBox *noteThru = new TQCheckBox(i18n("Note"), m_thruBox);
@ -88,7 +88,7 @@ MidiFilterDialog::MidiFilterDialog(TQWidget *parent,
m_recordBox =
new TQButtonGroup(1,
Qt::Horizontal,
TQt::Horizontal,
i18n("RECORD events to ignore"), hBox);
TQCheckBox *noteRecord = new TQCheckBox(i18n("Note"), m_recordBox);
@ -124,11 +124,11 @@ MidiFilterDialog::MidiFilterDialog(TQWidget *parent,
sysRecord->setChecked(true);
connect(m_thruBox, TQT_SIGNAL(released(int)),
this, TQT_SLOT(slotSetModified()));
connect(m_thruBox, TQ_SIGNAL(released(int)),
this, TQ_SLOT(slotSetModified()));
connect(m_recordBox, TQT_SIGNAL(released(int)),
this, TQT_SLOT(slotSetModified()));
connect(m_recordBox, TQ_SIGNAL(released(int)),
this, TQ_SLOT(slotSetModified()));
setModified(false);
}

2
src/gui/seqmanager/MidiFilterDialog.h
Unescape View File

@ -38,7 +38,7 @@ class RosegardenGUIDoc;
class MidiFilterDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:
MidiFilterDialog(TQWidget *parent,

30
src/gui/seqmanager/SequenceManager.cpp
Unescape View File

@ -115,18 +115,18 @@ SequenceManager::SequenceManager(RosegardenGUIDoc *doc,
(m_doc->parent())->parentWidget());
// Connect these for use later
//
connect(m_countdownTimer, TQT_SIGNAL(timeout()),
this, TQT_SLOT(slotCountdownTimerTimeout()));
connect(m_countdownTimer, TQ_SIGNAL(timeout()),
this, TQ_SLOT(slotCountdownTimerTimeout()));
connect(m_reportTimer, TQT_SIGNAL(timeout()),
this, TQT_SLOT(slotAllowReport()));
connect(m_reportTimer, TQ_SIGNAL(timeout()),
this, TQ_SLOT(slotAllowReport()));
connect(m_compositionMmapperResetTimer, TQT_SIGNAL(timeout()),
this, TQT_SLOT(slotScheduledCompositionMmapperReset()));
connect(m_compositionMmapperResetTimer, TQ_SIGNAL(timeout()),
this, TQ_SLOT(slotScheduledCompositionMmapperReset()));
connect(doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()),
this, TQT_SLOT(update()));
connect(doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQ_SLOT(update()));
m_doc->getComposition().addObserver(this);
@ -162,7 +162,7 @@ void SequenceManager::setDocument(RosegardenGUIDoc* doc)
DataBlockRepository::clear();
m_doc->getComposition().removeObserver(this);
disconnect(m_doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()));
disconnect(m_doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()));
m_segments.clear();
m_triggerSegments.clear();
@ -188,14 +188,14 @@ void SequenceManager::setDocument(RosegardenGUIDoc* doc)
// Connect this for use later
//
connect(m_countdownTimer, TQT_SIGNAL(timeout()),
this, TQT_SLOT(slotCountdownTimerTimeout()));
connect(m_countdownTimer, TQ_SIGNAL(timeout()),
this, TQ_SLOT(slotCountdownTimerTimeout()));
m_compositionRefreshStatusId = comp.getNewRefreshStatusId();
comp.addObserver(this);
connect(m_doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()),
this, TQT_SLOT(update()));
connect(m_doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQ_SLOT(update()));
for (Composition::iterator i = comp.begin(); i != comp.end(); ++i) {
@ -215,8 +215,8 @@ void SequenceManager::setDocument(RosegardenGUIDoc* doc)
m_compositionMmapperResetTimer = new TQTimer(m_doc);
connect(m_compositionMmapperResetTimer, TQT_SIGNAL(timeout()),
this, TQT_SLOT(slotScheduledCompositionMmapperReset()));
connect(m_compositionMmapperResetTimer, TQ_SIGNAL(timeout()),
this, TQ_SLOT(slotScheduledCompositionMmapperReset()));
resetCompositionMmapper();

2
src/gui/seqmanager/SequenceManager.h
Unescape View File

@ -62,7 +62,7 @@ class AudioManagerDialog;
class SequenceManager : public TQObject, public CompositionObserver
{
Q_OBJECT
TQ_OBJECT
public:
SequenceManager(RosegardenGUIDoc *doc,

160
src/gui/studio/AudioMixerWindow.cpp
Unescape View File

@ -94,14 +94,14 @@ AudioMixerWindow::AudioMixerWindow(TQWidget *parent,
{
populate();
KStdAction::close(TQT_TQOBJECT(this),
TQT_SLOT(slotClose()),
KStdAction::close(this,
TQ_SLOT(slotClose()),
actionCollection());
TQIconSet icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-play")));
TDEAction *play = new TDEAction(i18n("&Play"), icon, Key_Enter, TQT_TQOBJECT(this),
TQT_SIGNAL(play()), actionCollection(), "play");
TDEAction *play = new TDEAction(i18n("&Play"), icon, Key_Enter, this,
TQ_SIGNAL(play()), actionCollection(), "play");
// Alternative shortcut for Play
TDEShortcut playShortcut = play->shortcut();
playShortcut.append( KKey(Key_Return + CTRL) );
@ -109,69 +109,69 @@ AudioMixerWindow::AudioMixerWindow(TQWidget *parent,
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-stop")));
new TDEAction(i18n("&Stop"), icon, Key_Insert, TQT_TQOBJECT(this),
TQT_SIGNAL(stop()), actionCollection(), "stop");
new TDEAction(i18n("&Stop"), icon, Key_Insert, this,
TQ_SIGNAL(stop()), actionCollection(), "stop");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-rewind")));
new TDEAction(i18n("Re&wind"), icon, Key_End, TQT_TQOBJECT(this),
TQT_SIGNAL(rewindPlayback()), actionCollection(),
new TDEAction(i18n("Re&wind"), icon, Key_End, this,
TQ_SIGNAL(rewindPlayback()), actionCollection(),
"playback_pointer_back_bar");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-ffwd")));
new TDEAction(i18n("&Fast Forward"), icon, Key_PageDown, TQT_TQOBJECT(this),
TQT_SIGNAL(fastForwardPlayback()), actionCollection(),
new TDEAction(i18n("&Fast Forward"), icon, Key_PageDown, this,
TQ_SIGNAL(fastForwardPlayback()), actionCollection(),
"playback_pointer_forward_bar");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-rewind-end")));
new TDEAction(i18n("Rewind to &Beginning"), icon, 0, TQT_TQOBJECT(this),
TQT_SIGNAL(rewindPlaybackToBeginning()), actionCollection(),
new TDEAction(i18n("Rewind to &Beginning"), icon, 0, this,
TQ_SIGNAL(rewindPlaybackToBeginning()), actionCollection(),
"playback_pointer_start");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-ffwd-end")));
new TDEAction(i18n("Fast Forward to &End"), icon, 0, TQT_TQOBJECT(this),
TQT_SIGNAL(fastForwardPlaybackToEnd()), actionCollection(),
new TDEAction(i18n("Fast Forward to &End"), icon, 0, this,
TQ_SIGNAL(fastForwardPlaybackToEnd()), actionCollection(),
"playback_pointer_end");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-record")));
new TDEAction(i18n("&Record"), icon, 0, TQT_TQOBJECT(this),
TQT_SIGNAL(record()), actionCollection(),
new TDEAction(i18n("&Record"), icon, 0, this,
TQ_SIGNAL(record()), actionCollection(),
"record");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-panic")));
new TDEAction(i18n("Panic"), icon, Key_P + CTRL + ALT, TQT_TQOBJECT(this),
TQT_SIGNAL(panic()), actionCollection(),
new TDEAction(i18n("Panic"), icon, Key_P + CTRL + ALT, this,
TQ_SIGNAL(panic()), actionCollection(),
"panic");
unsigned int mixerOptions = m_studio->getMixerDisplayOptions();
(new TDEToggleAction(i18n("Show Audio &Faders"), 0, TQT_TQOBJECT(this),
TQT_SLOT(slotToggleFaders()), actionCollection(),
(new TDEToggleAction(i18n("Show Audio &Faders"), 0, this,
TQ_SLOT(slotToggleFaders()), actionCollection(),
"show_audio_faders"))->setChecked
(!(mixerOptions & MIXER_OMIT_FADERS));
(new TDEToggleAction(i18n("Show Synth &Faders"), 0, TQT_TQOBJECT(this),
TQT_SLOT(slotToggleSynthFaders()), actionCollection(),
(new TDEToggleAction(i18n("Show Synth &Faders"), 0, this,
TQ_SLOT(slotToggleSynthFaders()), actionCollection(),
"show_synth_faders"))->setChecked
(!(mixerOptions & MIXER_OMIT_SYNTH_FADERS));
(new TDEToggleAction(i18n("Show &Submasters"), 0, TQT_TQOBJECT(this),
TQT_SLOT(slotToggleSubmasters()), actionCollection(),
(new TDEToggleAction(i18n("Show &Submasters"), 0, this,
TQ_SLOT(slotToggleSubmasters()), actionCollection(),
"show_audio_submasters"))->setChecked
(!(mixerOptions & MIXER_OMIT_SUBMASTERS));
(new TDEToggleAction(i18n("Show &Plugin Buttons"), 0, TQT_TQOBJECT(this),
TQT_SLOT(slotTogglePluginButtons()), actionCollection(),
(new TDEToggleAction(i18n("Show &Plugin Buttons"), 0, this,
TQ_SLOT(slotTogglePluginButtons()), actionCollection(),
"show_plugin_buttons"))->setChecked
(!(mixerOptions & MIXER_OMIT_PLUGINS));
(new TDEToggleAction(i18n("Show &Unassigned Faders"), 0, TQT_TQOBJECT(this),
TQT_SLOT(slotToggleUnassignedFaders()), actionCollection(),
(new TDEToggleAction(i18n("Show &Unassigned Faders"), 0, this,
TQ_SLOT(slotToggleUnassignedFaders()), actionCollection(),
"show_unassigned_faders"))->setChecked
(mixerOptions & MIXER_SHOW_UNASSIGNED_FADERS);
@ -180,8 +180,8 @@ AudioMixerWindow::AudioMixerWindow(TQWidget *parent,
for (int i = 1; i <= 16; i *= 2) {
action =
new TDERadioAction(i18n("1 Input", "%n Inputs", i),
0, TQT_TQOBJECT(this),
TQT_SLOT(slotSetInputCountFromAction()), actionCollection(),
0, this,
TQ_SLOT(slotSetInputCountFromAction()), actionCollection(),
TQString("inputs_%1").arg(i).ascii());
action->setExclusiveGroup("inputs");
if (i == int(m_studio->getRecordIns().size()))
@ -190,8 +190,8 @@ AudioMixerWindow::AudioMixerWindow(TQWidget *parent,
action = new TDERadioAction
(i18n("No Submasters"),
0, TQT_TQOBJECT(this),
TQT_SLOT(slotSetSubmasterCountFromAction()), actionCollection(),
0, this,
TQ_SLOT(slotSetSubmasterCountFromAction()), actionCollection(),
TQString("submasters_0").ascii());
action->setExclusiveGroup("submasters");
action->setChecked(true);
@ -199,8 +199,8 @@ AudioMixerWindow::AudioMixerWindow(TQWidget *parent,
for (int i = 2; i <= 8; i *= 2) {
action = new TDERadioAction
(i18n("1 Submaster", "%n Submasters", i),
0, TQT_TQOBJECT(this),
TQT_SLOT(slotSetSubmasterCountFromAction()), actionCollection(),
0, this,
TQ_SLOT(slotSetSubmasterCountFromAction()), actionCollection(),
TQString("submasters_%1").arg(i).ascii());
action->setExclusiveGroup("submasters");
if (i == int(m_studio->getBusses().size()) - 1)
@ -388,8 +388,8 @@ AudioMixerWindow::populate()
TQToolTip::add
(plugin, i18n("Audio plugin button"));
rec.m_plugins.push_back(plugin);
connect(plugin, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotSelectPlugin()));
connect(plugin, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotSelectPlugin()));
}
TQLabel *idLabel;
@ -441,30 +441,30 @@ AudioMixerWindow::populate()
updatePluginButtons((*i)->getId());
if (rec.m_input) {
connect(rec.m_input, TQT_SIGNAL(changed()),
this, TQT_SLOT(slotInputChanged()));
connect(rec.m_input, TQ_SIGNAL(changed()),
this, TQ_SLOT(slotInputChanged()));
}
connect(rec.m_output, TQT_SIGNAL(changed()),
this, TQT_SLOT(slotOutputChanged()));
connect(rec.m_output, TQ_SIGNAL(changed()),
this, TQ_SLOT(slotOutputChanged()));
connect(rec.m_fader, TQT_SIGNAL(faderChanged(float)),
this, TQT_SLOT(slotFaderLevelChanged(float)));
connect(rec.m_fader, TQ_SIGNAL(faderChanged(float)),
this, TQ_SLOT(slotFaderLevelChanged(float)));
connect(rec.m_pan, TQT_SIGNAL(valueChanged(float)),
this, TQT_SLOT(slotPanChanged(float)));
connect(rec.m_pan, TQ_SIGNAL(valueChanged(float)),
this, TQ_SLOT(slotPanChanged(float)));
connect(rec.m_soloButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotSoloChanged()));
connect(rec.m_soloButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotSoloChanged()));
connect(rec.m_muteButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotMuteChanged()));
connect(rec.m_muteButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotMuteChanged()));
connect(rec.m_stereoButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotChannelsChanged()));
connect(rec.m_stereoButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotChannelsChanged()));
connect(rec.m_recordButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotRecordChanged()));
connect(rec.m_recordButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotRecordChanged()));
++count;
@ -519,8 +519,8 @@ AudioMixerWindow::populate()
TQToolTip::add
(plugin, i18n("Audio plugin button"));
rec.m_plugins.push_back(plugin);
connect(plugin, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotSelectPlugin()));
connect(plugin, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotSelectPlugin()));
}
TQLabel *idLabel = new TQLabel(i18n("Sub %1").arg(count), m_mainBox, "subMaster");
@ -546,14 +546,14 @@ AudioMixerWindow::populate()
updateFader(count);
updatePluginButtons(count);
connect(rec.m_fader, TQT_SIGNAL(faderChanged(float)),
this, TQT_SLOT(slotFaderLevelChanged(float)));
connect(rec.m_fader, TQ_SIGNAL(faderChanged(float)),
this, TQ_SLOT(slotFaderLevelChanged(float)));
connect(rec.m_pan, TQT_SIGNAL(valueChanged(float)),
this, TQT_SLOT(slotPanChanged(float)));
connect(rec.m_pan, TQ_SIGNAL(valueChanged(float)),
this, TQ_SLOT(slotPanChanged(float)));
connect(rec.m_muteButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotMuteChanged()));
connect(rec.m_muteButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotMuteChanged()));
++count;
@ -597,11 +597,11 @@ AudioMixerWindow::populate()
m_master = rec;
updateFader(0);
connect(rec.m_fader, TQT_SIGNAL(faderChanged(float)),
this, TQT_SLOT(slotFaderLevelChanged(float)));
connect(rec.m_fader, TQ_SIGNAL(faderChanged(float)),
this, TQ_SLOT(slotFaderLevelChanged(float)));
connect(rec.m_muteButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotMuteChanged()));
connect(rec.m_muteButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotMuteChanged()));
}
m_mainBox->show();
@ -940,7 +940,7 @@ AudioMixerWindow::updatePluginButtons(int id)
void
AudioMixerWindow::slotSelectPlugin()
{
const TQObject *s = TQT_TQOBJECT_CONST(const_cast<const TQT_BASE_OBJECT_NAME*>(sender()));
const TQObject *s = sender();
for (FaderMap::iterator i = m_faders.begin();
i != m_faders.end(); ++i) {
@ -952,7 +952,7 @@ AudioMixerWindow::slotSelectPlugin()
for (std::vector<TQPushButton *>::iterator pli = i->second.m_plugins.begin();
pli != i->second.m_plugins.end(); ++pli) {
if (TQT_BASE_OBJECT(*pli) == TQT_BASE_OBJECT_CONST(s)) {
if (*pli == s) {
emit selectPlugin(this, i->first, index);
return ;
@ -975,7 +975,7 @@ AudioMixerWindow::slotSelectPlugin()
for (std::vector<TQPushButton *>::iterator pli = i->m_plugins.begin();
pli != i->m_plugins.end(); ++pli) {
if (TQT_BASE_OBJECT(*pli) == TQT_BASE_OBJECT_CONST(s)) {
if (*pli == s) {
emit selectPlugin(this, b, index);
return ;
@ -991,7 +991,7 @@ AudioMixerWindow::slotSelectPlugin()
void
AudioMixerWindow::slotInputChanged()
{
const TQObject *s = TQT_TQOBJECT_CONST(const_cast<const TQT_BASE_OBJECT_NAME*>(sender()));
const TQObject *s = sender();
for (FaderMap::iterator i = m_faders.begin();
i != m_faders.end(); ++i) {
@ -1004,7 +1004,7 @@ AudioMixerWindow::slotInputChanged()
void
AudioMixerWindow::slotOutputChanged()
{
const TQObject *s = TQT_TQOBJECT_CONST(const_cast<const TQT_BASE_OBJECT_NAME*>(sender()));
const TQObject *s = sender();
for (FaderMap::iterator i = m_faders.begin();
i != m_faders.end(); ++i) {
@ -1058,11 +1058,11 @@ AudioMixerWindow::sendControllerRefresh()
void
AudioMixerWindow::slotFaderLevelChanged(float dB)
{
const TQObject *s = TQT_TQOBJECT_CONST(const_cast<const TQT_BASE_OBJECT_NAME*>(sender()));
const TQObject *s = sender();
BussList busses = m_studio->getBusses();
if (TQT_BASE_OBJECT(m_master.m_fader) == TQT_BASE_OBJECT_CONST(s)) {
if (m_master.m_fader == s) {
if (busses.size() > 0) {
StudioControl::setStudioObjectProperty
@ -1080,7 +1080,7 @@ AudioMixerWindow::slotFaderLevelChanged(float dB)
for (FaderVector::iterator i = m_submasters.begin();
i != m_submasters.end(); ++i) {
if (TQT_BASE_OBJECT(i->m_fader) == TQT_BASE_OBJECT_CONST(s)) {
if (i->m_fader == s) {
if ((int)busses.size() > index) {
StudioControl::setStudioObjectProperty
(MappedObjectId(busses[index]->getMappedId()),
@ -1100,7 +1100,7 @@ AudioMixerWindow::slotFaderLevelChanged(float dB)
for (FaderMap::iterator i = m_faders.begin();
i != m_faders.end(); ++i) {
if (TQT_BASE_OBJECT(i->second.m_fader) == TQT_BASE_OBJECT_CONST(s)) {
if (i->second.m_fader == s) {
Instrument *instrument =
m_studio->getInstrumentById(i->first);
@ -1138,7 +1138,7 @@ AudioMixerWindow::slotFaderLevelChanged(float dB)
void
AudioMixerWindow::slotPanChanged(float pan)
{
const TQObject *s = TQT_TQOBJECT_CONST(const_cast<const TQT_BASE_OBJECT_NAME*>(sender()));
const TQObject *s = sender();
BussList busses = m_studio->getBusses();
@ -1147,7 +1147,7 @@ AudioMixerWindow::slotPanChanged(float pan)
for (FaderVector::iterator i = m_submasters.begin();
i != m_submasters.end(); ++i) {
if (TQT_BASE_OBJECT(i->m_pan) == TQT_BASE_OBJECT_CONST(s)) {
if (i->m_pan == s) {
if ((int)busses.size() > index) {
StudioControl::setStudioObjectProperty
(MappedObjectId(busses[index]->getMappedId()),
@ -1166,7 +1166,7 @@ AudioMixerWindow::slotPanChanged(float pan)
for (FaderMap::iterator i = m_faders.begin();
i != m_faders.end(); ++i) {
if (TQT_BASE_OBJECT(i->second.m_pan) == TQT_BASE_OBJECT_CONST(s)) {
if (i->second.m_pan == s) {
Instrument *instrument =
m_studio->getInstrumentById(i->first);
@ -1206,7 +1206,7 @@ AudioMixerWindow::slotPanChanged(float pan)
void
AudioMixerWindow::slotChannelsChanged()
{
const TQObject *s = TQT_TQOBJECT_CONST(const_cast<const TQT_BASE_OBJECT_NAME*>(sender()));
const TQObject *s = sender();
// channels are only switchable on instruments
@ -1216,7 +1216,7 @@ AudioMixerWindow::slotChannelsChanged()
for (FaderMap::iterator i = m_faders.begin();
i != m_faders.end(); ++i) {
if (TQT_BASE_OBJECT_CONST(s) == TQT_BASE_OBJECT(i->second.m_stereoButton)) {
if (s == i->second.m_stereoButton) {
Instrument *instrument =
m_studio->getInstrumentById(i->first);
@ -1442,7 +1442,7 @@ AudioMixerWindow::slotControllerDeviceEventReceived(MappedEvent *e,
void
AudioMixerWindow::slotSetInputCountFromAction()
{
const TQObject *s = TQT_TQOBJECT_CONST(const_cast<const TQT_BASE_OBJECT_NAME*>(sender()));
const TQObject *s = sender();
TQString name = s->name();
if (name.left(7) == "inputs_") {
@ -1473,7 +1473,7 @@ AudioMixerWindow::slotSetInputCountFromAction()
void
AudioMixerWindow::slotSetSubmasterCountFromAction()
{
const TQObject *s = TQT_TQOBJECT_CONST(const_cast<const TQT_BASE_OBJECT_NAME*>(sender()));
const TQObject *s = sender();
TQString name = s->name();
if (name.left(11) == "submasters_") {

2
src/gui/studio/AudioMixerWindow.h
Unescape View File

@ -51,7 +51,7 @@ class AudioRouteMenu;
class AudioMixerWindow : public MixerWindow
{
Q_OBJECT
TQ_OBJECT
public:

70
src/gui/studio/BankEditorDialog.cpp
Unescape View File

@ -113,10 +113,10 @@ BankEditorDialog::BankEditorDialog(TQWidget *parent,
layout->addWidget(m_closeButton);
layout->addSpacing(5);
connect(m_applyButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotApply()));
connect(m_resetButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotReset()));
connect(m_applyButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotApply()));
connect(m_resetButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotReset()));
//
// Left-side list view
@ -191,8 +191,8 @@ BankEditorDialog::BankEditorDialog(TQWidget *parent,
(m_pastePrograms,
i18n("Paste Program names from clipboard to current Bank"));
connect(m_listView, TQT_SIGNAL(currentChanged(TQListViewItem*)),
this, TQT_SLOT(slotPopulateDevice(TQListViewItem*)));
connect(m_listView, TQ_SIGNAL(currentChanged(TQListViewItem*)),
this, TQ_SLOT(slotPopulateDevice(TQListViewItem*)));
TQFrame *vbox = new TQFrame(splitter);
TQVBoxLayout *vboxLayout = new TQVBoxLayout(vbox, 8, 6);
@ -217,44 +217,44 @@ BankEditorDialog::BankEditorDialog(TQWidget *parent,
m_variationCombo->insertItem(i18n("MSB"));
// device/bank modification
connect(m_listView, TQT_SIGNAL(itemRenamed (TQListViewItem*, const TQString&, int)),
this, TQT_SLOT(slotModifyDeviceOrBankName(TQListViewItem*, const TQString&, int)));
connect(m_listView, TQ_SIGNAL(itemRenamed (TQListViewItem*, const TQString&, int)),
this, TQ_SLOT(slotModifyDeviceOrBankName(TQListViewItem*, const TQString&, int)));
connect(m_addBank, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotAddBank()));
connect(m_addBank, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotAddBank()));
connect(m_addKeyMapping, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotAddKeyMapping()));
connect(m_addKeyMapping, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotAddKeyMapping()));
connect(m_delete, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotDelete()));
connect(m_delete, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotDelete()));
connect(m_deleteAll, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotDeleteAll()));
connect(m_deleteAll, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotDeleteAll()));
connect(m_importBanks, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotImport()));
connect(m_importBanks, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotImport()));
connect(m_exportBanks, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotExport()));
connect(m_exportBanks, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotExport()));
connect(m_copyPrograms, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotEditCopy()));
connect(m_copyPrograms, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotEditCopy()));
connect(m_pastePrograms, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotEditPaste()));
connect(m_pastePrograms, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotEditPaste()));
connect(m_variationToggle, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotVariationToggled()));
connect(m_variationToggle, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotVariationToggled()));
connect(m_variationCombo, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotVariationChanged(int)));
connect(m_variationCombo, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotVariationChanged(int)));
setupActions();
m_doc->getCommandHistory()->attachView(actionCollection());
connect(m_doc->getCommandHistory(), TQT_SIGNAL(commandExecuted()),
this, TQT_SLOT(slotUpdate()));
connect(m_doc->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQ_SLOT(slotUpdate()));
// Initialise the dialog
//
@ -301,14 +301,14 @@ BankEditorDialog::~BankEditorDialog()
void
BankEditorDialog::setupActions()
{
TDEAction* close = KStdAction::close (TQT_TQOBJECT(this), TQT_SLOT(slotFileClose()), actionCollection());
TDEAction* close = KStdAction::close (this, TQ_SLOT(slotFileClose()), actionCollection());
m_closeButton->setText(close->text());
connect(m_closeButton, TQT_SIGNAL(clicked()),
TQT_TQOBJECT(this), TQT_SLOT(slotFileClose()));
connect(m_closeButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotFileClose()));
KStdAction::copy (TQT_TQOBJECT(this), TQT_SLOT(slotEditCopy()), actionCollection());
KStdAction::paste (TQT_TQOBJECT(this), TQT_SLOT(slotEditPaste()), actionCollection());
KStdAction::copy (this, TQ_SLOT(slotEditCopy()), actionCollection());
KStdAction::paste (this, TQ_SLOT(slotEditPaste()), actionCollection());
// some adjustments

2
src/gui/studio/BankEditorDialog.h
Unescape View File

@ -57,7 +57,7 @@ class MidiDevice;
class BankEditorDialog : public TDEMainWindow
{
Q_OBJECT
TQ_OBJECT
public:

12
src/gui/studio/DeviceEditorDialog.cpp
Unescape View File

@ -90,11 +90,11 @@ DeviceEditorDialog::DeviceEditorDialog(TQWidget *parent,
TQPushButton *addButton = new TQPushButton(i18n("Add Play Device"), hbox);
TQPushButton *addRButton = new TQPushButton(i18n("Add Record Device"), hbox);
TQPushButton *deleteButton = new TQPushButton(i18n("Delete Device"), hbox);
connect(addButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotAddPlayDevice()));
connect(addRButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotAddRecordDevice()));
connect(deleteButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotDeleteDevice()));
connect(m_table, TQT_SIGNAL(valueChanged(int, int)),
this, TQT_SLOT(slotValueChanged (int, int)));
connect(addButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotAddPlayDevice()));
connect(addRButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotAddRecordDevice()));
connect(deleteButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotDeleteDevice()));
connect(m_table, TQ_SIGNAL(valueChanged(int, int)),
this, TQ_SLOT(slotValueChanged (int, int)));
setMinimumHeight(250);
@ -219,7 +219,7 @@ DeviceEditorDialog::makeConnectionList(unsigned int direction,
TQDataStream reply(replyData, IO_ReadOnly);
TQString connection;
if (replyType == TQSTRING_OBJECT_NAME_STRING) {
if (replyType == "TQString") {
reply >> connection;
list.append(connection);
}

2
src/gui/studio/DeviceEditorDialog.h
Unescape View File

@ -42,7 +42,7 @@ class RosegardenGUIDoc;
class DeviceEditorDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:
DeviceEditorDialog(TQWidget *parent, RosegardenGUIDoc *document);

54
src/gui/studio/DeviceManagerDialog.cpp
Unescape View File

@ -93,7 +93,7 @@ DeviceManagerDialog::DeviceManagerDialog(TQWidget *parent,
setCaption(i18n("Manage MIDI Devices"));
TQGroupBox *groupBox = new TQGroupBox(2, Qt::Horizontal, i18n("Play devices"), mainBox);
TQGroupBox *groupBox = new TQGroupBox(2, TQt::Horizontal, i18n("Play devices"), mainBox);
m_playTable = new TQTable(0, 2, groupBox);
m_playTable->setSorting(false);
@ -109,7 +109,7 @@ DeviceManagerDialog::DeviceManagerDialog(TQWidget *parent,
TQFrame *frame = new TQFrame(groupBox);
TQVBoxLayout *vlayout = new TQVBoxLayout(frame);
TQGrid *buttons = new TQGrid(2, Qt::Horizontal, frame);
TQGrid *buttons = new TQGrid(2, TQt::Horizontal, frame);
TQPushButton *addButton = new TQPushButton(i18n("New"), buttons);
m_deletePlayButton = new TQPushButton(i18n("Delete"), buttons);
m_importButton = new TQPushButton(i18n("Import..."), buttons);
@ -138,20 +138,20 @@ DeviceManagerDialog::DeviceManagerDialog(TQWidget *parent,
(m_controllersButton,
i18n("View and edit Control Events for the selected device - these are special Event types that you can define against your device and control through Control Rulers or the Instrument Parameter Box "));
connect(addButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotAddPlayDevice()));
connect(m_deletePlayButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotDeletePlayDevice()));
connect(m_importButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotImport()));
connect(m_exportButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotExport()));
connect(m_banksButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotSetBanks()));
connect(m_controllersButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotSetControllers()));
connect(addButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotAddPlayDevice()));
connect(m_deletePlayButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotDeletePlayDevice()));
connect(m_importButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotImport()));
connect(m_exportButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotExport()));
connect(m_banksButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotSetBanks()));
connect(m_controllersButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotSetControllers()));
connect(m_playTable, TQT_SIGNAL(valueChanged(int, int)),
this, TQT_SLOT(slotPlayValueChanged (int, int)));
connect(m_playTable, TQT_SIGNAL(currentChanged(int, int)),
this, TQT_SLOT(slotPlayDeviceSelected (int, int)));
connect(m_playTable, TQ_SIGNAL(valueChanged(int, int)),
this, TQ_SLOT(slotPlayValueChanged (int, int)));
connect(m_playTable, TQ_SIGNAL(currentChanged(int, int)),
this, TQ_SLOT(slotPlayDeviceSelected (int, int)));
mainLayout->addWidget(groupBox);
groupBox = new TQGroupBox(2, Qt::Horizontal, i18n("Record devices"), mainBox);
groupBox = new TQGroupBox(2, TQt::Horizontal, i18n("Record devices"), mainBox);
m_recordTable = new TQTable(0, 3, groupBox);
m_recordTable->setSorting(false);
@ -168,7 +168,7 @@ DeviceManagerDialog::DeviceManagerDialog(TQWidget *parent,
frame = new TQFrame(groupBox);
vlayout = new TQVBoxLayout(frame);
buttons = new TQGrid(2, Qt::Horizontal, frame);
buttons = new TQGrid(2, TQt::Horizontal, frame);
addButton = new TQPushButton(i18n("New"), buttons);
m_deleteRecordButton = new TQPushButton(i18n("Delete"), buttons);
vlayout->addWidget(buttons);
@ -181,15 +181,15 @@ DeviceManagerDialog::DeviceManagerDialog(TQWidget *parent,
(m_deleteRecordButton,
i18n("Delete the selected device"));
connect(addButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotAddRecordDevice()));
connect(m_deleteRecordButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotDeleteRecordDevice()));
connect(addButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotAddRecordDevice()));
connect(m_deleteRecordButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotDeleteRecordDevice()));
connect(m_recordTable, TQT_SIGNAL(currentChanged(int, int)),
this, TQT_SLOT(slotRecordDeviceSelected (int, int)));
connect(m_recordTable, TQT_SIGNAL(valueChanged(int, int)),
this, TQT_SLOT(slotRecordValueChanged (int, int)));
connect(m_recordTable, TQ_SIGNAL(currentChanged(int, int)),
this, TQ_SLOT(slotRecordDeviceSelected (int, int)));
connect(m_recordTable, TQ_SIGNAL(valueChanged(int, int)),
this, TQ_SLOT(slotRecordValueChanged (int, int)));
connect(document, TQT_SIGNAL(devicesResyncd()), this, TQT_SLOT(slotDevicesResyncd()));
connect(document, TQ_SIGNAL(devicesResyncd()), this, TQ_SLOT(slotDevicesResyncd()));
m_noConnectionString = i18n("No connection");
@ -212,12 +212,12 @@ DeviceManagerDialog::DeviceManagerDialog(TQWidget *parent,
layout->addWidget(closeButton);
layout->addSpacing(5);
TDEAction* close = KStdAction::close(TQT_TQOBJECT(this),
TQT_SLOT(slotClose()),
TDEAction* close = KStdAction::close(this,
TQ_SLOT(slotClose()),
actionCollection());
closeButton->setText(close->text());
connect(closeButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotClose()));
connect(closeButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotClose()));
mainLayout->addWidget(btnBox);
@ -237,8 +237,8 @@ DeviceManagerDialog::DeviceManagerDialog(TQWidget *parent,
createGUI("devicemanager.rc");
m_document->getCommandHistory()->attachView(actionCollection());
connect(m_document->getCommandHistory(), TQT_SIGNAL(commandExecuted()),
this, TQT_SLOT(populate()));
connect(m_document->getCommandHistory(), TQ_SIGNAL(commandExecuted()),
this, TQ_SLOT(populate()));
m_playTable->setCurrentCell( -1, 0);
m_recordTable->setCurrentCell( -1, 0);
@ -441,7 +441,7 @@ DeviceManagerDialog::DeviceManagerDialog(TQWidget *parent,
TQDataStream reply(replyData, IO_ReadOnly);
TQString connection;
if (replyType == TQSTRING_OBJECT_NAME_STRING) {
if (replyType == "TQString") {
reply >> connection;
list.append(connection);
}

2
src/gui/studio/DeviceManagerDialog.h
Unescape View File

@ -46,7 +46,7 @@ class MidiDevice;
class DeviceManagerDialog : public TDEMainWindow
{
Q_OBJECT
TQ_OBJECT
public:
DeviceManagerDialog(TQWidget *parent, RosegardenGUIDoc *document);

2
src/gui/studio/MidiKeyMappingEditor.cpp
Unescape View File

@ -160,7 +160,7 @@ MidiKeyMappingEditor::slotNameChanged(const TQString& name)
return ;
}
TQString senderName = TQT_TQOBJECT_CONST(sender())->name();
TQString senderName = sender()->name();
// Adjust value back to zero rated
//

2
src/gui/studio/MidiKeyMappingEditor.h
Unescape View File

@ -42,7 +42,7 @@ class BankEditorDialog;
class MidiKeyMappingEditor : public NameSetEditor
{
Q_OBJECT
TQ_OBJECT
public:

56
src/gui/studio/MidiMixerWindow.cpp
Unescape View File

@ -70,14 +70,14 @@ MidiMixerWindow::MidiMixerWindow(TQWidget *parent,
//
setupTabs();
KStdAction::close(TQT_TQOBJECT(this),
TQT_SLOT(slotClose()),
KStdAction::close(this,
TQ_SLOT(slotClose()),
actionCollection());
TQIconSet icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-play")));
TDEAction *play = new TDEAction(i18n("&Play"), icon, Key_Enter, TQT_TQOBJECT(this),
TQT_SIGNAL(play()), actionCollection(), "play");
TDEAction *play = new TDEAction(i18n("&Play"), icon, Key_Enter, this,
TQ_SIGNAL(play()), actionCollection(), "play");
// Alternative shortcut for Play
TDEShortcut playShortcut = play->shortcut();
playShortcut.append( KKey(Key_Return + CTRL) );
@ -85,43 +85,43 @@ MidiMixerWindow::MidiMixerWindow(TQWidget *parent,
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-stop")));
new TDEAction(i18n("&Stop"), icon, Key_Insert, TQT_TQOBJECT(this),
TQT_SIGNAL(stop()), actionCollection(), "stop");
new TDEAction(i18n("&Stop"), icon, Key_Insert, this,
TQ_SIGNAL(stop()), actionCollection(), "stop");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-rewind")));
new TDEAction(i18n("Re&wind"), icon, Key_End, TQT_TQOBJECT(this),
TQT_SIGNAL(rewindPlayback()), actionCollection(),
new TDEAction(i18n("Re&wind"), icon, Key_End, this,
TQ_SIGNAL(rewindPlayback()), actionCollection(),
"playback_pointer_back_bar");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-ffwd")));
new TDEAction(i18n("&Fast Forward"), icon, Key_PageDown, TQT_TQOBJECT(this),
TQT_SIGNAL(fastForwardPlayback()), actionCollection(),
new TDEAction(i18n("&Fast Forward"), icon, Key_PageDown, this,
TQ_SIGNAL(fastForwardPlayback()), actionCollection(),
"playback_pointer_forward_bar");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-rewind-end")));
new TDEAction(i18n("Rewind to &Beginning"), icon, 0, TQT_TQOBJECT(this),
TQT_SIGNAL(rewindPlaybackToBeginning()), actionCollection(),
new TDEAction(i18n("Rewind to &Beginning"), icon, 0, this,
TQ_SIGNAL(rewindPlaybackToBeginning()), actionCollection(),
"playback_pointer_start");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-ffwd-end")));
new TDEAction(i18n("Fast Forward to &End"), icon, 0, TQT_TQOBJECT(this),
TQT_SIGNAL(fastForwardPlaybackToEnd()), actionCollection(),
new TDEAction(i18n("Fast Forward to &End"), icon, 0, this,
TQ_SIGNAL(fastForwardPlaybackToEnd()), actionCollection(),
"playback_pointer_end");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-record")));
new TDEAction(i18n("&Record"), icon, 0, TQT_TQOBJECT(this),
TQT_SIGNAL(record()), actionCollection(),
new TDEAction(i18n("&Record"), icon, 0, this,
TQ_SIGNAL(record()), actionCollection(),
"record");
icon = TQIconSet(NotePixmapFactory::toTQPixmap(NotePixmapFactory::makeToolbarPixmap
("transport-panic")));
new TDEAction(i18n("Panic"), icon, Key_P + CTRL + ALT, TQT_TQOBJECT(this),
TQT_SIGNAL(panic()), actionCollection(),
new TDEAction(i18n("Panic"), icon, Key_P + CTRL + ALT, this,
TQ_SIGNAL(panic()), actionCollection(),
"panic");
createGUI("midimixer.rc");
@ -144,8 +144,8 @@ MidiMixerWindow::setupTabs()
//
m_tabWidget = new TQTabWidget(this);
setCentralWidget(m_tabWidget);
connect(m_tabWidget, TQT_SIGNAL(currentChanged(TQWidget *)),
this, TQT_SLOT(slotCurrentTabChanged(TQWidget *)));
connect(m_tabWidget, TQ_SIGNAL(currentChanged(TQWidget *)),
this, TQ_SLOT(slotCurrentTabChanged(TQWidget *)));
m_tabWidget->setTabPosition(TQTabWidget::Bottom);
setCaption(i18n("MIDI Mixer"));
@ -246,8 +246,8 @@ MidiMixerWindow::setupTabs()
controller->setKnobColour(knobColour);
connect(controller, TQT_SIGNAL(valueChanged(float)),
this, TQT_SLOT(slotControllerChanged(float)));
connect(controller, TQ_SIGNAL(valueChanged(float)),
this, TQ_SLOT(slotControllerChanged(float)));
mainLayout->addWidget(controller, i + 1, posCount,
TQt::AlignCenter);
@ -291,8 +291,8 @@ MidiMixerWindow::setupTabs()
// Connect them up
//
connect(fader, TQT_SIGNAL(faderChanged(float)),
this, TQT_SLOT(slotFaderLevelChanged(float)));
connect(fader, TQ_SIGNAL(faderChanged(float)),
this, TQ_SLOT(slotFaderLevelChanged(float)));
// Update all the faders and controllers
//
@ -321,11 +321,11 @@ MidiMixerWindow::addTab(TQWidget *tab, const TQString &title)
void
MidiMixerWindow::slotFaderLevelChanged(float value)
{
const TQObject *s = TQT_TQOBJECT_CONST(const_cast<const TQT_BASE_OBJECT_NAME*>(sender()));
const TQObject *s = sender();
for (FaderVector::const_iterator it = m_faders.begin();
it != m_faders.end(); ++it) {
if (TQT_BASE_OBJECT((*it)->m_volumeFader) == TQT_BASE_OBJECT_CONST(s)) {
if ((*it)->m_volumeFader == s) {
Instrument *instr = m_studio->
getInstrumentById((*it)->m_id);
@ -374,12 +374,12 @@ MidiMixerWindow::slotFaderLevelChanged(float value)
void
MidiMixerWindow::slotControllerChanged(float value)
{
const TQObject *s = TQT_TQOBJECT_CONST(const_cast<const TQT_BASE_OBJECT_NAME*>(sender()));
const TQObject *s = sender();
unsigned int i = 0, j = 0;
for (i = 0; i < m_faders.size(); ++i) {
for (j = 0; j < m_faders[i]->m_controllerRotaries.size(); ++j) {
if (TQT_BASE_OBJECT(m_faders[i]->m_controllerRotaries[j].second) == TQT_BASE_OBJECT_CONST(s))
if (m_faders[i]->m_controllerRotaries[j].second == s)
break;
}

2
src/gui/studio/MidiMixerWindow.h
Unescape View File

@ -47,7 +47,7 @@ class Fader;
class MidiMixerWindow : public MixerWindow
{
Q_OBJECT
TQ_OBJECT
public:

20
src/gui/studio/MidiProgramsEditor.cpp
Unescape View File

@ -91,8 +91,8 @@ MidiProgramsEditor::makeAdditionalWidget(TQWidget *parent)
gridLayout->addWidget(new TQLabel(i18n("Percussion"), frame),
0, 0, AlignLeft);
gridLayout->addWidget(m_percussion, 0, 1, AlignLeft);
connect(m_percussion, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotNewPercussion()));
connect(m_percussion, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotNewPercussion()));
gridLayout->addWidget(new TQLabel(i18n("MSB Value"), frame),
1, 0, AlignLeft);
@ -108,8 +108,8 @@ MidiProgramsEditor::makeAdditionalWidget(TQWidget *parent)
(m_lsb,
i18n("Selects a LSB controller Bank number (MSB/LSB pairs are always unique for any Device)"));
connect(m_msb, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotNewMSB(int)));
connect(m_msb, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotNewMSB(int)));
gridLayout->addWidget(new TQLabel(i18n("LSB Value"), frame),
2, 0, AlignLeft);
@ -117,8 +117,8 @@ MidiProgramsEditor::makeAdditionalWidget(TQWidget *parent)
m_lsb->setMaxValue(127);
gridLayout->addWidget(m_lsb, 2, 1, AlignLeft);
connect(m_lsb, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotNewLSB(int)));
connect(m_lsb, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotNewLSB(int)));
return frame;
}
@ -389,7 +389,7 @@ MidiProgramsEditor::slotNameChanged(const TQString& programName)
return ;
}
TQString senderName = TQT_TQOBJECT_CONST(sender())->name();
TQString senderName = sender()->name();
// Adjust value back to zero rated
//
@ -442,7 +442,7 @@ MidiProgramsEditor::slotNameChanged(const TQString& programName)
void
MidiProgramsEditor::slotEntryButtonPressed()
{
TQPushButton* button = dynamic_cast<TQPushButton*>(TQT_TQWIDGET(const_cast<TQT_BASE_OBJECT_NAME*>(sender())));
TQPushButton* button = dynamic_cast<TQPushButton*>(const_cast<TQObject*>(sender()));
if (!button) {
RG_DEBUG << "MidiProgramsEditor::slotEntryButtonPressed() : %%% ERROR - signal sender is not a TQPushButton\n";
return ;
@ -472,12 +472,12 @@ MidiProgramsEditor::slotEntryButtonPressed()
int currentEntry = 0;
menu->insertItem(i18n("<no key mapping>"), this,
TQT_SLOT(slotEntryMenuItemSelected(int)), 0, 0);
TQ_SLOT(slotEntryMenuItemSelected(int)), 0, 0);
menu->setItemParameter(0, 0);
for (int i = 0; i < kml.size(); ++i) {
menu->insertItem(strtoqstr(kml[i].getName()),
this, TQT_SLOT(slotEntryMenuItemSelected(int)),
this, TQ_SLOT(slotEntryMenuItemSelected(int)),
0, i + 1);
menu->setItemParameter(i + 1, i + 1);
if (currentMapping && (kml[i] == *currentMapping))

2
src/gui/studio/MidiProgramsEditor.h
Unescape View File

@ -45,7 +45,7 @@ class BankEditorDialog;
class MidiProgramsEditor : public NameSetEditor
{
Q_OBJECT
TQ_OBJECT
public:
MidiProgramsEditor(BankEditorDialog *bankEditor,

2
src/gui/studio/MixerWindow.h
Unescape View File

@ -41,7 +41,7 @@ class RosegardenGUIDoc;
class MixerWindow: public TDEMainWindow
{
Q_OBJECT
TQ_OBJECT
public:

14
src/gui/studio/NameSetEditor.cpp
Unescape View File

@ -62,7 +62,7 @@ NameSetEditor::NameSetEditor(BankEditorDialog* bankEditor,
// Librarian
//
TQGroupBox *groupBox = new TQGroupBox(2,
Qt::Horizontal,
TQt::Horizontal,
i18n("Librarian"),
m_mainFrame);
m_mainLayout->addMultiCellWidget(groupBox, 0, 2, 3, 5);
@ -103,9 +103,9 @@ NameSetEditor::NameSetEditor(BankEditorDialog* bankEditor,
// Initial label; button to adjust whether labels start at 0 or 1
m_initialLabel = new TQPushButton(numberText, numBox);
connect(m_initialLabel,
TQT_SIGNAL(clicked()),
TQ_SIGNAL(clicked()),
this,
TQT_SLOT(slotToggleInitialLabel()));
TQ_SLOT(slotToggleInitialLabel()));
} else {
TQLabel *label = new TQLabel(numberText, numBox);
label->setFixedWidth(40);
@ -120,8 +120,8 @@ NameSetEditor::NameSetEditor(BankEditorDialog* bankEditor,
button->setMaximumWidth(40);
button->setMaximumHeight(20);
button->setFlat(true);
connect(button, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotEntryButtonPressed()));
connect(button, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotEntryButtonPressed()));
m_entryButtons.push_back(button);
}
@ -132,9 +132,9 @@ NameSetEditor::NameSetEditor(BankEditorDialog* bankEditor,
m_names.push_back(lineEdit);
connect(m_names[labelId],
TQT_SIGNAL(textChanged(const TQString&)),
TQ_SIGNAL(textChanged(const TQString&)),
this,
TQT_SLOT(slotNameChanged(const TQString&)));
TQ_SLOT(slotNameChanged(const TQString&)));
++labelId;
}

2
src/gui/studio/NameSetEditor.h
Unescape View File

@ -46,7 +46,7 @@ class BankEditorDialog;
class NameSetEditor : public TQVGroupBox
{
Q_OBJECT
TQ_OBJECT
public:
virtual void clearAll() = 0;

8
src/gui/studio/RemapInstrumentDialog.cpp
Unescape View File

@ -56,7 +56,7 @@ RemapInstrumentDialog::RemapInstrumentDialog(TQWidget *parent,
{
TQVBox *vBox = makeVBoxMainWidget();
m_buttonGroup = new TQButtonGroup(1, Qt::Horizontal,
m_buttonGroup = new TQButtonGroup(1, TQt::Horizontal,
i18n("Device or Instrument"),
vBox);
@ -65,10 +65,10 @@ RemapInstrumentDialog::RemapInstrumentDialog(TQWidget *parent,
m_instrumentButton = new TQRadioButton(i18n("Instrument"), m_buttonGroup);
connect(m_buttonGroup, TQT_SIGNAL(released(int)),
this, TQT_SLOT(slotRemapReleased(int)));
connect(m_buttonGroup, TQ_SIGNAL(released(int)),
this, TQ_SLOT(slotRemapReleased(int)));
TQGroupBox *groupBox = new TQGroupBox(2, Qt::Horizontal,
TQGroupBox *groupBox = new TQGroupBox(2, TQt::Horizontal,
i18n("Choose Source and Destination"),
vBox);

2
src/gui/studio/RemapInstrumentDialog.h
Unescape View File

@ -44,7 +44,7 @@ class MultiViewCommandHistory;
class RemapInstrumentDialog : public KDialogBase
{
Q_OBJECT
TQ_OBJECT
public:
RemapInstrumentDialog(TQWidget *parent,

28
src/gui/studio/SynthPluginManagerDialog.cpp
Unescape View File

@ -73,7 +73,7 @@ SynthPluginManagerDialog::SynthPluginManagerDialog(TQWidget *parent,
TQVBoxLayout *mainLayout = new TQVBoxLayout(mainBox, 10, 10);
TQGroupBox *groupBox = new TQGroupBox(1, Qt::Horizontal, i18n("Synth plugins"), mainBox);
TQGroupBox *groupBox = new TQGroupBox(1, TQt::Horizontal, i18n("Synth plugins"), mainBox);
mainLayout->addWidget(groupBox);
TQFrame *pluginFrame = new TQFrame(groupBox);
@ -133,8 +133,8 @@ SynthPluginManagerDialog::SynthPluginManagerDialog(TQWidget *parent,
}
}
connect(pluginCombo, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotPluginChanged(int)));
connect(pluginCombo, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotPluginChanged(int)));
pluginLayout->addWidget(pluginCombo, i, 1);
@ -142,7 +142,7 @@ SynthPluginManagerDialog::SynthPluginManagerDialog(TQWidget *parent,
TQPushButton *controlsButton = new TQPushButton(i18n("Controls"), pluginFrame);
pluginLayout->addWidget(controlsButton, i, 2);
connect(controlsButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotControlsButtonClicked()));
connect(controlsButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotControlsButtonClicked()));
m_controlsButtons.push_back(controlsButton);
#ifdef HAVE_LIBLO
@ -151,7 +151,7 @@ SynthPluginManagerDialog::SynthPluginManagerDialog(TQWidget *parent,
pluginLayout->addWidget(guiButton, i, 3);
guiButton->setEnabled(m_guiManager->hasGUI
(id, Instrument::SYNTH_PLUGIN_POSITION));
connect(guiButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotGUIButtonClicked()));
connect(guiButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotGUIButtonClicked()));
m_guiButtons.push_back(guiButton);
#endif
@ -169,12 +169,12 @@ SynthPluginManagerDialog::SynthPluginManagerDialog(TQWidget *parent,
layout->addWidget(closeButton);
layout->addSpacing(5);
TDEAction* close = KStdAction::close(TQT_TQOBJECT(this),
TQT_SLOT(slotClose()),
TDEAction* close = KStdAction::close(this,
TQ_SLOT(slotClose()),
actionCollection());
closeButton->setText(close->text());
connect(closeButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotClose()));
connect(closeButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotClose()));
mainLayout->addWidget(btnBox);
@ -231,12 +231,12 @@ SynthPluginManagerDialog::SynthPluginManagerDialog(TQWidget *parent,
void
SynthPluginManagerDialog::slotGUIButtonClicked()
{
const TQObject *s = TQT_TQOBJECT_CONST(const_cast<const TQT_BASE_OBJECT_NAME*>(sender()));
const TQObject *s = sender();
int instrumentNo = -1;
for (unsigned int i = 0; i < m_guiButtons.size(); ++i) {
if (TQT_BASE_OBJECT_CONST(s) == TQT_BASE_OBJECT(m_guiButtons[i]))
if (s == m_guiButtons[i])
instrumentNo = i;
}
@ -253,12 +253,12 @@ SynthPluginManagerDialog::SynthPluginManagerDialog(TQWidget *parent,
void
SynthPluginManagerDialog::slotControlsButtonClicked()
{
const TQObject *s = TQT_TQOBJECT_CONST(const_cast<const TQT_BASE_OBJECT_NAME*>(sender()));
const TQObject *s = sender();
int instrumentNo = -1;
for (unsigned int i = 0; i < m_controlsButtons.size(); ++i) {
if (TQT_BASE_OBJECT_CONST(s) == TQT_BASE_OBJECT(m_controlsButtons[i]))
if (s == m_controlsButtons[i])
instrumentNo = i;
}
@ -275,7 +275,7 @@ SynthPluginManagerDialog::SynthPluginManagerDialog(TQWidget *parent,
void
SynthPluginManagerDialog::slotPluginChanged(int index)
{
const TQObject *s = TQT_TQOBJECT_CONST(const_cast<const TQT_BASE_OBJECT_NAME*>(sender()));
const TQObject *s = sender();
RG_DEBUG << "SynthPluginManagerDialog::slotPluginChanged(" << index
<< ")" << endl;
@ -283,7 +283,7 @@ SynthPluginManagerDialog::SynthPluginManagerDialog(TQWidget *parent,
int instrumentNo = -1;
for (unsigned int i = 0; i < m_synthCombos.size(); ++i) {
if (TQT_BASE_OBJECT_CONST(s) == TQT_BASE_OBJECT(m_synthCombos[i]))
if (s == m_synthCombos[i])
instrumentNo = i;
}

2
src/gui/studio/SynthPluginManagerDialog.h
Unescape View File

@ -45,7 +45,7 @@ class AudioPluginManager;
class SynthPluginManagerDialog : public TDEMainWindow
{
Q_OBJECT
TQ_OBJECT
public:

2
src/gui/studio/TimerCallbackAssistant.cpp
Unescape View File

@ -36,7 +36,7 @@ TimerCallbackAssistant::TimerCallbackAssistant(int ms, void (*callback)(void *da
m_data(data)
{
TQTimer *timer = new TQTimer(this);
connect(timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotCallback()));
connect(timer, TQ_SIGNAL(timeout()), this, TQ_SLOT(slotCallback()));
timer->start(ms, FALSE);
}

2
src/gui/studio/TimerCallbackAssistant.h
Unescape View File

@ -38,7 +38,7 @@ namespace Rosegarden
class TimerCallbackAssistant : public TQObject
{
Q_OBJECT
TQ_OBJECT
public:

16
src/gui/widgets/AudioFaderBox.cpp
Unescape View File

@ -60,7 +60,7 @@ AudioFaderBox::AudioFaderBox(TQWidget *parent,
bool haveInOut,
const char *name):
TQFrame(parent, name),
m_signalMapper(new TQSignalMapper(TQT_TQOBJECT(this))),
m_signalMapper(new TQSignalMapper(this)),
m_id(id),
m_isStereo(false)
{
@ -80,9 +80,9 @@ AudioFaderBox::AudioFaderBox(TQWidget *parent,
(plugin, i18n("Audio plugin button"));
m_plugins.push_back(plugin);
m_signalMapper->setMapping(TQT_TQOBJECT(plugin), i);
connect(plugin, TQT_SIGNAL(clicked()),
m_signalMapper, TQT_SLOT(map()));
m_signalMapper->setMapping(plugin, i);
connect(plugin, TQ_SIGNAL(clicked()),
m_signalMapper, TQ_SLOT(map()));
}
m_synthButton = new TQPushButton(this);
@ -127,8 +127,8 @@ AudioFaderBox::AudioFaderBox(TQWidget *parent,
m_stereoButton->setPixmap(m_monoPixmap); // default is mono
m_stereoButton->setFixedSize(24, 24);
connect(m_stereoButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotChannelStateChanged()));
connect(m_stereoButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotChannelStateChanged()));
m_synthGUIButton = new TQPushButton(this);
m_synthGUIButton->setText(i18n("Editor"));
@ -242,8 +242,8 @@ bool
AudioFaderBox::owns(const TQObject *object)
{
return (object &&
((TQT_BASE_OBJECT(object->parent()) == TQT_BASE_OBJECT(this)) ||
(object->parent() && (TQT_BASE_OBJECT(object->parent()->parent()) == TQT_BASE_OBJECT(this)))));
((object->parent() == this) ||
(object->parent() && (object->parent()->parent() == this))));
}
void

2
src/gui/widgets/AudioFaderBox.h
Unescape View File

@ -49,7 +49,7 @@ class AudioRouteMenu;
class AudioFaderBox : public TQFrame
{
Q_OBJECT
TQ_OBJECT
public:

8
src/gui/widgets/AudioRouteMenu.cpp
Unescape View File

@ -58,15 +58,15 @@ AudioRouteMenu::AudioRouteMenu(TQWidget *par,
case Compact: {
m_combo = 0;
m_button = new WheelyButton(par);
connect(m_button, TQT_SIGNAL(wheel(bool)), this, TQT_SLOT(slotWheel(bool)));
connect(m_button, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotShowMenu()));
connect(m_button, TQ_SIGNAL(wheel(bool)), this, TQ_SLOT(slotWheel(bool)));
connect(m_button, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotShowMenu()));
break;
}
case Regular: {
m_button = 0;
m_combo = new KComboBox(par);
connect(m_combo, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotEntrySelected(int)));
connect(m_combo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotEntrySelected(int)));
break;
}
@ -135,7 +135,7 @@ AudioRouteMenu::slotShowMenu()
for (int i = 0; i < getNumEntries(); ++i) {
menu->insertItem(getEntryText(i), this, TQT_SLOT(slotEntrySelected(int)),
menu->insertItem(getEntryText(i), this, TQ_SLOT(slotEntrySelected(int)),
0, i);
menu->setItemParameter(i, i);
}

2
src/gui/widgets/AudioRouteMenu.h
Unescape View File

@ -41,7 +41,7 @@ class Instrument;
class AudioRouteMenu : public TQObject
{
Q_OBJECT
TQ_OBJECT
public:

2
src/gui/widgets/BigArrowButton.h
Unescape View File

@ -30,7 +30,7 @@ namespace Rosegarden {
class BigArrowButton : public KArrowButton
{
public:
BigArrowButton(TQWidget *parent = 0, Qt::ArrowType arrow = Qt::UpArrow,
BigArrowButton(TQWidget *parent = 0, TQt::ArrowType arrow = TQt::UpArrow,
const char *name = 0) :
KArrowButton(parent, arrow, name) { }
virtual ~BigArrowButton() { }

2
src/gui/widgets/CollapsingFrame.cpp
Unescape View File

@ -62,7 +62,7 @@ CollapsingFrame::CollapsingFrame(TQString label, TQWidget *parent, const char *n
TQPixmap pixmap(pixmapDir + "/misc/arrow-expanded.png");
m_toggleButton->setIconSet(pixmap);
connect(m_toggleButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(toggle()));
connect(m_toggleButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(toggle()));
m_layout->addMultiCellWidget(m_toggleButton, 0, 0, 0, 2);
}

2
src/gui/widgets/CollapsingFrame.h
Unescape View File

@ -39,7 +39,7 @@ namespace Rosegarden
class CollapsingFrame : public TQFrame
{
Q_OBJECT
TQ_OBJECT
public:

4
src/gui/widgets/ColourTable.cpp
Unescape View File

@ -49,8 +49,8 @@ ColourTable::ColourTable
horizontalHeader()->setLabel(0, i18n("Name"));
horizontalHeader()->setLabel(1, i18n("Color"));
populate_table(input, list);
connect(this, TQT_SIGNAL(doubleClicked(int, int, int, const TQPoint&)),
TQT_SLOT(slotEditEntry(int, int)));
connect(this, TQ_SIGNAL(doubleClicked(int, int, int, const TQPoint&)),
TQ_SLOT(slotEditEntry(int, int)));
}

2
src/gui/widgets/ColourTable.h
Unescape View File

@ -43,7 +43,7 @@ class ColourMap;
class ColourTable : public TQTable
{
Q_OBJECT
TQ_OBJECT
public:

4
src/gui/widgets/CurrentProgressDialog.cpp
Unescape View File

@ -54,8 +54,8 @@ CurrentProgressDialog::set(ProgressDialog* d)
m_currentProgressDialog = d;
// this lets the progress dialog deregister itself when it's deleted
connect(d, TQT_SIGNAL(destroyed()),
getInstance(), TQT_SLOT(slotCurrentProgressDialogDestroyed()));
connect(d, TQ_SIGNAL(destroyed()),
getInstance(), TQ_SLOT(slotCurrentProgressDialogDestroyed()));
}
void CurrentProgressDialog::freeze()

2
src/gui/widgets/CurrentProgressDialog.h
Unescape View File

@ -36,7 +36,7 @@ class ProgressDialog;
class CurrentProgressDialog : public TQObject
{
Q_OBJECT
TQ_OBJECT
public:
static CurrentProgressDialog* getInstance();

50
src/gui/widgets/DiatonicPitchChooser.cpp
Unescape View File

@ -45,7 +45,7 @@ DiatonicPitchChooser::DiatonicPitchChooser(TQString title,
int defaultNote,
int defaultPitch,
int defaultOctave) :
TQGroupBox(1, Qt::Horizontal, title, parent),
TQGroupBox(1, TQt::Horizontal, title, parent),
m_defaultPitch(defaultPitch)
{
m_pitchDragLabel = new PitchDragLabel(this, defaultPitch);
@ -89,41 +89,41 @@ DiatonicPitchChooser::DiatonicPitchChooser(TQString title,
m_pitchLabel->setMinimumWidth(40);
connect(m_accidental, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotSetAccidental(int)));
connect(m_accidental, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotSetAccidental(int)));
connect(m_octave, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotSetOctave(int)));
connect(m_octave, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotSetOctave(int)));
connect(m_step, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotSetStep(int)));
connect(m_step, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotSetStep(int)));
//connect(m_pitch, TQT_SIGNAL(valueChanged(int)),
// this, TQT_SIGNAL(pitchChanged(int)));
//connect(m_pitch, TQ_SIGNAL(valueChanged(int)),
// this, TQ_SIGNAL(pitchChanged(int)));
//connect(m_pitch, TQT_SIGNAL(valueChanged(int)),
// this, TQT_SIGNAL(preview(int)));
//connect(m_pitch, TQ_SIGNAL(valueChanged(int)),
// this, TQ_SIGNAL(preview(int)));
connect(m_pitchDragLabel, TQT_SIGNAL(pitchDragged(int,int,int)),
this, TQT_SLOT(slotSetNote(int,int,int)));
connect(m_pitchDragLabel, TQ_SIGNAL(pitchDragged(int,int,int)),
this, TQ_SLOT(slotSetNote(int,int,int)));
//connect(m_pitchDragLabel, TQT_SIGNAL(pitchChanged(int)),
// this, TQT_SLOT(slotSetPitch(int)));
//connect(m_pitchDragLabel, TQ_SIGNAL(pitchChanged(int)),
// this, TQ_SLOT(slotSetPitch(int)));
connect(m_pitchDragLabel, TQT_SIGNAL(pitchChanged(int,int,int)),
this, TQT_SLOT(slotSetNote(int,int,int)));
connect(m_pitchDragLabel, TQ_SIGNAL(pitchChanged(int,int,int)),
this, TQ_SLOT(slotSetNote(int,int,int)));
//connect(m_pitchDragLabel, TQT_SIGNAL(pitchChanged(int)),
// this, TQT_SIGNAL(pitchChanged(int)));
//connect(m_pitchDragLabel, TQ_SIGNAL(pitchChanged(int)),
// this, TQ_SIGNAL(pitchChanged(int)));
connect(m_pitchDragLabel, TQT_SIGNAL(pitchDragged(int,int,int)),
this, TQT_SIGNAL(noteChanged(int,int,int)));
connect(m_pitchDragLabel, TQ_SIGNAL(pitchDragged(int,int,int)),
this, TQ_SIGNAL(noteChanged(int,int,int)));
connect(m_pitchDragLabel, TQT_SIGNAL(pitchChanged(int,int,int)),
this, TQT_SIGNAL(noteChanged(int,int,int)));
connect(m_pitchDragLabel, TQ_SIGNAL(pitchChanged(int,int,int)),
this, TQ_SIGNAL(noteChanged(int,int,int)));
connect(m_pitchDragLabel, TQT_SIGNAL(preview(int)),
this, TQT_SIGNAL(preview(int)));
connect(m_pitchDragLabel, TQ_SIGNAL(preview(int)),
this, TQ_SIGNAL(preview(int)));
}

2
src/gui/widgets/DiatonicPitchChooser.h
Unescape View File

@ -41,7 +41,7 @@ class PitchDragLabel;
class DiatonicPitchChooser : public TQGroupBox
{
Q_OBJECT
TQ_OBJECT
public:
DiatonicPitchChooser(TQString title,

8
src/gui/widgets/Fader.cpp
Unescape View File

@ -76,7 +76,7 @@ Fader::Fader(AudioLevel::FaderType type,
calculateGroovePixmap();
setFader(0.0);
connect(m_floatTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotFloatTimeout()));
connect(m_floatTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(slotFloatTimeout()));
m_float->hide();
}
@ -113,7 +113,7 @@ Fader::Fader(int min, int max, int deflt,
calculateGroovePixmap();
setFader(deflt);
connect(m_floatTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotFloatTimeout()));
connect(m_floatTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(slotFloatTimeout()));
m_float->hide();
}
@ -144,7 +144,7 @@ Fader::Fader(int min, int max, int deflt,
calculateGroovePixmap();
setFader(deflt);
connect(m_floatTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotFloatTimeout()));
connect(m_floatTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(slotFloatTimeout()));
m_float->hide();
}
@ -318,7 +318,7 @@ Fader::mousePressEvent(TQMouseEvent *e)
{
m_clickMousePos = -1;
if (e->button() == Qt::LeftButton) {
if (e->button() == TQt::LeftButton) {
if (e->type() == TQEvent::MouseButtonDblClick) {
setFader(0);

2
src/gui/widgets/Fader.h
Unescape View File

@ -45,7 +45,7 @@ class TextFloat;
class Fader : public TQWidget
{
Q_OBJECT
TQ_OBJECT
public:

6
src/gui/widgets/HSpinBox.cpp
Unescape View File

@ -48,7 +48,7 @@ HSpinBox::HSpinBox( int minV, int maxV, int step, TQWidget* parent,
double bottom, double top, int decimals, float initialValue)
: TQSpinBox(minV,maxV,step,parent)
{
setValidator(new TQDoubleValidator(bottom,top,decimals,TQT_TQOBJECT(this)));
setValidator(new TQDoubleValidator(bottom,top,decimals,this));
initialize(decimals);
setValuef(initialValue);
}
@ -60,11 +60,11 @@ HSpinBox::HSpinBox( TQWidget* parent, float initialValue, int step,
: TQSpinBox((int)(bottom*pow(10.0, decimals)),
(int)(top*pow(10.0, decimals)), step, parent)
{
setValidator(new TQDoubleValidator(bottom,top,decimals,TQT_TQOBJECT(this)));
setValidator(new TQDoubleValidator(bottom,top,decimals,this));
initialize(decimals);
setValuef(initialValue);
if (recv != NULL && mem != NULL)
TQObject::connect(this, TQT_SIGNAL(valueChanged(int)), recv, mem);
TQObject::connect(this, TQ_SIGNAL(valueChanged(int)), recv, mem);
}
float HSpinBox::valuef() { return float(value()) / m_scaleFactor; }

2
src/gui/widgets/Label.h
Unescape View File

@ -36,7 +36,7 @@ namespace Rosegarden
class Label : public TQLabel
{
Q_OBJECT
TQ_OBJECT
public:
Label(TQWidget *parent = 0, const char *name=0):

2
src/gui/widgets/MidiFaderWidget.h
Unescape View File

@ -42,7 +42,7 @@ class AudioVUMeter;
class MidiFaderWidget : public TQFrame
{
Q_OBJECT
TQ_OBJECT
public:

30
src/gui/widgets/PitchChooser.cpp
Unescape View File

@ -40,7 +40,7 @@ namespace Rosegarden
PitchChooser::PitchChooser(TQString title,
TQWidget *parent,
int defaultPitch) :
TQGroupBox(1, Qt::Horizontal, title, parent),
TQGroupBox(1, TQt::Horizontal, title, parent),
m_defaultPitch(defaultPitch)
{
m_pitchDragLabel = new PitchDragLabel(this, defaultPitch);
@ -59,26 +59,26 @@ PitchChooser::PitchChooser(TQString title,
m_pitchLabel = new TQLabel(pl.getTQString(), hbox);
m_pitchLabel->setMinimumWidth(40);
connect(m_pitch, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotSetPitch(int)));
connect(m_pitch, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotSetPitch(int)));
connect(m_pitch, TQT_SIGNAL(valueChanged(int)),
this, TQT_SIGNAL(pitchChanged(int)));
connect(m_pitch, TQ_SIGNAL(valueChanged(int)),
this, TQ_SIGNAL(pitchChanged(int)));
connect(m_pitch, TQT_SIGNAL(valueChanged(int)),
this, TQT_SIGNAL(preview(int)));
connect(m_pitch, TQ_SIGNAL(valueChanged(int)),
this, TQ_SIGNAL(preview(int)));
connect(m_pitchDragLabel, TQT_SIGNAL(pitchDragged(int)),
this, TQT_SLOT(slotSetPitch(int)));
connect(m_pitchDragLabel, TQ_SIGNAL(pitchDragged(int)),
this, TQ_SLOT(slotSetPitch(int)));
connect(m_pitchDragLabel, TQT_SIGNAL(pitchChanged(int)),
this, TQT_SLOT(slotSetPitch(int)));
connect(m_pitchDragLabel, TQ_SIGNAL(pitchChanged(int)),
this, TQ_SLOT(slotSetPitch(int)));
connect(m_pitchDragLabel, TQT_SIGNAL(pitchChanged(int)),
this, TQT_SIGNAL(pitchChanged(int)));
connect(m_pitchDragLabel, TQ_SIGNAL(pitchChanged(int)),
this, TQ_SIGNAL(pitchChanged(int)));
connect(m_pitchDragLabel, TQT_SIGNAL(preview(int)),
this, TQT_SIGNAL(preview(int)));
connect(m_pitchDragLabel, TQ_SIGNAL(preview(int)),
this, TQ_SIGNAL(preview(int)));
}

2
src/gui/widgets/PitchChooser.h
Unescape View File

@ -40,7 +40,7 @@ class PitchDragLabel;
class PitchChooser : public TQGroupBox
{
Q_OBJECT
TQ_OBJECT
public:
PitchChooser(TQString title,

2
src/gui/widgets/PitchDragLabel.cpp
Unescape View File

@ -82,7 +82,7 @@ PitchDragLabel::slotSetPitch(int pitch, int octave, int step)
void
PitchDragLabel::mousePressEvent(TQMouseEvent *e)
{
if (e->button() == Qt::LeftButton) {
if (e->button() == TQt::LeftButton) {
m_clickedY = e->y();
m_clickedPitch = m_pitch;
m_clicked = true;

2
src/gui/widgets/PitchDragLabel.h
Unescape View File

@ -41,7 +41,7 @@ class NotePixmapFactory;
class PitchDragLabel : public TQWidget
{
Q_OBJECT
TQ_OBJECT
public:
PitchDragLabel(TQWidget *parent,

4
src/gui/widgets/PluginControl.cpp
Unescape View File

@ -146,8 +146,8 @@ PluginControl::PluginControl(TQWidget *parent,
m_dial->setKnobColour(GUIPalette::getColour(GUIPalette::RotaryPlugin));
connect(m_dial, TQT_SIGNAL(valueChanged(float)),
this, TQT_SLOT(slotValueChanged(float)));
connect(m_dial, TQ_SIGNAL(valueChanged(float)),
this, TQ_SLOT(slotValueChanged(float)));
TQLabel *upp;
if (port->getDisplayHint() &

2
src/gui/widgets/PluginControl.h
Unescape View File

@ -42,7 +42,7 @@ class Studio;
class PluginControl : public TQObject
{
Q_OBJECT
TQ_OBJECT
public:

2
src/gui/widgets/ProgressBar.h
Unescape View File

@ -36,7 +36,7 @@ namespace Rosegarden
class ProgressBar : public KProgress
{
Q_OBJECT
TQ_OBJECT
public:

8
src/gui/widgets/ProgressDialog.cpp
Unescape View File

@ -52,8 +52,8 @@ ProgressDialog::ProgressDialog(TQWidget *creator,
RG_DEBUG << "ProgressDialog::ProgressDialog type 1 - "
<< labelText() << " - modal : " << modal << endl;
connect(progressBar(), TQT_SIGNAL(percentageChanged (int)),
this, TQT_SLOT(slotCheckShow(int)));
connect(progressBar(), TQ_SIGNAL(percentageChanged (int)),
this, TQ_SLOT(slotCheckShow(int)));
m_chrono.start();
@ -83,8 +83,8 @@ ProgressDialog::ProgressDialog(
RG_DEBUG << "ProgressDialog::ProgressDialog type 2 - "
<< labelText << " - modal : " << modal << endl;
connect(progressBar(), TQT_SIGNAL(percentageChanged (int)),
this, TQT_SLOT(slotCheckShow(int)));
connect(progressBar(), TQ_SIGNAL(percentageChanged (int)),
this, TQ_SLOT(slotCheckShow(int)));
m_chrono.start();

2
src/gui/widgets/ProgressDialog.h
Unescape View File

@ -40,7 +40,7 @@ namespace Rosegarden
class ProgressDialog : public KProgressDialog
{
Q_OBJECT
TQ_OBJECT
public:
ProgressDialog(TQWidget * creator = 0,

2
src/gui/widgets/QDeferScrollView.cpp
Unescape View File

@ -33,7 +33,7 @@ namespace Rosegarden
QDeferScrollView::QDeferScrollView(TQWidget* parent, const char *name, WFlags f)
: TQScrollView(parent, name, f)
{
setFocusPolicy(TQ_WheelFocus);
setFocusPolicy(TQWidget::WheelFocus);
}
void QDeferScrollView::setBottomMargin(int m)

2
src/gui/widgets/QDeferScrollView.h
Unescape View File

@ -52,7 +52,7 @@ namespace Rosegarden
*/
class QDeferScrollView : public TQScrollView
{
Q_OBJECT
TQ_OBJECT
public:
QDeferScrollView(TQWidget* parent=0, const char *name=0, WFlags f=0);

14
src/gui/widgets/QuantizeParameters.cpp
Unescape View File

@ -75,7 +75,7 @@ QuantizeParameters::QuantizeParameters(TQWidget *parent,
}
TQGroupBox *quantizerBox = new TQGroupBox
(1, Qt::Horizontal, i18n("Quantizer"), this);
(1, TQt::Horizontal, i18n("Quantizer"), this);
m_mainLayout->addWidget(quantizerBox, zero, 0);
TQFrame *typeFrame = new TQFrame(quantizerBox);
@ -99,7 +99,7 @@ QuantizeParameters::QuantizeParameters(TQWidget *parent,
m_mainLayout->addWidget(parameterBox, zero + 1, 0);
m_notationBox = new TQGroupBox
(1, Qt::Horizontal, i18n("Notation parameters"), parameterBox);
(1, TQt::Horizontal, i18n("Notation parameters"), parameterBox);
TQFrame *notationFrame = new TQFrame(m_notationBox);
layout = new TQGridLayout(notationFrame, 4, 2, 5, 3);
@ -140,7 +140,7 @@ QuantizeParameters::QuantizeParameters(TQWidget *parent,
layout->addMultiCellWidget(m_counterpoint, 3, 3, 0, 1);
m_gridBox = new TQGroupBox
(1, Qt::Horizontal, i18n("Grid parameters"), parameterBox);
(1, TQt::Horizontal, i18n("Grid parameters"), parameterBox);
TQFrame *gridFrame = new TQFrame(m_gridBox);
layout = new TQGridLayout(gridFrame, 4, 2, 5, 3);
@ -164,7 +164,7 @@ QuantizeParameters::QuantizeParameters(TQWidget *parent,
layout->addMultiCellWidget(m_durationCheckBox, 3, 3, 0, 1);
m_postProcessingBox = new TQGroupBox
(1, Qt::Horizontal, i18n("After quantization"), this);
(1, TQt::Horizontal, i18n("After quantization"), this);
if (!preamble.isNull()) {
m_mainLayout->addMultiCellWidget(m_postProcessingBox,
@ -180,8 +180,8 @@ QuantizeParameters::QuantizeParameters(TQWidget *parent,
m_advancedButton =
new TQPushButton(i18n("Show advanced options"), this);
m_mainLayout->addWidget(m_advancedButton, zero + 2, 0, TQt::AlignLeft);
TQObject::connect(m_advancedButton, TQT_SIGNAL(clicked()),
this, TQT_SLOT(slotAdvancedChanged()));
TQObject::connect(m_advancedButton, TQ_SIGNAL(clicked()),
this, TQ_SLOT(slotAdvancedChanged()));
}
TQFrame *postFrame = new TQFrame(m_postProcessingBox);
@ -335,7 +335,7 @@ QuantizeParameters::QuantizeParameters(TQWidget *parent,
break;
}
connect(m_typeCombo, TQT_SIGNAL(activated(int)), TQT_SLOT(slotTypeChanged(int)));
connect(m_typeCombo, TQ_SIGNAL(activated(int)), TQ_SLOT(slotTypeChanged(int)));
}
Quantizer *

2
src/gui/widgets/QuantizeParameters.h
Unescape View File

@ -46,7 +46,7 @@ class Quantizer;
class QuantizeParameters : public TQFrame
{
Q_OBJECT
TQ_OBJECT
public:
enum QuantizerType { Grid, Legato, Notation };

18
src/gui/widgets/Rotary.cpp
Unescape View File

@ -97,8 +97,8 @@ Rotary::Rotary(TQWidget *parent,
}
// connect timer
connect(_floatTimer, TQT_SIGNAL(timeout()), this,
TQT_SLOT(slotFloatTimeout()));
connect(_floatTimer, TQ_SIGNAL(timeout()), this,
TQ_SLOT(slotFloatTimeout()));
_float->hide();
TQToolTip::add
@ -113,8 +113,8 @@ Rotary::~Rotary()
{
// Remove this connection
//
disconnect(_floatTimer, TQT_SIGNAL(timeout()), this,
TQT_SLOT(slotFloatTimeout()));
disconnect(_floatTimer, TQ_SIGNAL(timeout()), this,
TQ_SLOT(slotFloatTimeout()));
delete _float;
_float = 0;
@ -371,17 +371,17 @@ Rotary::snapPosition()
void
Rotary::mousePressEvent(TQMouseEvent *e)
{
if (e->button() == Qt::LeftButton) {
if (e->button() == TQt::LeftButton) {
m_buttonPressed = true;
m_lastY = e->y();
m_lastX = e->x();
} else if (e->button() == Qt::MidButton) // reset to default
} else if (e->button() == TQt::MidButton) // reset to default
{
m_position = m_initialPosition;
snapPosition();
update();
emit valueChanged(m_snapPosition);
} else if (e->button() == Qt::RightButton) // reset to centre position
} else if (e->button() == TQt::RightButton) // reset to centre position
{
m_position = (m_maxValue + m_minValue) / 2.0;
snapPosition();
@ -405,7 +405,7 @@ Rotary::mousePressEvent(TQMouseEvent *e)
// std::cerr << "Rotary::mousePressEvent: logarithmic = " << m_logarithmic
// << ", position = " << m_position << std::endl;
if (e->button() == Qt::RightButton || e->button() == Qt::MidButton) {
if (e->button() == TQt::RightButton || e->button() == TQt::MidButton) {
// one shot, 500ms
_floatTimer->start(500, true);
}
@ -453,7 +453,7 @@ Rotary::mouseDoubleClickEvent(TQMouseEvent * /*e*/)
void
Rotary::mouseReleaseEvent(TQMouseEvent *e)
{
if (e->button() == Qt::LeftButton) {
if (e->button() == TQt::LeftButton) {
m_buttonPressed = false;
m_lastY = 0;
m_lastX = 0;

2
src/gui/widgets/Rotary.h
Unescape View File

@ -41,7 +41,7 @@ namespace Rosegarden
class Rotary : public TQWidget
{
Q_OBJECT
TQ_OBJECT
public:

6
src/gui/widgets/ScrollBox.cpp
Unescape View File

@ -51,15 +51,15 @@ ScrollBox::ScrollBox(TQWidget* parent, SizeMode sizeMode, const char* name) :
void ScrollBox::mousePressEvent(TQMouseEvent* e)
{
m_mouse = e->pos();
if (e->button() == Qt::RightButton)
if (e->button() == TQt::RightButton)
emit button3Pressed();
if (e->button() == Qt::MidButton)
if (e->button() == TQt::MidButton)
emit button2Pressed();
}
void ScrollBox::mouseMoveEvent(TQMouseEvent* e)
{
if (e->state() != Qt::LeftButton)
if (e->state() != TQt::LeftButton)
return ;
int dx = (e->pos().x() - m_mouse.x()) * m_pagesize.width() / width();

2
src/gui/widgets/ScrollBox.h
Unescape View File

@ -43,7 +43,7 @@ namespace Rosegarden
class ScrollBox: public TQFrame
{
Q_OBJECT
TQ_OBJECT
public:

2
src/gui/widgets/ScrollBoxDialog.h
Unescape View File

@ -39,7 +39,7 @@ namespace Rosegarden
class ScrollBoxDialog : public KDialog
{
Q_OBJECT
TQ_OBJECT
public:

2
src/gui/widgets/SpinBox.h
Unescape View File

@ -42,7 +42,7 @@ namespace Rosegarden
*/
class SpinBox : public TQSpinBox
{
Q_OBJECT
TQ_OBJECT
public:
SpinBox(TQWidget *parent = 0, const char *name=0);

36
src/gui/widgets/TimeWidget.cpp
Unescape View File

@ -51,7 +51,7 @@ TimeWidget::TimeWidget(TQString title,
timeT absTime,
bool editable,
bool constrainToCompositionDuration) :
TQGroupBox(1, Qt::Horizontal, title, parent),
TQGroupBox(1, TQt::Horizontal, title, parent),
m_composition(composition),
m_isDuration(false),
m_constrain(constrainToCompositionDuration),
@ -69,7 +69,7 @@ TimeWidget::TimeWidget(TQString title,
timeT duration,
bool editable,
bool constrainToCompositionDuration) :
TQGroupBox(1, Qt::Horizontal, title, parent),
TQGroupBox(1, TQt::Horizontal, title, parent),
m_composition(composition),
m_isDuration(true),
m_constrain(constrainToCompositionDuration),
@ -129,8 +129,8 @@ TimeWidget::init(bool editable)
(NotePixmapFactory::makeNoteMenuPixmap(duration, error));
m_note->insertItem(pmap, label); // ignore error
}
connect(m_note, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotNoteChanged(int)));
connect(m_note, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotNoteChanged(int)));
layout->addMultiCellWidget(m_note, 0, 0, 1, 3);
} else {
@ -154,8 +154,8 @@ TimeWidget::init(bool editable)
m_timeT = new TQSpinBox(frame);
m_timeT->setLineStep
(Note(Note::Shortest).getDuration());
connect(m_timeT, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotTimeTChanged(int)));
connect(m_timeT, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotTimeTChanged(int)));
layout->addWidget(m_timeT, 0, 5);
} else {
m_timeT = 0;
@ -176,8 +176,8 @@ TimeWidget::init(bool editable)
m_timeT = new TQSpinBox(frame);
m_timeT->setLineStep
(Note(Note::Shortest).getDuration());
connect(m_timeT, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotTimeTChanged(int)));
connect(m_timeT, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotTimeTChanged(int)));
layout->addWidget(m_timeT, 0, 1);
layout->addWidget(new TQLabel(i18n("units"), frame), 0, 2);
} else {
@ -197,8 +197,8 @@ TimeWidget::init(bool editable)
m_bar = new TQSpinBox(frame);
if (m_isDuration)
m_bar->setMinValue(0);
connect(m_bar, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotBarBeatOrFractionChanged(int)));
connect(m_bar, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotBarBeatOrFractionChanged(int)));
layout->addWidget(m_bar, 1, 1);
} else {
m_bar = 0;
@ -215,8 +215,8 @@ TimeWidget::init(bool editable)
m_beatLabel = 0;
m_beat = new TQSpinBox(frame);
m_beat->setMinValue(1);
connect(m_beat, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotBarBeatOrFractionChanged(int)));
connect(m_beat, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotBarBeatOrFractionChanged(int)));
layout->addWidget(m_beat, 1, 3);
} else {
m_beat = 0;
@ -236,8 +236,8 @@ TimeWidget::init(bool editable)
m_fractionLabel = 0;
m_fraction = new TQSpinBox(frame);
m_fraction->setMinValue(1);
connect(m_fraction, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotBarBeatOrFractionChanged(int)));
connect(m_fraction, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotBarBeatOrFractionChanged(int)));
layout->addWidget(m_fraction, 1, 5);
} else {
m_fraction = 0;
@ -258,8 +258,8 @@ TimeWidget::init(bool editable)
m_sec = new TQSpinBox(frame);
if (m_isDuration)
m_sec->setMinValue(0);
connect(m_sec, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotSecOrMSecChanged(int)));
connect(m_sec, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotSecOrMSecChanged(int)));
layout->addWidget(m_sec, 2, 1);
} else {
m_sec = 0;
@ -277,8 +277,8 @@ TimeWidget::init(bool editable)
m_msec = new TQSpinBox(frame);
m_msec->setMinValue(0);
m_msec->setLineStep(10);
connect(m_msec, TQT_SIGNAL(valueChanged(int)),
this, TQT_SLOT(slotSecOrMSecChanged(int)));
connect(m_msec, TQ_SIGNAL(valueChanged(int)),
this, TQ_SLOT(slotSecOrMSecChanged(int)));
layout->addWidget(m_msec, 2, 3);
} else {
m_msec = 0;

2
src/gui/widgets/TimeWidget.h
Unescape View File

@ -45,7 +45,7 @@ class Composition;
class TimeWidget : public TQGroupBox
{
Q_OBJECT
TQ_OBJECT
public:
/**

2
src/gui/widgets/TristateCheckBox.h
Unescape View File

@ -41,7 +41,7 @@ namespace Rosegarden
*/
class TristateCheckBox : public TQCheckBox
{
Q_OBJECT
TQ_OBJECT
public:
TristateCheckBox(TQWidget *parent=0,

16
src/gui/widgets/VUMeter.cpp
Unescape View File

@ -92,26 +92,26 @@ VUMeter::VUMeter(TQWidget *parent,
//
m_fallTimerLeft = new TQTimer();
connect(m_fallTimerLeft, TQT_SIGNAL(timeout()),
this, TQT_SLOT(slotReduceLevelLeft()));
connect(m_fallTimerLeft, TQ_SIGNAL(timeout()),
this, TQ_SLOT(slotReduceLevelLeft()));
if (m_showPeakLevel) {
m_peakTimerLeft = new TQTimer();
connect(m_peakTimerLeft, TQT_SIGNAL(timeout()),
this, TQT_SLOT(slotStopShowingPeakLeft()));
connect(m_peakTimerLeft, TQ_SIGNAL(timeout()),
this, TQ_SLOT(slotStopShowingPeakLeft()));
}
if (stereo) {
m_fallTimerRight = new TQTimer();
connect(m_fallTimerRight, TQT_SIGNAL(timeout()),
this, TQT_SLOT(slotReduceLevelRight()));
connect(m_fallTimerRight, TQ_SIGNAL(timeout()),
this, TQ_SLOT(slotReduceLevelRight()));
if (m_showPeakLevel) {
m_peakTimerRight = new TQTimer();
connect(m_peakTimerRight, TQT_SIGNAL(timeout()),
this, TQT_SLOT(slotStopShowingPeakRight()));
connect(m_peakTimerRight, TQ_SIGNAL(timeout()),
this, TQ_SLOT(slotStopShowingPeakRight()));
}
}

2
src/gui/widgets/VUMeter.h
Unescape View File

@ -41,7 +41,7 @@ class VelocityColour;
class VUMeter : public TQLabel
{
Q_OBJECT
TQ_OBJECT
public:

2
src/gui/widgets/WheelyButton.h
Unescape View File

@ -37,7 +37,7 @@ namespace Rosegarden
class WheelyButton : public TQPushButton
{
Q_OBJECT
TQ_OBJECT
public:

4
src/gui/widgets/ZoomSlider.h
Unescape View File

@ -57,7 +57,7 @@ public:
* to the user as a nice continuous range.
*/
ZoomSlider(const std::vector<T> &sizes, T defaultValue,
Qt::Orientation, TQWidget * parent, const char * name=0);
TQt::Orientation, TQWidget * parent, const char * name=0);
virtual ~ZoomSlider();
@ -81,7 +81,7 @@ protected:
template<class T>
ZoomSlider<T>::ZoomSlider(const std::vector<T> &sizes,
T initialSize, Qt::Orientation o,
T initialSize, TQt::Orientation o,
TQWidget *parent, const char *name) :
TQSlider(0, sizes.size()-1, 1,
getIndex(sizes, initialSize), o, parent, name),

4
src/sequencer/RosegardenSequencerApp.cpp
Unescape View File

@ -118,8 +118,8 @@ RosegardenSequencerApp::RosegardenSequencerApp() :
// Check for new clients every so often
//
m_newClientTimer = new TQTimer(this);
connect(m_newClientTimer, TQT_SIGNAL(timeout()),
this, TQT_SLOT(slotCheckForNewClients()));
connect(m_newClientTimer, TQ_SIGNAL(timeout()),
this, TQ_SLOT(slotCheckForNewClients()));
m_newClientTimer->start(3000); // every 3 seconds
}

2
src/sequencer/RosegardenSequencerApp.h
Unescape View File

@ -76,7 +76,7 @@ class RosegardenSequencerApp : public TDEMainWindow,
virtual public RosegardenSequencerIface,
public ExternalTransport
{
Q_OBJECT
TQ_OBJECT
public:

2
src/sequencer/main.cpp
Unescape View File

@ -101,7 +101,7 @@ int main(int argc, char *argv[])
roseSeq = new RosegardenSequencerApp;
}
TQObject::connect(&app, TQT_SIGNAL(lastWindowClosed()), &app, TQT_SLOT(quit()));
TQObject::connect(&app, TQ_SIGNAL(lastWindowClosed()), &app, TQ_SLOT(quit()));
app.disableSessionManagement(); // we don't want to be
// saved/restored by session

4
src/sound/AudioFileManager.cpp
Unescape View File

@ -95,8 +95,8 @@ AudioFileManager::AudioFileManager() :
// Retransmit progress
//
connect(&m_peakManager, TQT_SIGNAL(setProgress(int)),
this, TQT_SIGNAL(setProgress(int)));
connect(&m_peakManager, TQ_SIGNAL(setProgress(int)),
this, TQ_SIGNAL(setProgress(int)));
}
AudioFileManager::~AudioFileManager()

2
src/sound/AudioFileManager.h
Unescape View File

@ -59,7 +59,7 @@ typedef std::vector<AudioFile*>::const_iterator AudioFileManagerIterator;
class AudioFileManager : public TQObject, public XmlExportable
{
Q_OBJECT
TQ_OBJECT
public:
AudioFileManager();

2
src/sound/AudioFileTimeStretcher.h
Unescape View File

@ -33,7 +33,7 @@ class AudioFileManager;
class AudioFileTimeStretcher : public TQObject
{
Q_OBJECT
TQ_OBJECT
public:

2
src/sound/MidiFile.h
Unescape View File

@ -64,7 +64,7 @@ class Studio;
class MidiFile : public TQObject, public SoundFile
{
Q_OBJECT
TQ_OBJECT
public:

2
src/sound/PeakFile.h
Unescape View File

@ -52,7 +52,7 @@ typedef std::pair<RealTime, RealTime> SplitPointPair;
class PeakFile : public TQObject, public SoundFile
{
Q_OBJECT
TQ_OBJECT
public:

4
src/sound/PeakFileManager.cpp
Unescape View File

@ -176,8 +176,8 @@ PeakFileManager::generatePeaks(AudioFile *audioFile,
if (audioFile->getType() == WAV) {
m_currentPeakFile = getPeakFile(audioFile);
TQObject::connect(m_currentPeakFile, TQT_SIGNAL(setProgress(int)),
this, TQT_SIGNAL(setProgress(int)));
TQObject::connect(m_currentPeakFile, TQ_SIGNAL(setProgress(int)),
this, TQ_SIGNAL(setProgress(int)));
// Just write out a peak file
//

2
src/sound/PeakFileManager.h
Unescape View File

@ -46,7 +46,7 @@ class RealTime;
class PeakFileManager : public TQObject
{
Q_OBJECT
TQ_OBJECT
public:
// updatePercentage tells this object how often to throw a

54
translations/desktop_files/ru.po
Unescape View File

@ -0,0 +1,54 @@
# SOME DESCRIPTIVE TITLE.
# This file is put in the public domain.
# Andrei Stepanov <adem4ik@gmail.com>, 2024.
msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2022-08-26 02:56+0200\n"
"PO-Revision-Date: 2024-04-27 18:57+0000\n"
"Last-Translator: Andrei Stepanov <adem4ik@gmail.com>\n"
"Language-Team: Russian <https://mirror.git.trinitydesktop.org/weblate/"
"projects/applications/rosegarden-desktop-files/ru/>\n"
"Language: ru\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=3; plural=n%10==1 && n%100!=11 ? 0 : n%10>=2 && n"
"%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2;\n"
"X-Generator: Weblate 4.17\n"
#. Name
#: data/desktop/rosegarden.desktop:2
msgid "Rosegarden"
msgstr "Rosegarden"
#. GenericName
#: data/desktop/rosegarden.desktop:4
msgid "MIDI and Audio Sequencer and Editor"
msgstr "Секвенсор и редактор MIDI и аудио"
#. Comment
#: data/desktop/rosegarden.desktop:6
msgid "MIDI and audio sequencer and musical notation editor"
msgstr "Секвенсор MIDI и аудио и редактор нотной записи"
#. Comment
#: data/desktop/x-rosegarden-device.desktop:2
msgid "Rosegarden device file"
msgstr "Файл устройства Rosegarden"
#. Comment
#: data/desktop/x-rosegarden.desktop:2
msgid "Rosegarden file"
msgstr "Файл Rosegarden"
#. Comment
#: data/desktop/x-rosegarden21.desktop:2
msgid "Rosegarden 2.1 file"
msgstr "Файл Rosegarden 2.1"
#. Comment
#: data/desktop/x-soundfont.desktop:2
msgid "Soundfont"
msgstr "Soundfont"

10796
translations/messages/pt_BR.po
View File

File diff suppressed because it is too large Load Diff

28
translations/messages/ru.po
Unescape View File

@ -5,21 +5,23 @@
# Alexandre Prokoudine <avp@altlinux.ru>, 2003, 2004.
# Alexandre Prokoudine <techwriter@land.ru>, 2004.
# Alexandre Prokoudine <alexandre.prokoudine@gmail.com>, 2004, 2005, 2006.
# Andrei Stepanov <adem4ik@gmail.com>, 2024.
msgid ""
msgstr ""
"Project-Id-Version: ru\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2021-07-07 18:28+0000\n"
"PO-Revision-Date: 2007-11-12 09:19+0300\n"
"Last-Translator: Alexandre Prokoudine <alexandre.prokoudine@gmail.com>\n"
"Language-Team: Russian <ru@li.org>\n"
"PO-Revision-Date: 2024-04-30 23:00+0000\n"
"Last-Translator: Andrei Stepanov <adem4ik@gmail.com>\n"
"Language-Team: Russian <https://mirror.git.trinitydesktop.org/weblate/"
"projects/applications/rosegarden/ru/>\n"
"Language: ru\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 1.11.4\n"
"Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n"
"%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n"
"Plural-Forms: nplurals=3; plural=n%10==1 && n%100!=11 ? 0 : n%10>=2 && n"
"%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2;\n"
"X-Generator: Weblate 4.17\n"
#. Instead of a literal translation, add your name to the end of the list (separated by a comma).
#: src/gui/application/main.cpp:467
@ -2423,11 +2425,11 @@ msgstr ""
#: src/gui/application/main.cpp:310
msgid "Rosegarden - A sequencer and musical notation editor"
msgstr "Rosegarden - секвенсер и нотный редактор"
msgstr "Rosegarden — секвенсер и нотный редактор"
#: src/gui/application/main.cpp:314
msgid "Don't use the sequencer (support editing only)"
msgstr "Не использовать секвенсер (оставить только редактирование)"
msgstr "Не использовать секвенсер (поддержка только редактирования)"
#: src/gui/application/main.cpp:315
msgid "Don't show the splash screen"
@ -7291,12 +7293,11 @@ msgstr "У&далить украшение..."
#: src/gui/editors/notation/NotationView.cpp:2259
msgid "&None"
msgstr "&Ничего"
msgstr "&Нет"
#: src/gui/editors/notation/NotationView.cpp:2287
#, fuzzy
msgid "Convert Notation For..."
msgstr "Экспортируется звуковой файл..."
msgstr "Преобразовать нотную запись для…"
#: src/gui/editors/notation/NotationView.cpp:2296
msgid "Show &Notes Toolbar"
@ -7504,7 +7505,6 @@ msgid "Unknown font size action %1"
msgstr "%1 - неизвестное действие с размером шрифта"
#: src/gui/editors/notation/NotationView.cpp:4772
#, fuzzy
msgid ""
"The Restricted paste type requires enough empty space (containing only "
"rests) at the paste position to hold all of the events to be pasted.\n"
@ -7516,10 +7516,10 @@ msgstr ""
"Ограниченный способ вставки требует достаточного\n"
"количества свободного дискового пространства\n"
"для хранения всех вставляемых событий.\n"
"В настоящий момент дискового постранства не хватает..\n"
"В настоящий момент дискового пространства не хватает..\n"
"Если вам всё равно необходимо вставить данные, \n"
"используйте любой другой тип вставки\n"
"из меню \"Правка\". Вы также можете сменить\n"
"из меню «Правка». Вы также можете сменить\n"
"стандартный тип вставки с Ограниченной \n"
"на какую-либо другую."

Write Preview
Loading…
Cancel
Save