From 1b916e4872a4e78f11c1a4d7eaf286e38aeed161 Mon Sep 17 00:00:00 2001 From: Pritpal Bedi Date: Thu, 22 Oct 2009 16:41:57 +0000 Subject: [PATCH] ! Changes will be documented in last Changelog commit. --- harbour/contrib/hbqt/qtcore/Makefile | 64 ++ .../hbqt/qtcore/QAbstractItemModel.cpp | 403 ++++++++ .../hbqt/qtcore/QAbstractListModel.cpp | 116 +++ .../hbqt/qtcore/QAbstractTableModel.cpp | 116 +++ harbour/contrib/hbqt/qtcore/QBitArray.cpp | 235 +++++ harbour/contrib/hbqt/qtcore/QByteArray.cpp | 941 ++++++++++++++++++ .../contrib/hbqt/qtcore/QCoreApplication.cpp | 447 +++++++++ harbour/contrib/hbqt/qtcore/QDataStream.cpp | 215 ++++ harbour/contrib/hbqt/qtcore/QDate.cpp | 274 +++++ harbour/contrib/hbqt/qtcore/QDateTime.cpp | 318 ++++++ harbour/contrib/hbqt/qtcore/QDir.cpp | 532 ++++++++++ harbour/contrib/hbqt/qtcore/QEvent.cpp | 163 +++ harbour/contrib/hbqt/qtcore/QEventLoop.cpp | 170 ++++ harbour/contrib/hbqt/qtcore/QFile.cpp | 402 ++++++++ harbour/contrib/hbqt/qtcore/QFileInfo.cpp | 464 +++++++++ harbour/contrib/hbqt/qtcore/QIODevice.cpp | 378 +++++++ harbour/contrib/hbqt/qtcore/QLatin1Char.cpp | 118 +++ harbour/contrib/hbqt/qtcore/QLatin1String.cpp | 110 ++ harbour/contrib/hbqt/qtcore/QLine.cpp | 259 +++++ harbour/contrib/hbqt/qtcore/QLineF.cpp | 328 ++++++ harbour/contrib/hbqt/qtcore/QList.cpp | 451 +++++++++ harbour/contrib/hbqt/qtcore/QLocale.cpp | 552 ++++++++++ harbour/contrib/hbqt/qtcore/QMimeData.cpp | 279 ++++++ harbour/contrib/hbqt/qtcore/QModelIndex.cpp | 196 ++++ harbour/contrib/hbqt/qtcore/QObject.cpp | 367 +++++++ harbour/contrib/hbqt/qtcore/QPoint.cpp | 179 ++++ harbour/contrib/hbqt/qtcore/QPointF.cpp | 183 ++++ harbour/contrib/hbqt/qtcore/QProcess.cpp | 403 ++++++++ harbour/contrib/hbqt/qtcore/QRect.cpp | 617 ++++++++++++ harbour/contrib/hbqt/qtcore/QRectF.cpp | 626 ++++++++++++ harbour/contrib/hbqt/qtcore/QRegExp.cpp | 265 +++++ harbour/contrib/hbqt/qtcore/QResource.cpp | 199 ++++ harbour/contrib/hbqt/qtcore/QSignalMapper.cpp | 205 ++++ harbour/contrib/hbqt/qtcore/QSize.cpp | 231 +++++ harbour/contrib/hbqt/qtcore/QSizeF.cpp | 236 +++++ harbour/contrib/hbqt/qtcore/QStringList.cpp | 407 ++++++++ .../hbqt/qtcore/QTextBoundaryFinder.cpp | 200 ++++ harbour/contrib/hbqt/qtcore/QTextCodec.cpp | 268 +++++ harbour/contrib/hbqt/qtcore/QTextDecoder.cpp | 111 +++ harbour/contrib/hbqt/qtcore/QTextEncoder.cpp | 111 +++ harbour/contrib/hbqt/qtcore/QTextStream.cpp | 411 ++++++++ harbour/contrib/hbqt/qtcore/QThread.cpp | 232 +++++ harbour/contrib/hbqt/qtcore/QTime.cpp | 266 +++++ harbour/contrib/hbqt/qtcore/QTimer.cpp | 197 ++++ harbour/contrib/hbqt/qtcore/QTranslator.cpp | 148 +++ harbour/contrib/hbqt/qtcore/QUrl.cpp | 693 +++++++++++++ harbour/contrib/hbqt/qtcore/QVariant.cpp | 478 +++++++++ .../hbqt/qtcore/TQAbstractItemModel.prg | 143 +++ .../hbqt/qtcore/TQAbstractListModel.prg | 100 ++ .../hbqt/qtcore/TQAbstractTableModel.prg | 100 ++ harbour/contrib/hbqt/qtcore/TQBitArray.prg | 115 +++ harbour/contrib/hbqt/qtcore/TQByteArray.prg | 196 ++++ .../contrib/hbqt/qtcore/TQCoreApplication.prg | 139 +++ harbour/contrib/hbqt/qtcore/TQDataStream.prg | 112 +++ harbour/contrib/hbqt/qtcore/TQDate.prg | 118 +++ harbour/contrib/hbqt/qtcore/TQDateTime.prg | 125 +++ harbour/contrib/hbqt/qtcore/TQDir.prg | 151 +++ harbour/contrib/hbqt/qtcore/TQEvent.prg | 106 ++ harbour/contrib/hbqt/qtcore/TQEventLoop.prg | 105 ++ harbour/contrib/hbqt/qtcore/TQFile.prg | 133 +++ harbour/contrib/hbqt/qtcore/TQFileInfo.prg | 143 +++ harbour/contrib/hbqt/qtcore/TQIODevice.prg | 132 +++ harbour/contrib/hbqt/qtcore/TQLatin1Char.prg | 101 ++ .../contrib/hbqt/qtcore/TQLatin1String.prg | 100 ++ harbour/contrib/hbqt/qtcore/TQLine.prg | 114 +++ harbour/contrib/hbqt/qtcore/TQLineF.prg | 126 +++ harbour/contrib/hbqt/qtcore/TQList.prg | 139 +++ harbour/contrib/hbqt/qtcore/TQLocale.prg | 147 +++ harbour/contrib/hbqt/qtcore/TQMimeData.prg | 118 +++ harbour/contrib/hbqt/qtcore/TQModelIndex.prg | 110 ++ harbour/contrib/hbqt/qtcore/TQObject.prg | 128 +++ harbour/contrib/hbqt/qtcore/TQPoint.prg | 105 ++ harbour/contrib/hbqt/qtcore/TQPointF.prg | 105 ++ harbour/contrib/hbqt/qtcore/TQProcess.prg | 132 +++ harbour/contrib/hbqt/qtcore/TQRect.prg | 156 +++ harbour/contrib/hbqt/qtcore/TQRectF.prg | 157 +++ harbour/contrib/hbqt/qtcore/TQRegExp.prg | 118 +++ harbour/contrib/hbqt/qtcore/TQResource.prg | 111 +++ .../contrib/hbqt/qtcore/TQSignalMapper.prg | 110 ++ harbour/contrib/hbqt/qtcore/TQSize.prg | 111 +++ harbour/contrib/hbqt/qtcore/TQSizeF.prg | 112 +++ harbour/contrib/hbqt/qtcore/TQStringList.prg | 134 +++ .../hbqt/qtcore/TQTextBoundaryFinder.prg | 110 ++ harbour/contrib/hbqt/qtcore/TQTextCodec.prg | 119 +++ harbour/contrib/hbqt/qtcore/TQTextDecoder.prg | 100 ++ harbour/contrib/hbqt/qtcore/TQTextEncoder.prg | 100 ++ harbour/contrib/hbqt/qtcore/TQTextStream.prg | 135 +++ harbour/contrib/hbqt/qtcore/TQThread.prg | 113 +++ harbour/contrib/hbqt/qtcore/TQTime.prg | 119 +++ harbour/contrib/hbqt/qtcore/TQTimer.prg | 109 ++ harbour/contrib/hbqt/qtcore/TQTranslator.prg | 103 ++ harbour/contrib/hbqt/qtcore/TQUrl.prg | 168 ++++ harbour/contrib/hbqt/qtcore/TQVariant.prg | 135 +++ harbour/contrib/hbqt/qtcore/filelist.mk | 110 ++ 94 files changed, 20337 insertions(+) create mode 100644 harbour/contrib/hbqt/qtcore/Makefile create mode 100644 harbour/contrib/hbqt/qtcore/QAbstractItemModel.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QAbstractListModel.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QAbstractTableModel.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QBitArray.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QByteArray.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QCoreApplication.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QDataStream.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QDate.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QDateTime.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QDir.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QEvent.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QEventLoop.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QFile.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QFileInfo.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QIODevice.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QLatin1Char.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QLatin1String.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QLine.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QLineF.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QList.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QLocale.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QMimeData.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QModelIndex.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QObject.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QPoint.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QPointF.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QProcess.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QRect.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QRectF.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QRegExp.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QResource.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QSignalMapper.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QSize.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QSizeF.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QStringList.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QTextBoundaryFinder.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QTextCodec.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QTextDecoder.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QTextEncoder.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QTextStream.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QThread.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QTime.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QTimer.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QTranslator.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QUrl.cpp create mode 100644 harbour/contrib/hbqt/qtcore/QVariant.cpp create mode 100644 harbour/contrib/hbqt/qtcore/TQAbstractItemModel.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQAbstractListModel.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQAbstractTableModel.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQBitArray.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQByteArray.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQCoreApplication.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQDataStream.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQDate.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQDateTime.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQDir.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQEvent.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQEventLoop.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQFile.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQFileInfo.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQIODevice.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQLatin1Char.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQLatin1String.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQLine.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQLineF.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQList.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQLocale.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQMimeData.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQModelIndex.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQObject.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQPoint.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQPointF.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQProcess.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQRect.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQRectF.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQRegExp.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQResource.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQSignalMapper.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQSize.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQSizeF.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQStringList.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQTextBoundaryFinder.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQTextCodec.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQTextDecoder.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQTextEncoder.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQTextStream.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQThread.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQTime.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQTimer.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQTranslator.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQUrl.prg create mode 100644 harbour/contrib/hbqt/qtcore/TQVariant.prg create mode 100644 harbour/contrib/hbqt/qtcore/filelist.mk diff --git a/harbour/contrib/hbqt/qtcore/Makefile b/harbour/contrib/hbqt/qtcore/Makefile new file mode 100644 index 0000000000..898ff981f3 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/Makefile @@ -0,0 +1,64 @@ +# +# $Id$ +# + +ROOT := ../../../ + +include $(TOP)$(ROOT)config/global.mk + +LIBNAME := hbqtcore + +PRG_HEADERS := \ + ../hbqt.ch \ + +# force redetect. needed for _QT_DARWIN trick +HB_HAS_QT := + +_DET_DSP_NAME := qt +_DET_VAR_INC_ := HB_INC_QT +_DET_VAR_HAS_ := HB_HAS_QT +_DET_FLT_PLAT := !dos !os2 +_DET_FLT_COMP := !mingw64 !watcom !bcc !pocc !pocc64 !poccarm !msvcia64 +_DET_INC_DEFP := /usr/include/qt4 /usr/lib/qt4/include /usr/include /Developer/qt/include +_DET_INC_HEAD := /Qt/qglobal.h +include $(TOP)$(ROOT)config/detfun.mk + +_QT_DARWIN := +ifeq ($(HB_PLATFORM),darwin) + ifeq ($(HB_HAS_QT),) + _DET_DSP_NAME := qt + _DET_VAR_INC_ := HB_INC_QT + _DET_VAR_HAS_ := HB_HAS_QT + _DET_INC_DEFP := /Library/Frameworks/QtCore.framework/Versions/4/Headers + _DET_INC_HEAD := /QtCore + include $(TOP)$(ROOT)config/detfun.mk + _QT_DARWIN := yes + endif +endif + +ifneq ($(HB_HAS_QT),) + + ifeq ($(_QT_DARWIN),yes) + HB_CFLAGS += -I/Library/Frameworks/QtCore.framework/Headers + HB_CFLAGS += -I/Library/Frameworks/QtGui.framework/Headers + HB_CFLAGS += -I/Library/Frameworks/QtNetwork.framework/Headers + HB_CFLAGS += -I/Library/Frameworks/QtWebKit.framework/Headers + else + HB_CFLAGS += $(foreach d,$(HB_HAS_QT),-I$(d) -I$(d)/Qt -I$(d)/QtCore -I$(d)/QtGui -I$(d)/QtNetwork -I$(d)/QtWebKit) + endif + + include $(TOP)$(ROOT)contrib/hbqt/qtcore/filelist.mk + + include $(TOP)$(ROOT)config/header.mk + include $(TOP)$(ROOT)config/lib.mk + + ifneq ($(filter $(HB_PLATFORM),win wce),) + ifneq ($(HB_QT_STATIC),) + DIRS += hbqts + include $(TOP)$(ROOT)config/dir.mk + endif + endif +else + HB_SKIP_REASON := $(_DET_RES_TEXT) + include $(TOP)$(ROOT)config/none.mk +endif diff --git a/harbour/contrib/hbqt/qtcore/QAbstractItemModel.cpp b/harbour/contrib/hbqt/qtcore/QAbstractItemModel.cpp new file mode 100644 index 0000000000..24a0404c41 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QAbstractItemModel.cpp @@ -0,0 +1,403 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +/* + * Constructed[ 32/36 [ 88.89% ] ] + * + * *** Unconvered Prototypes *** + * ----------------------------- + * + * virtual QMap itemData ( const QModelIndex & index ) const + * virtual bool setItemData ( const QModelIndex & index, const QMap & roles ) + * + * *** Commented out protos which construct fine but do not compile *** + * + * // virtual QModelIndexList match ( const QModelIndex & start, int role, const QVariant & value, int hits = 1, Qt::MatchFlags flags = Qt::MatchFlags( Qt::MatchStartsWith | Qt::MatchWrap ) ) const + * // virtual QMimeData * mimeData ( const QModelIndexList & indexes ) const + */ + +#include + +#include +#include +#include + +#include "../hbqt_slots.h" + +/* + * QAbstractItemModel ( QObject * parent = 0 ) + * virtual ~QAbstractItemModel () + */ + +HB_FUNC( QT_HBDBFMODEL ) +{ + hb_retptr( new HbDbfModel( ( PHB_ITEM ) hb_param( 1, HB_IT_BLOCK ) ) ); +} + +HB_FUNC( QT_HBDBFMODEL_RESET ) +{ + hbqt_par_HbDbfModel( 1 )->reset(); +} + +HB_FUNC( QT_HBDBFMODEL_INDEX ) +{ + hb_retptr( new QModelIndex( hbqt_par_HbDbfModel( 1 )->index( hb_parni( 2 ), hb_parni( 3 ), QModelIndex() ) ) ); +} + +HB_FUNC( QT_HBDBFMODEL_HBSETROWCOLUMNS ) +{ + hbqt_par_HbDbfModel( 1 )->hbSetRowColumns( hb_parni( 2 ), hb_parni( 3 ) ); +} + + +QT_G_FUNC( release_QAbstractItemModel ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QAbstractItemModel" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + const QMetaObject * m = ( ( QObject * ) ph )->metaObject(); + if( ( QString ) m->className() != ( QString ) "QObject" ) + { + delete ( ( QAbstractItemModel * ) ph ); + ph = NULL; + } + else + { +#if defined(__debug__) + hb_snprintf( str, sizeof(str), " Object Name Missing: QAbstractItemModel" ); OutputDebugString( str ); +#endif + } + } +} + +HB_FUNC( QT_QABSTRACTITEMMODEL ) +{ +} +/* + * virtual QModelIndex buddy ( const QModelIndex & index ) const + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_BUDDY ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QModelIndex( hbqt_par_QAbstractItemModel( 1 )->buddy( *hbqt_par_QModelIndex( 2 ) ) ), release_QModelIndex ) ); +} + +/* + * virtual bool canFetchMore ( const QModelIndex & parent ) const + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_CANFETCHMORE ) +{ + hb_retl( hbqt_par_QAbstractItemModel( 1 )->canFetchMore( *hbqt_par_QModelIndex( 2 ) ) ); +} + +/* + * virtual int columnCount ( const QModelIndex & parent = QModelIndex() ) const = 0 + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_COLUMNCOUNT ) +{ + hb_retni( hbqt_par_QAbstractItemModel( 1 )->columnCount( ( HB_ISPOINTER( 2 ) ? *hbqt_par_QModelIndex( 2 ) : QModelIndex() ) ) ); +} + +/* + * virtual QVariant data ( const QModelIndex & index, int role = Qt::DisplayRole ) const = 0 + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_DATA ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QVariant( hbqt_par_QAbstractItemModel( 1 )->data( *hbqt_par_QModelIndex( 2 ), ( HB_ISNUM( 3 ) ? hb_parni( 3 ) : Qt::DisplayRole ) ) ), release_QVariant ) ); +} + +/* + * virtual bool dropMimeData ( const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent ) + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_DROPMIMEDATA ) +{ + hb_retl( hbqt_par_QAbstractItemModel( 1 )->dropMimeData( hbqt_par_QMimeData( 2 ), ( Qt::DropAction ) hb_parni( 3 ), hb_parni( 4 ), hb_parni( 5 ), *hbqt_par_QModelIndex( 6 ) ) ); +} + +/* + * virtual void fetchMore ( const QModelIndex & parent ) + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_FETCHMORE ) +{ + hbqt_par_QAbstractItemModel( 1 )->fetchMore( *hbqt_par_QModelIndex( 2 ) ); +} + +/* + * virtual Qt::ItemFlags flags ( const QModelIndex & index ) const + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_FLAGS ) +{ + hb_retni( ( Qt::ItemFlags ) hbqt_par_QAbstractItemModel( 1 )->flags( *hbqt_par_QModelIndex( 2 ) ) ); +} + +/* + * virtual bool hasChildren ( const QModelIndex & parent = QModelIndex() ) const + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_HASCHILDREN ) +{ + hb_retl( hbqt_par_QAbstractItemModel( 1 )->hasChildren( ( HB_ISPOINTER( 2 ) ? *hbqt_par_QModelIndex( 2 ) : QModelIndex() ) ) ); +} + +/* + * bool hasIndex ( int row, int column, const QModelIndex & parent = QModelIndex() ) const + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_HASINDEX ) +{ + hb_retl( hbqt_par_QAbstractItemModel( 1 )->hasIndex( hb_parni( 2 ), hb_parni( 3 ), ( HB_ISPOINTER( 4 ) ? *hbqt_par_QModelIndex( 4 ) : QModelIndex() ) ) ); +} + +/* + * virtual QVariant headerData ( int section, Qt::Orientation orientation, int role = Qt::DisplayRole ) const + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_HEADERDATA ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QVariant( hbqt_par_QAbstractItemModel( 1 )->headerData( hb_parni( 2 ), ( Qt::Orientation ) hb_parni( 3 ), ( HB_ISNUM( 4 ) ? hb_parni( 4 ) : Qt::DisplayRole ) ) ), release_QVariant ) ); +} + +/* + * virtual QModelIndex index ( int row, int column, const QModelIndex & parent = QModelIndex() ) const = 0 + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_INDEX ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QModelIndex( hbqt_par_QAbstractItemModel( 1 )->index( hb_parni( 2 ), hb_parni( 3 ), ( HB_ISPOINTER( 4 ) ? *hbqt_par_QModelIndex( 4 ) : QModelIndex() ) ) ), release_QModelIndex ) ); +} + +/* + * bool insertColumn ( int column, const QModelIndex & parent = QModelIndex() ) + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_INSERTCOLUMN ) +{ + hb_retl( hbqt_par_QAbstractItemModel( 1 )->insertColumn( hb_parni( 2 ), ( HB_ISPOINTER( 3 ) ? *hbqt_par_QModelIndex( 3 ) : QModelIndex() ) ) ); +} + +/* + * virtual bool insertColumns ( int column, int count, const QModelIndex & parent = QModelIndex() ) + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_INSERTCOLUMNS ) +{ + hb_retl( hbqt_par_QAbstractItemModel( 1 )->insertColumns( hb_parni( 2 ), hb_parni( 3 ), ( HB_ISPOINTER( 4 ) ? *hbqt_par_QModelIndex( 4 ) : QModelIndex() ) ) ); +} + +/* + * bool insertRow ( int row, const QModelIndex & parent = QModelIndex() ) + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_INSERTROW ) +{ + hb_retl( hbqt_par_QAbstractItemModel( 1 )->insertRow( hb_parni( 2 ), ( HB_ISPOINTER( 3 ) ? *hbqt_par_QModelIndex( 3 ) : QModelIndex() ) ) ); +} + +/* + * virtual bool insertRows ( int row, int count, const QModelIndex & parent = QModelIndex() ) + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_INSERTROWS ) +{ + hb_retl( hbqt_par_QAbstractItemModel( 1 )->insertRows( hb_parni( 2 ), hb_parni( 3 ), ( HB_ISPOINTER( 4 ) ? *hbqt_par_QModelIndex( 4 ) : QModelIndex() ) ) ); +} + +/* + * virtual QStringList mimeTypes () const + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_MIMETYPES ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QStringList( hbqt_par_QAbstractItemModel( 1 )->mimeTypes() ), release_QStringList ) ); +} + +/* + * virtual QModelIndex parent ( const QModelIndex & index ) const = 0 + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_PARENT ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QModelIndex( hbqt_par_QAbstractItemModel( 1 )->parent( *hbqt_par_QModelIndex( 2 ) ) ), release_QModelIndex ) ); +} + +/* + * bool removeColumn ( int column, const QModelIndex & parent = QModelIndex() ) + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_REMOVECOLUMN ) +{ + hb_retl( hbqt_par_QAbstractItemModel( 1 )->removeColumn( hb_parni( 2 ), ( HB_ISPOINTER( 3 ) ? *hbqt_par_QModelIndex( 3 ) : QModelIndex() ) ) ); +} + +/* + * virtual bool removeColumns ( int column, int count, const QModelIndex & parent = QModelIndex() ) + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_REMOVECOLUMNS ) +{ + hb_retl( hbqt_par_QAbstractItemModel( 1 )->removeColumns( hb_parni( 2 ), hb_parni( 3 ), ( HB_ISPOINTER( 4 ) ? *hbqt_par_QModelIndex( 4 ) : QModelIndex() ) ) ); +} + +/* + * bool removeRow ( int row, const QModelIndex & parent = QModelIndex() ) + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_REMOVEROW ) +{ + hb_retl( hbqt_par_QAbstractItemModel( 1 )->removeRow( hb_parni( 2 ), ( HB_ISPOINTER( 3 ) ? *hbqt_par_QModelIndex( 3 ) : QModelIndex() ) ) ); +} + +/* + * virtual bool removeRows ( int row, int count, const QModelIndex & parent = QModelIndex() ) + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_REMOVEROWS ) +{ + hb_retl( hbqt_par_QAbstractItemModel( 1 )->removeRows( hb_parni( 2 ), hb_parni( 3 ), ( HB_ISPOINTER( 4 ) ? *hbqt_par_QModelIndex( 4 ) : QModelIndex() ) ) ); +} + +/* + * virtual int rowCount ( const QModelIndex & parent = QModelIndex() ) const = 0 + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_ROWCOUNT ) +{ + hb_retni( hbqt_par_QAbstractItemModel( 1 )->rowCount( ( HB_ISPOINTER( 2 ) ? *hbqt_par_QModelIndex( 2 ) : QModelIndex() ) ) ); +} + +/* + * virtual bool setData ( const QModelIndex & index, const QVariant & value, int role = Qt::EditRole ) + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_SETDATA ) +{ + hb_retl( hbqt_par_QAbstractItemModel( 1 )->setData( *hbqt_par_QModelIndex( 2 ), *hbqt_par_QVariant( 3 ), ( HB_ISNUM( 4 ) ? hb_parni( 4 ) : Qt::EditRole ) ) ); +} + +/* + * virtual bool setHeaderData ( int section, Qt::Orientation orientation, const QVariant & value, int role = Qt::EditRole ) + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_SETHEADERDATA ) +{ + hb_retl( hbqt_par_QAbstractItemModel( 1 )->setHeaderData( hb_parni( 2 ), ( Qt::Orientation ) hb_parni( 3 ), *hbqt_par_QVariant( 4 ), ( HB_ISNUM( 5 ) ? hb_parni( 5 ) : Qt::EditRole ) ) ); +} + +/* + * void setSupportedDragActions ( Qt::DropActions actions ) + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_SETSUPPORTEDDRAGACTIONS ) +{ + hbqt_par_QAbstractItemModel( 1 )->setSupportedDragActions( ( Qt::DropActions ) hb_parni( 2 ) ); +} + +/* + * QModelIndex sibling ( int row, int column, const QModelIndex & index ) const + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_SIBLING ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QModelIndex( hbqt_par_QAbstractItemModel( 1 )->sibling( hb_parni( 2 ), hb_parni( 3 ), *hbqt_par_QModelIndex( 4 ) ) ), release_QModelIndex ) ); +} + +/* + * virtual void sort ( int column, Qt::SortOrder order = Qt::AscendingOrder ) + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_SORT ) +{ + hbqt_par_QAbstractItemModel( 1 )->sort( hb_parni( 2 ), ( HB_ISNUM( 3 ) ? ( Qt::SortOrder ) hb_parni( 3 ) : ( Qt::SortOrder ) Qt::AscendingOrder ) ); +} + +/* + * virtual QSize span ( const QModelIndex & index ) const + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_SPAN ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QSize( hbqt_par_QAbstractItemModel( 1 )->span( *hbqt_par_QModelIndex( 2 ) ) ), release_QSize ) ); +} + +/* + * Qt::DropActions supportedDragActions () const + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_SUPPORTEDDRAGACTIONS ) +{ + hb_retni( ( Qt::DropActions ) hbqt_par_QAbstractItemModel( 1 )->supportedDragActions() ); +} + +/* + * virtual Qt::DropActions supportedDropActions () const + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_SUPPORTEDDROPACTIONS ) +{ + hb_retni( ( Qt::DropActions ) hbqt_par_QAbstractItemModel( 1 )->supportedDropActions() ); +} + +/* + * virtual void revert () + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_REVERT ) +{ + hbqt_par_QAbstractItemModel( 1 )->revert(); +} + +/* + * virtual bool submit () + */ +HB_FUNC( QT_QABSTRACTITEMMODEL_SUBMIT ) +{ + hb_retl( hbqt_par_QAbstractItemModel( 1 )->submit() ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QAbstractListModel.cpp b/harbour/contrib/hbqt/qtcore/QAbstractListModel.cpp new file mode 100644 index 0000000000..7094198b66 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QAbstractListModel.cpp @@ -0,0 +1,116 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +#include + +#include + + +/* + * QAbstractListModel ( QObject * parent = 0 ) + * ~QAbstractListModel () + */ + +QT_G_FUNC( release_QAbstractListModel ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QAbstractListModel" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + const QMetaObject * m = ( ( QObject * ) ph )->metaObject(); + if( ( QString ) m->className() != ( QString ) "QObject" ) + { + delete ( ( QAbstractListModel * ) ph ); + ph = NULL; + } + else + { +#if defined(__debug__) + hb_snprintf( str, sizeof(str), " Object Name Missing: QAbstractListModel" ); OutputDebugString( str ); +#endif + } + } +} + +HB_FUNC( QT_QABSTRACTLISTMODEL ) +{ +} +/* + * virtual QModelIndex index ( int row, int column = 0, const QModelIndex & parent = QModelIndex() ) const + */ +HB_FUNC( QT_QABSTRACTLISTMODEL_INDEX ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QModelIndex( hbqt_par_QAbstractListModel( 1 )->index( hb_parni( 2 ), hb_parni( 3 ), ( HB_ISPOINTER( 4 ) ? *hbqt_par_QModelIndex( 4 ) : QModelIndex() ) ) ), release_QModelIndex ) ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QAbstractTableModel.cpp b/harbour/contrib/hbqt/qtcore/QAbstractTableModel.cpp new file mode 100644 index 0000000000..19a5ab8390 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QAbstractTableModel.cpp @@ -0,0 +1,116 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +#include + +#include + + +/* + * QAbstractTableModel ( QObject * parent = 0 ) + * ~QAbstractTableModel () + */ + +QT_G_FUNC( release_QAbstractTableModel ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QAbstractTableModel" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + const QMetaObject * m = ( ( QObject * ) ph )->metaObject(); + if( ( QString ) m->className() != ( QString ) "QObject" ) + { + delete ( ( QAbstractTableModel * ) ph ); + ph = NULL; + } + else + { +#if defined(__debug__) + hb_snprintf( str, sizeof(str), " Object Name Missing: QAbstractTableModel" ); OutputDebugString( str ); +#endif + } + } +} + +HB_FUNC( QT_QABSTRACTTABLEMODEL ) +{ +} +/* + * virtual QModelIndex index ( int row, int column, const QModelIndex & parent = QModelIndex() ) const + */ +HB_FUNC( QT_QABSTRACTTABLEMODEL_INDEX ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QModelIndex( hbqt_par_QAbstractTableModel( 1 )->index( hb_parni( 2 ), hb_parni( 3 ), ( HB_ISPOINTER( 4 ) ? *hbqt_par_QModelIndex( 4 ) : QModelIndex() ) ) ), release_QModelIndex ) ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QBitArray.cpp b/harbour/contrib/hbqt/qtcore/QBitArray.cpp new file mode 100644 index 0000000000..3993862908 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QBitArray.cpp @@ -0,0 +1,235 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +#include + +#include + + +/* QBitArray () + * QBitArray ( int size, bool value = false ) + * QBitArray ( const QBitArray & other ) + */ + +QT_G_FUNC( release_QBitArray ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QBitArray" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QBitArray * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QBITARRAY ) +{ + QGC_POINTER * p = ( QGC_POINTER * ) hb_gcAlloc( sizeof( QGC_POINTER ), Q_release ); + void * pObj = NULL; + + pObj = new QBitArray() ; + + p->ph = pObj; + p->func = release_QBitArray; + + hb_retptrGC( p ); +} +/* + * bool at ( int i ) const + */ +HB_FUNC( QT_QBITARRAY_AT ) +{ + hb_retl( hbqt_par_QBitArray( 1 )->at( hb_parni( 2 ) ) ); +} + +/* + * void clear () + */ +HB_FUNC( QT_QBITARRAY_CLEAR ) +{ + hbqt_par_QBitArray( 1 )->clear(); +} + +/* + * void clearBit ( int i ) + */ +HB_FUNC( QT_QBITARRAY_CLEARBIT ) +{ + hbqt_par_QBitArray( 1 )->clearBit( hb_parni( 2 ) ); +} + +/* + * int count () const + */ +HB_FUNC( QT_QBITARRAY_COUNT ) +{ + hb_retni( hbqt_par_QBitArray( 1 )->count() ); +} + +/* + * int count ( bool on ) const + */ +HB_FUNC( QT_QBITARRAY_COUNT_1 ) +{ + hb_retni( hbqt_par_QBitArray( 1 )->count( hb_parl( 2 ) ) ); +} + +/* + * bool fill ( bool value, int size = -1 ) + */ +HB_FUNC( QT_QBITARRAY_FILL ) +{ + hb_retl( hbqt_par_QBitArray( 1 )->fill( hb_parl( 2 ), ( HB_ISNUM( 3 ) ? hb_parni( 3 ) : -1 ) ) ); +} + +/* + * void fill ( bool value, int begin, int end ) + */ +HB_FUNC( QT_QBITARRAY_FILL_1 ) +{ + hbqt_par_QBitArray( 1 )->fill( hb_parl( 2 ), hb_parni( 3 ), hb_parni( 4 ) ); +} + +/* + * bool isEmpty () const + */ +HB_FUNC( QT_QBITARRAY_ISEMPTY ) +{ + hb_retl( hbqt_par_QBitArray( 1 )->isEmpty() ); +} + +/* + * bool isNull () const + */ +HB_FUNC( QT_QBITARRAY_ISNULL ) +{ + hb_retl( hbqt_par_QBitArray( 1 )->isNull() ); +} + +/* + * void resize ( int size ) + */ +HB_FUNC( QT_QBITARRAY_RESIZE ) +{ + hbqt_par_QBitArray( 1 )->resize( hb_parni( 2 ) ); +} + +/* + * void setBit ( int i ) + */ +HB_FUNC( QT_QBITARRAY_SETBIT ) +{ + hbqt_par_QBitArray( 1 )->setBit( hb_parni( 2 ) ); +} + +/* + * void setBit ( int i, bool value ) + */ +HB_FUNC( QT_QBITARRAY_SETBIT_1 ) +{ + hbqt_par_QBitArray( 1 )->setBit( hb_parni( 2 ), hb_parl( 3 ) ); +} + +/* + * int size () const + */ +HB_FUNC( QT_QBITARRAY_SIZE ) +{ + hb_retni( hbqt_par_QBitArray( 1 )->size() ); +} + +/* + * bool testBit ( int i ) const + */ +HB_FUNC( QT_QBITARRAY_TESTBIT ) +{ + hb_retl( hbqt_par_QBitArray( 1 )->testBit( hb_parni( 2 ) ) ); +} + +/* + * bool toggleBit ( int i ) + */ +HB_FUNC( QT_QBITARRAY_TOGGLEBIT ) +{ + hb_retl( hbqt_par_QBitArray( 1 )->toggleBit( hb_parni( 2 ) ) ); +} + +/* + * void truncate ( int pos ) + */ +HB_FUNC( QT_QBITARRAY_TRUNCATE ) +{ + hbqt_par_QBitArray( 1 )->truncate( hb_parni( 2 ) ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QByteArray.cpp b/harbour/contrib/hbqt/qtcore/QByteArray.cpp new file mode 100644 index 0000000000..429a7a0047 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QByteArray.cpp @@ -0,0 +1,941 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +/* + * Constructed[ 97/101 [ 96.04% ] ] + * + * *** Unconvered Prototypes *** + * ----------------------------- + * + * QList split ( char sep ) const + * + * *** Commented out protos which construct fine but do not compile *** + * + * // bool contains ( const QByteArray & ba ) const + * // bool contains ( const char * str ) const + * // bool contains ( char ch ) const + */ + +#include + +#include + + +/* QByteArray () + * QByteArray ( const char * str ) + * QByteArray ( const char * data, int size ) + * QByteArray ( int size, char ch ) + * QByteArray ( const QByteArray & other ) + * ~QByteArray () + */ + +QT_G_FUNC( release_QByteArray ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QByteArray" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QByteArray * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QBYTEARRAY ) +{ + QGC_POINTER * p = ( QGC_POINTER * ) hb_gcAlloc( sizeof( QGC_POINTER ), Q_release ); + void * pObj = NULL; + + pObj = new QByteArray() ; + + p->ph = pObj; + p->func = release_QByteArray; + + hb_retptrGC( p ); +} +/* + * QByteArray & append ( const QByteArray & ba ) + */ +HB_FUNC( QT_QBYTEARRAY_APPEND ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->append( *hbqt_par_QByteArray( 2 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & append ( const QString & str ) + */ +HB_FUNC( QT_QBYTEARRAY_APPEND_1 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->append( hbqt_par_QString( 2 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & append ( const char * str ) + */ +HB_FUNC( QT_QBYTEARRAY_APPEND_2 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->append( hbqt_par_char( 2 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & append ( const char * str, int len ) + */ +HB_FUNC( QT_QBYTEARRAY_APPEND_3 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->append( hbqt_par_char( 2 ), hb_parni( 3 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & append ( char ch ) + */ +HB_FUNC( QT_QBYTEARRAY_APPEND_4 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->append( ( char ) hb_parni( 2 ) ) ), release_QByteArray ) ); +} + +/* + * char at ( int i ) const + */ +HB_FUNC( QT_QBYTEARRAY_AT ) +{ + hb_retni( hbqt_par_QByteArray( 1 )->at( hb_parni( 2 ) ) ); +} + +/* + * int capacity () const + */ +HB_FUNC( QT_QBYTEARRAY_CAPACITY ) +{ + hb_retni( hbqt_par_QByteArray( 1 )->capacity() ); +} + +/* + * void chop ( int n ) + */ +HB_FUNC( QT_QBYTEARRAY_CHOP ) +{ + hbqt_par_QByteArray( 1 )->chop( hb_parni( 2 ) ); +} + +/* + * void clear () + */ +HB_FUNC( QT_QBYTEARRAY_CLEAR ) +{ + hbqt_par_QByteArray( 1 )->clear(); +} + +/* + * const char * constData () const + */ +HB_FUNC( QT_QBYTEARRAY_CONSTDATA ) +{ + hb_retc( hbqt_par_QByteArray( 1 )->constData() ); +} + +/* + * int count ( const QByteArray & ba ) const + */ +HB_FUNC( QT_QBYTEARRAY_COUNT ) +{ + hb_retni( hbqt_par_QByteArray( 1 )->count( *hbqt_par_QByteArray( 2 ) ) ); +} + +/* + * int count ( const char * str ) const + */ +HB_FUNC( QT_QBYTEARRAY_COUNT_1 ) +{ + hb_retni( hbqt_par_QByteArray( 1 )->count( hbqt_par_char( 2 ) ) ); +} + +/* + * int count ( char ch ) const + */ +HB_FUNC( QT_QBYTEARRAY_COUNT_2 ) +{ + hb_retni( hbqt_par_QByteArray( 1 )->count( ( char ) hb_parni( 2 ) ) ); +} + +/* + * int count () const + */ +HB_FUNC( QT_QBYTEARRAY_COUNT_3 ) +{ + hb_retni( hbqt_par_QByteArray( 1 )->count() ); +} + +/* + * char * data () + */ +HB_FUNC( QT_QBYTEARRAY_DATA ) +{ + hb_retc( hbqt_par_QByteArray( 1 )->data() ); +} + +/* + * const char * data () const + */ +HB_FUNC( QT_QBYTEARRAY_DATA_1 ) +{ + hb_retc( hbqt_par_QByteArray( 1 )->data() ); +} + +/* + * bool endsWith ( const QByteArray & ba ) const + */ +HB_FUNC( QT_QBYTEARRAY_ENDSWITH ) +{ + hb_retl( hbqt_par_QByteArray( 1 )->endsWith( *hbqt_par_QByteArray( 2 ) ) ); +} + +/* + * bool endsWith ( const char * str ) const + */ +HB_FUNC( QT_QBYTEARRAY_ENDSWITH_1 ) +{ + hb_retl( hbqt_par_QByteArray( 1 )->endsWith( hbqt_par_char( 2 ) ) ); +} + +/* + * bool endsWith ( char ch ) const + */ +HB_FUNC( QT_QBYTEARRAY_ENDSWITH_2 ) +{ + hb_retl( hbqt_par_QByteArray( 1 )->endsWith( ( char ) hb_parni( 2 ) ) ); +} + +/* + * QByteArray & fill ( char ch, int size = -1 ) + */ +HB_FUNC( QT_QBYTEARRAY_FILL ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->fill( ( char ) hb_parni( 2 ), ( HB_ISNUM( 3 ) ? hb_parni( 3 ) : -1 ) ) ), release_QByteArray ) ); +} + +/* + * int indexOf ( const QByteArray & ba, int from = 0 ) const + */ +HB_FUNC( QT_QBYTEARRAY_INDEXOF ) +{ + hb_retni( hbqt_par_QByteArray( 1 )->indexOf( *hbqt_par_QByteArray( 2 ), hb_parni( 3 ) ) ); +} + +/* + * int indexOf ( const QString & str, int from = 0 ) const + */ +HB_FUNC( QT_QBYTEARRAY_INDEXOF_1 ) +{ + hb_retni( hbqt_par_QByteArray( 1 )->indexOf( hbqt_par_QString( 2 ), hb_parni( 3 ) ) ); +} + +/* + * int indexOf ( const char * str, int from = 0 ) const + */ +HB_FUNC( QT_QBYTEARRAY_INDEXOF_2 ) +{ + hb_retni( hbqt_par_QByteArray( 1 )->indexOf( hbqt_par_char( 2 ), hb_parni( 3 ) ) ); +} + +/* + * int indexOf ( char ch, int from = 0 ) const + */ +HB_FUNC( QT_QBYTEARRAY_INDEXOF_3 ) +{ + hb_retni( hbqt_par_QByteArray( 1 )->indexOf( ( char ) hb_parni( 2 ), hb_parni( 3 ) ) ); +} + +/* + * QByteArray & insert ( int i, const QByteArray & ba ) + */ +HB_FUNC( QT_QBYTEARRAY_INSERT ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->insert( hb_parni( 2 ), *hbqt_par_QByteArray( 3 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & insert ( int i, const QString & str ) + */ +HB_FUNC( QT_QBYTEARRAY_INSERT_1 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->insert( hb_parni( 2 ), hbqt_par_QString( 3 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & insert ( int i, const char * str ) + */ +HB_FUNC( QT_QBYTEARRAY_INSERT_2 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->insert( hb_parni( 2 ), hbqt_par_char( 3 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & insert ( int i, char ch ) + */ +HB_FUNC( QT_QBYTEARRAY_INSERT_3 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->insert( hb_parni( 2 ), ( char ) hb_parni( 3 ) ) ), release_QByteArray ) ); +} + +/* + * bool isEmpty () const + */ +HB_FUNC( QT_QBYTEARRAY_ISEMPTY ) +{ + hb_retl( hbqt_par_QByteArray( 1 )->isEmpty() ); +} + +/* + * bool isNull () const + */ +HB_FUNC( QT_QBYTEARRAY_ISNULL ) +{ + hb_retl( hbqt_par_QByteArray( 1 )->isNull() ); +} + +/* + * int lastIndexOf ( const QByteArray & ba, int from = -1 ) const + */ +HB_FUNC( QT_QBYTEARRAY_LASTINDEXOF ) +{ + hb_retni( hbqt_par_QByteArray( 1 )->lastIndexOf( *hbqt_par_QByteArray( 2 ), ( HB_ISNUM( 3 ) ? hb_parni( 3 ) : -1 ) ) ); +} + +/* + * int lastIndexOf ( const QString & str, int from = -1 ) const + */ +HB_FUNC( QT_QBYTEARRAY_LASTINDEXOF_1 ) +{ + hb_retni( hbqt_par_QByteArray( 1 )->lastIndexOf( hbqt_par_QString( 2 ), ( HB_ISNUM( 3 ) ? hb_parni( 3 ) : -1 ) ) ); +} + +/* + * int lastIndexOf ( const char * str, int from = -1 ) const + */ +HB_FUNC( QT_QBYTEARRAY_LASTINDEXOF_2 ) +{ + hb_retni( hbqt_par_QByteArray( 1 )->lastIndexOf( hbqt_par_char( 2 ), ( HB_ISNUM( 3 ) ? hb_parni( 3 ) : -1 ) ) ); +} + +/* + * int lastIndexOf ( char ch, int from = -1 ) const + */ +HB_FUNC( QT_QBYTEARRAY_LASTINDEXOF_3 ) +{ + hb_retni( hbqt_par_QByteArray( 1 )->lastIndexOf( ( char ) hb_parni( 2 ), ( HB_ISNUM( 3 ) ? hb_parni( 3 ) : -1 ) ) ); +} + +/* + * QByteArray left ( int len ) const + */ +HB_FUNC( QT_QBYTEARRAY_LEFT ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->left( hb_parni( 2 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray leftJustified ( int width, char fill = ' ', bool truncate = false ) const + */ +HB_FUNC( QT_QBYTEARRAY_LEFTJUSTIFIED ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->leftJustified( hb_parni( 2 ), ( char ) hb_parni( 3 ), hb_parl( 4 ) ) ), release_QByteArray ) ); +} + +/* + * int length () const + */ +HB_FUNC( QT_QBYTEARRAY_LENGTH ) +{ + hb_retni( hbqt_par_QByteArray( 1 )->length() ); +} + +/* + * QByteArray mid ( int pos, int len = -1 ) const + */ +HB_FUNC( QT_QBYTEARRAY_MID ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->mid( hb_parni( 2 ), ( HB_ISNUM( 3 ) ? hb_parni( 3 ) : -1 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & prepend ( const QByteArray & ba ) + */ +HB_FUNC( QT_QBYTEARRAY_PREPEND ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->prepend( *hbqt_par_QByteArray( 2 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & prepend ( const char * str ) + */ +HB_FUNC( QT_QBYTEARRAY_PREPEND_1 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->prepend( hbqt_par_char( 2 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & prepend ( char ch ) + */ +HB_FUNC( QT_QBYTEARRAY_PREPEND_2 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->prepend( ( char ) hb_parni( 2 ) ) ), release_QByteArray ) ); +} + +/* + * void push_back ( const QByteArray & other ) + */ +HB_FUNC( QT_QBYTEARRAY_PUSH_BACK ) +{ + hbqt_par_QByteArray( 1 )->push_back( *hbqt_par_QByteArray( 2 ) ); +} + +/* + * void push_back ( const char * str ) + */ +HB_FUNC( QT_QBYTEARRAY_PUSH_BACK_1 ) +{ + hbqt_par_QByteArray( 1 )->push_back( hbqt_par_char( 2 ) ); +} + +/* + * void push_back ( char ch ) + */ +HB_FUNC( QT_QBYTEARRAY_PUSH_BACK_2 ) +{ + hbqt_par_QByteArray( 1 )->push_back( ( char ) hb_parni( 2 ) ); +} + +/* + * void push_front ( const QByteArray & other ) + */ +HB_FUNC( QT_QBYTEARRAY_PUSH_FRONT ) +{ + hbqt_par_QByteArray( 1 )->push_front( *hbqt_par_QByteArray( 2 ) ); +} + +/* + * void push_front ( const char * str ) + */ +HB_FUNC( QT_QBYTEARRAY_PUSH_FRONT_1 ) +{ + hbqt_par_QByteArray( 1 )->push_front( hbqt_par_char( 2 ) ); +} + +/* + * void push_front ( char ch ) + */ +HB_FUNC( QT_QBYTEARRAY_PUSH_FRONT_2 ) +{ + hbqt_par_QByteArray( 1 )->push_front( ( char ) hb_parni( 2 ) ); +} + +/* + * QByteArray & remove ( int pos, int len ) + */ +HB_FUNC( QT_QBYTEARRAY_REMOVE ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->remove( hb_parni( 2 ), hb_parni( 3 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray repeated ( int times ) const + */ +HB_FUNC( QT_QBYTEARRAY_REPEATED ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->repeated( hb_parni( 2 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & replace ( int pos, int len, const QByteArray & after ) + */ +HB_FUNC( QT_QBYTEARRAY_REPLACE ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->replace( hb_parni( 2 ), hb_parni( 3 ), *hbqt_par_QByteArray( 4 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & replace ( int pos, int len, const char * after ) + */ +HB_FUNC( QT_QBYTEARRAY_REPLACE_1 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->replace( hb_parni( 2 ), hb_parni( 3 ), hbqt_par_char( 4 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & replace ( const QByteArray & before, const QByteArray & after ) + */ +HB_FUNC( QT_QBYTEARRAY_REPLACE_2 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->replace( *hbqt_par_QByteArray( 2 ), *hbqt_par_QByteArray( 3 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & replace ( const char * before, const QByteArray & after ) + */ +HB_FUNC( QT_QBYTEARRAY_REPLACE_3 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->replace( hbqt_par_char( 2 ), *hbqt_par_QByteArray( 3 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & replace ( const char * before, int bsize, const char * after, int asize ) + */ +HB_FUNC( QT_QBYTEARRAY_REPLACE_4 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->replace( hbqt_par_char( 2 ), hb_parni( 3 ), hbqt_par_char( 4 ), hb_parni( 5 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & replace ( const QByteArray & before, const char * after ) + */ +HB_FUNC( QT_QBYTEARRAY_REPLACE_5 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->replace( *hbqt_par_QByteArray( 2 ), hbqt_par_char( 3 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & replace ( const QString & before, const QByteArray & after ) + */ +HB_FUNC( QT_QBYTEARRAY_REPLACE_6 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->replace( hbqt_par_QString( 2 ), *hbqt_par_QByteArray( 3 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & replace ( const QString & before, const char * after ) + */ +HB_FUNC( QT_QBYTEARRAY_REPLACE_7 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->replace( hbqt_par_QString( 2 ), hbqt_par_char( 3 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & replace ( const char * before, const char * after ) + */ +HB_FUNC( QT_QBYTEARRAY_REPLACE_8 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->replace( hbqt_par_char( 2 ), hbqt_par_char( 3 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & replace ( char before, const QByteArray & after ) + */ +HB_FUNC( QT_QBYTEARRAY_REPLACE_9 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->replace( ( char ) hb_parni( 2 ), *hbqt_par_QByteArray( 3 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & replace ( char before, const QString & after ) + */ +HB_FUNC( QT_QBYTEARRAY_REPLACE_10 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->replace( ( char ) hb_parni( 2 ), hbqt_par_QString( 3 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & replace ( char before, const char * after ) + */ +HB_FUNC( QT_QBYTEARRAY_REPLACE_11 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->replace( ( char ) hb_parni( 2 ), hbqt_par_char( 3 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & replace ( char before, char after ) + */ +HB_FUNC( QT_QBYTEARRAY_REPLACE_12 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->replace( ( char ) hb_parni( 2 ), ( char ) hb_parni( 3 ) ) ), release_QByteArray ) ); +} + +/* + * void reserve ( int size ) + */ +HB_FUNC( QT_QBYTEARRAY_RESERVE ) +{ + hbqt_par_QByteArray( 1 )->reserve( hb_parni( 2 ) ); +} + +/* + * void resize ( int size ) + */ +HB_FUNC( QT_QBYTEARRAY_RESIZE ) +{ + hbqt_par_QByteArray( 1 )->resize( hb_parni( 2 ) ); +} + +/* + * QByteArray right ( int len ) const + */ +HB_FUNC( QT_QBYTEARRAY_RIGHT ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->right( hb_parni( 2 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray rightJustified ( int width, char fill = ' ', bool truncate = false ) const + */ +HB_FUNC( QT_QBYTEARRAY_RIGHTJUSTIFIED ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->rightJustified( hb_parni( 2 ), ( char ) hb_parni( 3 ), hb_parl( 4 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & setNum ( int n, int base = 10 ) + */ +HB_FUNC( QT_QBYTEARRAY_SETNUM ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->setNum( hb_parni( 2 ), ( HB_ISNUM( 3 ) ? hb_parni( 3 ) : 10 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & setNum ( uint n, int base = 10 ) + */ +HB_FUNC( QT_QBYTEARRAY_SETNUM_1 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->setNum( hb_parni( 2 ), ( HB_ISNUM( 3 ) ? hb_parni( 3 ) : 10 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & setNum ( short n, int base = 10 ) + */ +HB_FUNC( QT_QBYTEARRAY_SETNUM_2 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->setNum( hb_parni( 2 ), ( HB_ISNUM( 3 ) ? hb_parni( 3 ) : 10 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & setNum ( ushort n, int base = 10 ) + */ +HB_FUNC( QT_QBYTEARRAY_SETNUM_3 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->setNum( hb_parni( 2 ), ( HB_ISNUM( 3 ) ? hb_parni( 3 ) : 10 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & setNum ( qlonglong n, int base = 10 ) + */ +HB_FUNC( QT_QBYTEARRAY_SETNUM_4 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->setNum( hb_parnint( 2 ), ( HB_ISNUM( 3 ) ? hb_parni( 3 ) : 10 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & setNum ( qulonglong n, int base = 10 ) + */ +HB_FUNC( QT_QBYTEARRAY_SETNUM_5 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->setNum( hb_parnint( 2 ), ( HB_ISNUM( 3 ) ? hb_parni( 3 ) : 10 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & setNum ( double n, char f = 'g', int prec = 6 ) + */ +HB_FUNC( QT_QBYTEARRAY_SETNUM_6 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->setNum( hb_parnd( 2 ), ( char ) hb_parni( 3 ), ( HB_ISNUM( 4 ) ? hb_parni( 4 ) : 6 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray & setNum ( float n, char f = 'g', int prec = 6 ) + */ +HB_FUNC( QT_QBYTEARRAY_SETNUM_7 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->setNum( hb_parnd( 2 ), ( char ) hb_parni( 3 ), ( HB_ISNUM( 4 ) ? hb_parni( 4 ) : 6 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray simplified () const + */ +HB_FUNC( QT_QBYTEARRAY_SIMPLIFIED ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->simplified() ), release_QByteArray ) ); +} + +/* + * int size () const + */ +HB_FUNC( QT_QBYTEARRAY_SIZE ) +{ + hb_retni( hbqt_par_QByteArray( 1 )->size() ); +} + +/* + * void squeeze () + */ +HB_FUNC( QT_QBYTEARRAY_SQUEEZE ) +{ + hbqt_par_QByteArray( 1 )->squeeze(); +} + +/* + * bool startsWith ( const QByteArray & ba ) const + */ +HB_FUNC( QT_QBYTEARRAY_STARTSWITH ) +{ + hb_retl( hbqt_par_QByteArray( 1 )->startsWith( *hbqt_par_QByteArray( 2 ) ) ); +} + +/* + * bool startsWith ( const char * str ) const + */ +HB_FUNC( QT_QBYTEARRAY_STARTSWITH_1 ) +{ + hb_retl( hbqt_par_QByteArray( 1 )->startsWith( hbqt_par_char( 2 ) ) ); +} + +/* + * bool startsWith ( char ch ) const + */ +HB_FUNC( QT_QBYTEARRAY_STARTSWITH_2 ) +{ + hb_retl( hbqt_par_QByteArray( 1 )->startsWith( ( char ) hb_parni( 2 ) ) ); +} + +/* + * QByteArray toBase64 () const + */ +HB_FUNC( QT_QBYTEARRAY_TOBASE64 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->toBase64() ), release_QByteArray ) ); +} + +/* + * double toDouble ( bool * ok = 0 ) const + */ +HB_FUNC( QT_QBYTEARRAY_TODOUBLE ) +{ + bool iOk = 0; + + hb_retnd( hbqt_par_QByteArray( 1 )->toDouble( &iOk ) ); + + hb_stornl( iOk, 2 ); +} + +/* + * float toFloat ( bool * ok = 0 ) const + */ +HB_FUNC( QT_QBYTEARRAY_TOFLOAT ) +{ + bool iOk = 0; + + hb_retnd( hbqt_par_QByteArray( 1 )->toFloat( &iOk ) ); + + hb_stornl( iOk, 2 ); +} + +/* + * QByteArray toHex () const + */ +HB_FUNC( QT_QBYTEARRAY_TOHEX ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->toHex() ), release_QByteArray ) ); +} + +/* + * int toInt ( bool * ok = 0, int base = 10 ) const + */ +HB_FUNC( QT_QBYTEARRAY_TOINT ) +{ + bool iOk = 0; + + hb_retni( hbqt_par_QByteArray( 1 )->toInt( &iOk, ( HB_ISNUM( 3 ) ? hb_parni( 3 ) : 10 ) ) ); + + hb_stornl( iOk, 2 ); +} + +/* + * long toLong ( bool * ok = 0, int base = 10 ) const + */ +HB_FUNC( QT_QBYTEARRAY_TOLONG ) +{ + bool iOk = 0; + + hb_retnint( hbqt_par_QByteArray( 1 )->toLong( &iOk, ( HB_ISNUM( 3 ) ? hb_parni( 3 ) : 10 ) ) ); + + hb_stornl( iOk, 2 ); +} + +/* + * qlonglong toLongLong ( bool * ok = 0, int base = 10 ) const + */ +HB_FUNC( QT_QBYTEARRAY_TOLONGLONG ) +{ + bool iOk = 0; + + hb_retnint( hbqt_par_QByteArray( 1 )->toLongLong( &iOk, ( HB_ISNUM( 3 ) ? hb_parni( 3 ) : 10 ) ) ); + + hb_stornl( iOk, 2 ); +} + +/* + * QByteArray toLower () const + */ +HB_FUNC( QT_QBYTEARRAY_TOLOWER ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->toLower() ), release_QByteArray ) ); +} + +/* + * QByteArray toPercentEncoding ( const QByteArray & exclude = QByteArray(), const QByteArray & include = QByteArray(), char percent = '%' ) const + */ +HB_FUNC( QT_QBYTEARRAY_TOPERCENTENCODING ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->toPercentEncoding( ( HB_ISPOINTER( 2 ) ? *hbqt_par_QByteArray( 2 ) : QByteArray() ), ( HB_ISPOINTER( 3 ) ? *hbqt_par_QByteArray( 3 ) : QByteArray() ), ( char ) hb_parni( 4 ) ) ), release_QByteArray ) ); +} + +/* + * short toShort ( bool * ok = 0, int base = 10 ) const + */ +HB_FUNC( QT_QBYTEARRAY_TOSHORT ) +{ + bool iOk = 0; + + hb_retni( hbqt_par_QByteArray( 1 )->toShort( &iOk, ( HB_ISNUM( 3 ) ? hb_parni( 3 ) : 10 ) ) ); + + hb_stornl( iOk, 2 ); +} + +/* + * uint toUInt ( bool * ok = 0, int base = 10 ) const + */ +HB_FUNC( QT_QBYTEARRAY_TOUINT ) +{ + bool iOk = 0; + + hb_retni( hbqt_par_QByteArray( 1 )->toUInt( &iOk, ( HB_ISNUM( 3 ) ? hb_parni( 3 ) : 10 ) ) ); + + hb_stornl( iOk, 2 ); +} + +/* + * ulong toULong ( bool * ok = 0, int base = 10 ) const + */ +HB_FUNC( QT_QBYTEARRAY_TOULONG ) +{ + bool iOk = 0; + + hb_retnint( hbqt_par_QByteArray( 1 )->toULong( &iOk, ( HB_ISNUM( 3 ) ? hb_parni( 3 ) : 10 ) ) ); + + hb_stornl( iOk, 2 ); +} + +/* + * qulonglong toULongLong ( bool * ok = 0, int base = 10 ) const + */ +HB_FUNC( QT_QBYTEARRAY_TOULONGLONG ) +{ + bool iOk = 0; + + hb_retnint( hbqt_par_QByteArray( 1 )->toULongLong( &iOk, ( HB_ISNUM( 3 ) ? hb_parni( 3 ) : 10 ) ) ); + + hb_stornl( iOk, 2 ); +} + +/* + * ushort toUShort ( bool * ok = 0, int base = 10 ) const + */ +HB_FUNC( QT_QBYTEARRAY_TOUSHORT ) +{ + bool iOk = 0; + + hb_retni( hbqt_par_QByteArray( 1 )->toUShort( &iOk, ( HB_ISNUM( 3 ) ? hb_parni( 3 ) : 10 ) ) ); + + hb_stornl( iOk, 2 ); +} + +/* + * QByteArray toUpper () const + */ +HB_FUNC( QT_QBYTEARRAY_TOUPPER ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->toUpper() ), release_QByteArray ) ); +} + +/* + * QByteArray trimmed () const + */ +HB_FUNC( QT_QBYTEARRAY_TRIMMED ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QByteArray( 1 )->trimmed() ), release_QByteArray ) ); +} + +/* + * void truncate ( int pos ) + */ +HB_FUNC( QT_QBYTEARRAY_TRUNCATE ) +{ + hbqt_par_QByteArray( 1 )->truncate( hb_parni( 2 ) ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QCoreApplication.cpp b/harbour/contrib/hbqt/qtcore/QCoreApplication.cpp new file mode 100644 index 0000000000..0918aedf92 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QCoreApplication.cpp @@ -0,0 +1,447 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +/* + * enum Encoding { CodecForTr, UnicodeUTF8, DefaultCodec } + */ + +/* + * Constructed[ 40/43 [ 93.02% ] ] + * + * *** Unconvered Prototypes *** + * ----------------------------- + * + * EventFilter setEventFilter ( EventFilter filter ) + * + * *** Commented out protos which construct fine but do not compile *** + * + * // bool filterEvent ( void * message, long * result ) + * // virtual bool winEventFilter ( MSG * msg, long * result ) + */ + +#include + +#include +#include + + +/* + * QCoreApplication ( int & argc, char ** argv ) + * ~QCoreApplication () + */ + +QT_G_FUNC( release_QCoreApplication ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QCoreApplication" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + const QMetaObject * m = ( ( QObject * ) ph )->metaObject(); + if( ( QString ) m->className() != ( QString ) "QObject" ) + { + delete ( ( QCoreApplication * ) ph ); + ph = NULL; + } + else + { +#if defined(__debug__) + hb_snprintf( str, sizeof(str), " Object Name Missing: QCoreApplication" ); OutputDebugString( str ); +#endif + } + } +} + +HB_FUNC( QT_QCOREAPPLICATION ) +{ +} +/* + * virtual bool notify ( QObject * receiver, QEvent * event ) + */ +HB_FUNC( QT_QCOREAPPLICATION_NOTIFY ) +{ + hb_retl( hbqt_par_QCoreApplication( 1 )->notify( hbqt_par_QObject( 2 ), hbqt_par_QEvent( 3 ) ) ); +} + +/* + * void addLibraryPath ( const QString & path ) + */ +HB_FUNC( QT_QCOREAPPLICATION_ADDLIBRARYPATH ) +{ + hbqt_par_QCoreApplication( 1 )->addLibraryPath( hbqt_par_QString( 2 ) ); +} + +/* + * QString applicationDirPath () + */ +HB_FUNC( QT_QCOREAPPLICATION_APPLICATIONDIRPATH ) +{ + hb_retc( hbqt_par_QCoreApplication( 1 )->applicationDirPath().toAscii().data() ); +} + +/* + * QString applicationFilePath () + */ +HB_FUNC( QT_QCOREAPPLICATION_APPLICATIONFILEPATH ) +{ + hb_retc( hbqt_par_QCoreApplication( 1 )->applicationFilePath().toAscii().data() ); +} + +/* + * QString applicationName () + */ +HB_FUNC( QT_QCOREAPPLICATION_APPLICATIONNAME ) +{ + hb_retc( hbqt_par_QCoreApplication( 1 )->applicationName().toAscii().data() ); +} + +/* + * qint64 applicationPid () + */ +HB_FUNC( QT_QCOREAPPLICATION_APPLICATIONPID ) +{ + hb_retnint( hbqt_par_QCoreApplication( 1 )->applicationPid() ); +} + +/* + * QString applicationVersion () + */ +HB_FUNC( QT_QCOREAPPLICATION_APPLICATIONVERSION ) +{ + hb_retc( hbqt_par_QCoreApplication( 1 )->applicationVersion().toAscii().data() ); +} + +/* + * QStringList arguments () + */ +HB_FUNC( QT_QCOREAPPLICATION_ARGUMENTS ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QStringList( hbqt_par_QCoreApplication( 1 )->arguments() ), release_QStringList ) ); +} + +/* + * bool closingDown () + */ +HB_FUNC( QT_QCOREAPPLICATION_CLOSINGDOWN ) +{ + hb_retl( hbqt_par_QCoreApplication( 1 )->closingDown() ); +} + +/* + * int exec () + */ +HB_FUNC( QT_QCOREAPPLICATION_EXEC ) +{ + hb_retni( hbqt_par_QCoreApplication( 1 )->exec() ); +} + +/* + * void exit ( int returnCode = 0 ) + */ +HB_FUNC( QT_QCOREAPPLICATION_EXIT ) +{ + hbqt_par_QCoreApplication( 1 )->exit( hb_parni( 2 ) ); +} + +/* + * void flush () + */ +HB_FUNC( QT_QCOREAPPLICATION_FLUSH ) +{ + hbqt_par_QCoreApplication( 1 )->flush(); +} + +/* + * bool hasPendingEvents () + */ +HB_FUNC( QT_QCOREAPPLICATION_HASPENDINGEVENTS ) +{ + hb_retl( hbqt_par_QCoreApplication( 1 )->hasPendingEvents() ); +} + +/* + * void installTranslator ( QTranslator * translationFile ) + */ +HB_FUNC( QT_QCOREAPPLICATION_INSTALLTRANSLATOR ) +{ + hbqt_par_QCoreApplication( 1 )->installTranslator( hbqt_par_QTranslator( 2 ) ); +} + +/* + * QCoreApplication * instance () + */ +HB_FUNC( QT_QCOREAPPLICATION_INSTANCE ) +{ + hb_retptr( ( QCoreApplication* ) hbqt_par_QCoreApplication( 1 )->instance() ); +} + +/* + * QStringList libraryPaths () + */ +HB_FUNC( QT_QCOREAPPLICATION_LIBRARYPATHS ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QStringList( hbqt_par_QCoreApplication( 1 )->libraryPaths() ), release_QStringList ) ); +} + +/* + * QString organizationDomain () + */ +HB_FUNC( QT_QCOREAPPLICATION_ORGANIZATIONDOMAIN ) +{ + hb_retc( hbqt_par_QCoreApplication( 1 )->organizationDomain().toAscii().data() ); +} + +/* + * QString organizationName () + */ +HB_FUNC( QT_QCOREAPPLICATION_ORGANIZATIONNAME ) +{ + hb_retc( hbqt_par_QCoreApplication( 1 )->organizationName().toAscii().data() ); +} + +/* + * void postEvent ( QObject * receiver, QEvent * event ) + */ +HB_FUNC( QT_QCOREAPPLICATION_POSTEVENT ) +{ + hbqt_par_QCoreApplication( 1 )->postEvent( hbqt_par_QObject( 2 ), hbqt_par_QEvent( 3 ) ); +} + +/* + * void postEvent ( QObject * receiver, QEvent * event, int priority ) + */ +HB_FUNC( QT_QCOREAPPLICATION_POSTEVENT_1 ) +{ + hbqt_par_QCoreApplication( 1 )->postEvent( hbqt_par_QObject( 2 ), hbqt_par_QEvent( 3 ), hb_parni( 4 ) ); +} + +/* + * void processEvents ( QEventLoop::ProcessEventsFlags flags = QEventLoop::AllEvents ) + */ +HB_FUNC( QT_QCOREAPPLICATION_PROCESSEVENTS ) +{ + hbqt_par_QCoreApplication( 1 )->processEvents( ( HB_ISNUM( 2 ) ? ( QEventLoop::ProcessEventsFlags ) hb_parni( 2 ) : ( QEventLoop::ProcessEventsFlags ) QEventLoop::AllEvents ) ); +} + +/* + * void processEvents ( QEventLoop::ProcessEventsFlags flags, int maxtime ) + */ +HB_FUNC( QT_QCOREAPPLICATION_PROCESSEVENTS_1 ) +{ + hbqt_par_QCoreApplication( 1 )->processEvents( ( QEventLoop::ProcessEventsFlags ) hb_parni( 2 ), hb_parni( 3 ) ); +} + +/* + * void removeLibraryPath ( const QString & path ) + */ +HB_FUNC( QT_QCOREAPPLICATION_REMOVELIBRARYPATH ) +{ + hbqt_par_QCoreApplication( 1 )->removeLibraryPath( hbqt_par_QString( 2 ) ); +} + +/* + * void removePostedEvents ( QObject * receiver ) + */ +HB_FUNC( QT_QCOREAPPLICATION_REMOVEPOSTEDEVENTS ) +{ + hbqt_par_QCoreApplication( 1 )->removePostedEvents( hbqt_par_QObject( 2 ) ); +} + +/* + * void removePostedEvents ( QObject * receiver, int eventType ) + */ +HB_FUNC( QT_QCOREAPPLICATION_REMOVEPOSTEDEVENTS_1 ) +{ + hbqt_par_QCoreApplication( 1 )->removePostedEvents( hbqt_par_QObject( 2 ), hb_parni( 3 ) ); +} + +/* + * void removeTranslator ( QTranslator * translationFile ) + */ +HB_FUNC( QT_QCOREAPPLICATION_REMOVETRANSLATOR ) +{ + hbqt_par_QCoreApplication( 1 )->removeTranslator( hbqt_par_QTranslator( 2 ) ); +} + +/* + * bool sendEvent ( QObject * receiver, QEvent * event ) + */ +HB_FUNC( QT_QCOREAPPLICATION_SENDEVENT ) +{ + hb_retl( hbqt_par_QCoreApplication( 1 )->sendEvent( hbqt_par_QObject( 2 ), hbqt_par_QEvent( 3 ) ) ); +} + +/* + * void sendPostedEvents ( QObject * receiver, int event_type ) + */ +HB_FUNC( QT_QCOREAPPLICATION_SENDPOSTEDEVENTS ) +{ + hbqt_par_QCoreApplication( 1 )->sendPostedEvents( hbqt_par_QObject( 2 ), hb_parni( 3 ) ); +} + +/* + * void sendPostedEvents () + */ +HB_FUNC( QT_QCOREAPPLICATION_SENDPOSTEDEVENTS_1 ) +{ + hbqt_par_QCoreApplication( 1 )->sendPostedEvents(); +} + +/* + * void setApplicationName ( const QString & application ) + */ +HB_FUNC( QT_QCOREAPPLICATION_SETAPPLICATIONNAME ) +{ + hbqt_par_QCoreApplication( 1 )->setApplicationName( hbqt_par_QString( 2 ) ); +} + +/* + * void setApplicationVersion ( const QString & version ) + */ +HB_FUNC( QT_QCOREAPPLICATION_SETAPPLICATIONVERSION ) +{ + hbqt_par_QCoreApplication( 1 )->setApplicationVersion( hbqt_par_QString( 2 ) ); +} + +/* + * void setAttribute ( Qt::ApplicationAttribute attribute, bool on = true ) + */ +HB_FUNC( QT_QCOREAPPLICATION_SETATTRIBUTE ) +{ + hbqt_par_QCoreApplication( 1 )->setAttribute( ( Qt::ApplicationAttribute ) hb_parni( 2 ), hb_parl( 3 ) ); +} + +/* + * void setLibraryPaths ( const QStringList & paths ) + */ +HB_FUNC( QT_QCOREAPPLICATION_SETLIBRARYPATHS ) +{ + hbqt_par_QCoreApplication( 1 )->setLibraryPaths( *hbqt_par_QStringList( 2 ) ); +} + +/* + * void setOrganizationDomain ( const QString & orgDomain ) + */ +HB_FUNC( QT_QCOREAPPLICATION_SETORGANIZATIONDOMAIN ) +{ + hbqt_par_QCoreApplication( 1 )->setOrganizationDomain( hbqt_par_QString( 2 ) ); +} + +/* + * void setOrganizationName ( const QString & orgName ) + */ +HB_FUNC( QT_QCOREAPPLICATION_SETORGANIZATIONNAME ) +{ + hbqt_par_QCoreApplication( 1 )->setOrganizationName( hbqt_par_QString( 2 ) ); +} + +/* + * bool startingUp () + */ +HB_FUNC( QT_QCOREAPPLICATION_STARTINGUP ) +{ + hb_retl( hbqt_par_QCoreApplication( 1 )->startingUp() ); +} + +/* + * bool testAttribute ( Qt::ApplicationAttribute attribute ) + */ +HB_FUNC( QT_QCOREAPPLICATION_TESTATTRIBUTE ) +{ + hb_retl( hbqt_par_QCoreApplication( 1 )->testAttribute( ( Qt::ApplicationAttribute ) hb_parni( 2 ) ) ); +} + +/* + * QString translate ( const char * context, const char * sourceText, const char * disambiguation, Encoding encoding, int n ) + */ +HB_FUNC( QT_QCOREAPPLICATION_TRANSLATE ) +{ + hb_retc( hbqt_par_QCoreApplication( 1 )->translate( hbqt_par_char( 2 ), hbqt_par_char( 3 ), hbqt_par_char( 4 ), ( QCoreApplication::Encoding ) hb_parni( 5 ), hb_parni( 6 ) ).toAscii().data() ); +} + +/* + * QString translate ( const char * context, const char * sourceText, const char * disambiguation = 0, Encoding encoding = CodecForTr ) + */ +HB_FUNC( QT_QCOREAPPLICATION_TRANSLATE_1 ) +{ + hb_retc( hbqt_par_QCoreApplication( 1 )->translate( hbqt_par_char( 2 ), hbqt_par_char( 3 ), hbqt_par_char( 4 ), ( HB_ISNUM( 5 ) ? ( QCoreApplication::Encoding ) hb_parni( 5 ) : ( QCoreApplication::Encoding ) QCoreApplication::CodecForTr ) ).toAscii().data() ); +} + +/* + * void quit () + */ +HB_FUNC( QT_QCOREAPPLICATION_QUIT ) +{ + hbqt_par_QCoreApplication( 1 )->quit(); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QDataStream.cpp b/harbour/contrib/hbqt/qtcore/QDataStream.cpp new file mode 100644 index 0000000000..ae4395e11b --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QDataStream.cpp @@ -0,0 +1,215 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +/* + * enum ByteOrder { BigEndian, LittleEndian } + * enum Status { Ok, ReadPastEnd, ReadCorruptData } + * enum Version { Qt_1_0, Qt_2_0, Qt_2_1, Qt_3_0, ..., Qt_4_5 } + */ + +#include + +#include + + +/* QDataStream () + * QDataStream ( QIODevice * d ) + * QDataStream ( QByteArray * a, QIODevice::OpenMode mode ) + * QDataStream ( const QByteArray & a ) + * virtual ~QDataStream () + */ + +QT_G_FUNC( release_QDataStream ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QDataStream" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QDataStream * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QDATASTREAM ) +{ + void * pObj = NULL; + + pObj = new QDataStream() ; + + hb_retptr( pObj ); +} +/* + * bool atEnd () const + */ +HB_FUNC( QT_QDATASTREAM_ATEND ) +{ + hb_retl( hbqt_par_QDataStream( 1 )->atEnd() ); +} + +/* + * ByteOrder byteOrder () const + */ +HB_FUNC( QT_QDATASTREAM_BYTEORDER ) +{ + hb_retni( ( QDataStream::ByteOrder ) hbqt_par_QDataStream( 1 )->byteOrder() ); +} + +/* + * QIODevice * device () const + */ +HB_FUNC( QT_QDATASTREAM_DEVICE ) +{ + hb_retptr( ( QIODevice* ) hbqt_par_QDataStream( 1 )->device() ); +} + +/* + * int readRawData ( char * s, int len ) + */ +HB_FUNC( QT_QDATASTREAM_READRAWDATA ) +{ + hb_retni( hbqt_par_QDataStream( 1 )->readRawData( ( char * ) hb_parc( 2 ), hb_parni( 3 ) ) ); +} + +/* + * void resetStatus () + */ +HB_FUNC( QT_QDATASTREAM_RESETSTATUS ) +{ + hbqt_par_QDataStream( 1 )->resetStatus(); +} + +/* + * void setByteOrder ( ByteOrder bo ) + */ +HB_FUNC( QT_QDATASTREAM_SETBYTEORDER ) +{ + hbqt_par_QDataStream( 1 )->setByteOrder( ( QDataStream::ByteOrder ) hb_parni( 2 ) ); +} + +/* + * void setDevice ( QIODevice * d ) + */ +HB_FUNC( QT_QDATASTREAM_SETDEVICE ) +{ + hbqt_par_QDataStream( 1 )->setDevice( hbqt_par_QIODevice( 2 ) ); +} + +/* + * void setStatus ( Status status ) + */ +HB_FUNC( QT_QDATASTREAM_SETSTATUS ) +{ + hbqt_par_QDataStream( 1 )->setStatus( ( QDataStream::Status ) hb_parni( 2 ) ); +} + +/* + * void setVersion ( int v ) + */ +HB_FUNC( QT_QDATASTREAM_SETVERSION ) +{ + hbqt_par_QDataStream( 1 )->setVersion( hb_parni( 2 ) ); +} + +/* + * int skipRawData ( int len ) + */ +HB_FUNC( QT_QDATASTREAM_SKIPRAWDATA ) +{ + hb_retni( hbqt_par_QDataStream( 1 )->skipRawData( hb_parni( 2 ) ) ); +} + +/* + * Status status () const + */ +HB_FUNC( QT_QDATASTREAM_STATUS ) +{ + hb_retni( ( QDataStream::Status ) hbqt_par_QDataStream( 1 )->status() ); +} + +/* + * int version () const + */ +HB_FUNC( QT_QDATASTREAM_VERSION ) +{ + hb_retni( hbqt_par_QDataStream( 1 )->version() ); +} + +/* + * int writeRawData ( const char * s, int len ) + */ +HB_FUNC( QT_QDATASTREAM_WRITERAWDATA ) +{ + hb_retni( hbqt_par_QDataStream( 1 )->writeRawData( hbqt_par_char( 2 ), hb_parni( 3 ) ) ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QDate.cpp b/harbour/contrib/hbqt/qtcore/QDate.cpp new file mode 100644 index 0000000000..014bee0050 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QDate.cpp @@ -0,0 +1,274 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +/* + * enum MonthNameType { DateFormat, StandaloneFormat } + */ + +#include + +#include + + +/* QDate () + * QDate ( int y, int m, int d ) + */ + +QT_G_FUNC( release_QDate ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QDate" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QDate * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QDATE ) +{ + QGC_POINTER * p = ( QGC_POINTER * ) hb_gcAlloc( sizeof( QGC_POINTER ), Q_release ); + void * pObj = NULL; + + pObj = new QDate() ; + + p->ph = pObj; + p->func = release_QDate; + + hb_retptrGC( p ); +} +/* + * QDate addDays ( int ndays ) const + */ +HB_FUNC( QT_QDATE_ADDDAYS ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDate( hbqt_par_QDate( 1 )->addDays( hb_parni( 2 ) ) ), release_QDate ) ); +} + +/* + * QDate addMonths ( int nmonths ) const + */ +HB_FUNC( QT_QDATE_ADDMONTHS ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDate( hbqt_par_QDate( 1 )->addMonths( hb_parni( 2 ) ) ), release_QDate ) ); +} + +/* + * QDate addYears ( int nyears ) const + */ +HB_FUNC( QT_QDATE_ADDYEARS ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDate( hbqt_par_QDate( 1 )->addYears( hb_parni( 2 ) ) ), release_QDate ) ); +} + +/* + * int day () const + */ +HB_FUNC( QT_QDATE_DAY ) +{ + hb_retni( hbqt_par_QDate( 1 )->day() ); +} + +/* + * int dayOfWeek () const + */ +HB_FUNC( QT_QDATE_DAYOFWEEK ) +{ + hb_retni( hbqt_par_QDate( 1 )->dayOfWeek() ); +} + +/* + * int dayOfYear () const + */ +HB_FUNC( QT_QDATE_DAYOFYEAR ) +{ + hb_retni( hbqt_par_QDate( 1 )->dayOfYear() ); +} + +/* + * int daysInMonth () const + */ +HB_FUNC( QT_QDATE_DAYSINMONTH ) +{ + hb_retni( hbqt_par_QDate( 1 )->daysInMonth() ); +} + +/* + * int daysInYear () const + */ +HB_FUNC( QT_QDATE_DAYSINYEAR ) +{ + hb_retni( hbqt_par_QDate( 1 )->daysInYear() ); +} + +/* + * int daysTo ( const QDate & d ) const + */ +HB_FUNC( QT_QDATE_DAYSTO ) +{ + hb_retni( hbqt_par_QDate( 1 )->daysTo( *hbqt_par_QDate( 2 ) ) ); +} + +/* + * void getDate ( int * year, int * month, int * day ) + */ +HB_FUNC( QT_QDATE_GETDATE ) +{ + int iYear = 0; + int iMonth = 0; + int iDay = 0; + + hbqt_par_QDate( 1 )->getDate( &iYear, &iMonth, &iDay ); + + hb_storni( iYear, 2 ); + hb_storni( iMonth, 3 ); + hb_storni( iDay, 4 ); +} + +/* + * bool isNull () const + */ +HB_FUNC( QT_QDATE_ISNULL ) +{ + hb_retl( hbqt_par_QDate( 1 )->isNull() ); +} + +/* + * bool isValid () const + */ +HB_FUNC( QT_QDATE_ISVALID ) +{ + hb_retl( hbqt_par_QDate( 1 )->isValid() ); +} + +/* + * int month () const + */ +HB_FUNC( QT_QDATE_MONTH ) +{ + hb_retni( hbqt_par_QDate( 1 )->month() ); +} + +/* + * bool setDate ( int year, int month, int day ) + */ +HB_FUNC( QT_QDATE_SETDATE ) +{ + hb_retl( hbqt_par_QDate( 1 )->setDate( hb_parni( 2 ), hb_parni( 3 ), hb_parni( 4 ) ) ); +} + +/* + * int toJulianDay () const + */ +HB_FUNC( QT_QDATE_TOJULIANDAY ) +{ + hb_retni( hbqt_par_QDate( 1 )->toJulianDay() ); +} + +/* + * QString toString ( const QString & format ) const + */ +HB_FUNC( QT_QDATE_TOSTRING ) +{ + hb_retc( hbqt_par_QDate( 1 )->toString( hbqt_par_QString( 2 ) ).toAscii().data() ); +} + +/* + * QString toString ( Qt::DateFormat format = Qt::TextDate ) const + */ +HB_FUNC( QT_QDATE_TOSTRING_1 ) +{ + hb_retc( hbqt_par_QDate( 1 )->toString( ( HB_ISNUM( 2 ) ? ( Qt::DateFormat ) hb_parni( 2 ) : ( Qt::DateFormat ) Qt::TextDate ) ).toAscii().data() ); +} + +/* + * int weekNumber ( int * yearNumber = 0 ) const + */ +HB_FUNC( QT_QDATE_WEEKNUMBER ) +{ + int iYearNumber = 0; + + hb_retni( hbqt_par_QDate( 1 )->weekNumber( &iYearNumber ) ); + + hb_storni( iYearNumber, 2 ); +} + +/* + * int year () const + */ +HB_FUNC( QT_QDATE_YEAR ) +{ + hb_retni( hbqt_par_QDate( 1 )->year() ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QDateTime.cpp b/harbour/contrib/hbqt/qtcore/QDateTime.cpp new file mode 100644 index 0000000000..d0aa1d7a86 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QDateTime.cpp @@ -0,0 +1,318 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +#include + +#include + + +/* + * QDateTime () + * QDateTime ( const QDate & date ) + * QDateTime ( const QDate & date, const QTime & time, Qt::TimeSpec spec = Qt::LocalTime ) + * QDateTime ( const QDateTime & other ) + * ~QDateTime () + */ + +QT_G_FUNC( release_QDateTime ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QDateTime" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QDateTime * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QDATETIME ) +{ + QGC_POINTER * p = ( QGC_POINTER * ) hb_gcAlloc( sizeof( QGC_POINTER ), Q_release ); + void * pObj = NULL; + + pObj = ( QDateTime* ) new QDateTime() ; + + p->ph = pObj; + p->func = release_QDateTime; + + hb_retptrGC( p ); +} +/* + * QDateTime addDays ( int ndays ) const + */ +HB_FUNC( QT_QDATETIME_ADDDAYS ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDateTime( hbqt_par_QDateTime( 1 )->addDays( hb_parni( 2 ) ) ), release_QDateTime ) ); +} + +/* + * QDateTime addMSecs ( qint64 msecs ) const + */ +HB_FUNC( QT_QDATETIME_ADDMSECS ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDateTime( hbqt_par_QDateTime( 1 )->addMSecs( hb_parnint( 2 ) ) ), release_QDateTime ) ); +} + +/* + * QDateTime addMonths ( int nmonths ) const + */ +HB_FUNC( QT_QDATETIME_ADDMONTHS ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDateTime( hbqt_par_QDateTime( 1 )->addMonths( hb_parni( 2 ) ) ), release_QDateTime ) ); +} + +/* + * QDateTime addSecs ( int s ) const + */ +HB_FUNC( QT_QDATETIME_ADDSECS ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDateTime( hbqt_par_QDateTime( 1 )->addSecs( hb_parni( 2 ) ) ), release_QDateTime ) ); +} + +/* + * QDateTime addYears ( int nyears ) const + */ +HB_FUNC( QT_QDATETIME_ADDYEARS ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDateTime( hbqt_par_QDateTime( 1 )->addYears( hb_parni( 2 ) ) ), release_QDateTime ) ); +} + +/* + * QDate date () const + */ +HB_FUNC( QT_QDATETIME_DATE ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDate( hbqt_par_QDateTime( 1 )->date() ), release_QDate ) ); +} + +/* + * int daysTo ( const QDateTime & other ) const + */ +HB_FUNC( QT_QDATETIME_DAYSTO ) +{ + hb_retni( hbqt_par_QDateTime( 1 )->daysTo( *hbqt_par_QDateTime( 2 ) ) ); +} + +/* + * bool isNull () const + */ +HB_FUNC( QT_QDATETIME_ISNULL ) +{ + hb_retl( hbqt_par_QDateTime( 1 )->isNull() ); +} + +/* + * bool isValid () const + */ +HB_FUNC( QT_QDATETIME_ISVALID ) +{ + hb_retl( hbqt_par_QDateTime( 1 )->isValid() ); +} + +/* + * int secsTo ( const QDateTime & other ) const + */ +HB_FUNC( QT_QDATETIME_SECSTO ) +{ + hb_retni( hbqt_par_QDateTime( 1 )->secsTo( *hbqt_par_QDateTime( 2 ) ) ); +} + +/* + * void setDate ( const QDate & date ) + */ +HB_FUNC( QT_QDATETIME_SETDATE ) +{ + hbqt_par_QDateTime( 1 )->setDate( *hbqt_par_QDate( 2 ) ); +} + +/* + * void setTime ( const QTime & time ) + */ +HB_FUNC( QT_QDATETIME_SETTIME ) +{ + hbqt_par_QDateTime( 1 )->setTime( *hbqt_par_QTime( 2 ) ); +} + +/* + * void setTimeSpec ( Qt::TimeSpec spec ) + */ +HB_FUNC( QT_QDATETIME_SETTIMESPEC ) +{ + hbqt_par_QDateTime( 1 )->setTimeSpec( ( Qt::TimeSpec ) hb_parni( 2 ) ); +} + +/* + * void setTime_t ( uint seconds ) + */ +HB_FUNC( QT_QDATETIME_SETTIME_T ) +{ + hbqt_par_QDateTime( 1 )->setTime_t( hb_parni( 2 ) ); +} + +/* + * QTime time () const + */ +HB_FUNC( QT_QDATETIME_TIME ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QTime( hbqt_par_QDateTime( 1 )->time() ), release_QTime ) ); +} + +/* + * Qt::TimeSpec timeSpec () const + */ +HB_FUNC( QT_QDATETIME_TIMESPEC ) +{ + hb_retni( ( Qt::TimeSpec ) hbqt_par_QDateTime( 1 )->timeSpec() ); +} + +/* + * QDateTime toLocalTime () const + */ +HB_FUNC( QT_QDATETIME_TOLOCALTIME ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDateTime( hbqt_par_QDateTime( 1 )->toLocalTime() ), release_QDateTime ) ); +} + +/* + * QString toString ( const QString & format ) const + */ +HB_FUNC( QT_QDATETIME_TOSTRING ) +{ + hb_retc( hbqt_par_QDateTime( 1 )->toString( hbqt_par_QString( 2 ) ).toAscii().data() ); +} + +/* + * QString toString ( Qt::DateFormat format = Qt::TextDate ) const + */ +HB_FUNC( QT_QDATETIME_TOSTRING_1 ) +{ + hb_retc( hbqt_par_QDateTime( 1 )->toString( ( HB_ISNUM( 2 ) ? ( Qt::DateFormat ) hb_parni( 2 ) : ( Qt::DateFormat ) Qt::TextDate ) ).toAscii().data() ); +} + +/* + * QDateTime toTimeSpec ( Qt::TimeSpec specification ) const + */ +HB_FUNC( QT_QDATETIME_TOTIMESPEC ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDateTime( hbqt_par_QDateTime( 1 )->toTimeSpec( ( Qt::TimeSpec ) hb_parni( 2 ) ) ), release_QDateTime ) ); +} + +/* + * uint toTime_t () const + */ +HB_FUNC( QT_QDATETIME_TOTIME_T ) +{ + hb_retni( hbqt_par_QDateTime( 1 )->toTime_t() ); +} + +/* + * QDateTime toUTC () const + */ +HB_FUNC( QT_QDATETIME_TOUTC ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDateTime( hbqt_par_QDateTime( 1 )->toUTC() ), release_QDateTime ) ); +} + +/* + * QDateTime currentDateTime () + */ +HB_FUNC( QT_QDATETIME_CURRENTDATETIME ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDateTime( hbqt_par_QDateTime( 1 )->currentDateTime() ), release_QDateTime ) ); +} + +/* + * QDateTime fromString ( const QString & string, Qt::DateFormat format = Qt::TextDate ) + */ +HB_FUNC( QT_QDATETIME_FROMSTRING ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDateTime( hbqt_par_QDateTime( 1 )->fromString( hbqt_par_QString( 2 ), ( HB_ISNUM( 3 ) ? ( Qt::DateFormat ) hb_parni( 3 ) : ( Qt::DateFormat ) Qt::TextDate ) ) ), release_QDateTime ) ); +} + +/* + * QDateTime fromString ( const QString & string, const QString & format ) + */ +HB_FUNC( QT_QDATETIME_FROMSTRING_1 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDateTime( hbqt_par_QDateTime( 1 )->fromString( hbqt_par_QString( 2 ), hbqt_par_QString( 3 ) ) ), release_QDateTime ) ); +} + +/* + * QDateTime fromTime_t ( uint seconds ) + */ +HB_FUNC( QT_QDATETIME_FROMTIME_T ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDateTime( hbqt_par_QDateTime( 1 )->fromTime_t( hb_parni( 2 ) ) ), release_QDateTime ) ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QDir.cpp b/harbour/contrib/hbqt/qtcore/QDir.cpp new file mode 100644 index 0000000000..c219ae6749 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QDir.cpp @@ -0,0 +1,532 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +/* + * enum Filter { Dirs, AllDirs, Files, Drives, ..., CaseSensitive } + * enum SortFlag { Name, Time, Size, Type, ..., LocaleAware } + * flags Filters + * flags SortFlags + */ + +#include + +#include + + +/* + * QDir ( const QDir & dir ) + * QDir ( const QString & path = QString() ) + * QDir ( const QString & path, const QString & nameFilter, SortFlags sort = SortFlags( Name | IgnoreCase ), Filters filters = AllEntries ) + * ~QDir () + */ + +QT_G_FUNC( release_QDir ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QDir" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QDir * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QDIR ) +{ + QGC_POINTER * p = ( QGC_POINTER * ) hb_gcAlloc( sizeof( QGC_POINTER ), Q_release ); + void * pObj = NULL; + + pObj = new QDir( hbqt_par_QString( 1 ) ) ; + + p->ph = pObj; + p->func = release_QDir; + + hb_retptrGC( p ); +} +/* + * QString absoluteFilePath ( const QString & fileName ) const + */ +HB_FUNC( QT_QDIR_ABSOLUTEFILEPATH ) +{ + hb_retc( hbqt_par_QDir( 1 )->absoluteFilePath( hbqt_par_QString( 2 ) ).toAscii().data() ); +} + +/* + * QString absolutePath () const + */ +HB_FUNC( QT_QDIR_ABSOLUTEPATH ) +{ + hb_retc( hbqt_par_QDir( 1 )->absolutePath().toAscii().data() ); +} + +/* + * QString canonicalPath () const + */ +HB_FUNC( QT_QDIR_CANONICALPATH ) +{ + hb_retc( hbqt_par_QDir( 1 )->canonicalPath().toAscii().data() ); +} + +/* + * bool cd ( const QString & dirName ) + */ +HB_FUNC( QT_QDIR_CD ) +{ + hb_retl( hbqt_par_QDir( 1 )->cd( hbqt_par_QString( 2 ) ) ); +} + +/* + * bool cdUp () + */ +HB_FUNC( QT_QDIR_CDUP ) +{ + hb_retl( hbqt_par_QDir( 1 )->cdUp() ); +} + +/* + * uint count () const + */ +HB_FUNC( QT_QDIR_COUNT ) +{ + hb_retni( hbqt_par_QDir( 1 )->count() ); +} + +/* + * QString dirName () const + */ +HB_FUNC( QT_QDIR_DIRNAME ) +{ + hb_retc( hbqt_par_QDir( 1 )->dirName().toAscii().data() ); +} + +/* + * QStringList entryList ( const QStringList & nameFilters, Filters filters = NoFilter, SortFlags sort = NoSort ) const + */ +HB_FUNC( QT_QDIR_ENTRYLIST ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QStringList( hbqt_par_QDir( 1 )->entryList( *hbqt_par_QStringList( 2 ), ( HB_ISNUM( 3 ) ? ( QDir::Filters ) hb_parni( 3 ) : ( QDir::Filters ) QDir::NoFilter ), ( HB_ISNUM( 4 ) ? ( QDir::SortFlags ) hb_parni( 4 ) : ( QDir::SortFlags ) QDir::NoSort ) ) ), release_QStringList ) ); +} + +/* + * QStringList entryList ( Filters filters = NoFilter, SortFlags sort = NoSort ) const + */ +HB_FUNC( QT_QDIR_ENTRYLIST_1 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QStringList( hbqt_par_QDir( 1 )->entryList( ( HB_ISNUM( 2 ) ? ( QDir::Filters ) hb_parni( 2 ) : ( QDir::Filters ) QDir::NoFilter ), ( HB_ISNUM( 3 ) ? ( QDir::SortFlags ) hb_parni( 3 ) : ( QDir::SortFlags ) QDir::NoSort ) ) ), release_QStringList ) ); +} + +/* + * bool exists ( const QString & name ) const + */ +HB_FUNC( QT_QDIR_EXISTS ) +{ + hb_retl( hbqt_par_QDir( 1 )->exists( hbqt_par_QString( 2 ) ) ); +} + +/* + * bool exists () const + */ +HB_FUNC( QT_QDIR_EXISTS_1 ) +{ + hb_retl( hbqt_par_QDir( 1 )->exists() ); +} + +/* + * QString filePath ( const QString & fileName ) const + */ +HB_FUNC( QT_QDIR_FILEPATH ) +{ + hb_retc( hbqt_par_QDir( 1 )->filePath( hbqt_par_QString( 2 ) ).toAscii().data() ); +} + +/* + * Filters filter () const + */ +HB_FUNC( QT_QDIR_FILTER ) +{ + hb_retni( ( QDir::Filters ) hbqt_par_QDir( 1 )->filter() ); +} + +/* + * bool isAbsolute () const + */ +HB_FUNC( QT_QDIR_ISABSOLUTE ) +{ + hb_retl( hbqt_par_QDir( 1 )->isAbsolute() ); +} + +/* + * bool isReadable () const + */ +HB_FUNC( QT_QDIR_ISREADABLE ) +{ + hb_retl( hbqt_par_QDir( 1 )->isReadable() ); +} + +/* + * bool isRelative () const + */ +HB_FUNC( QT_QDIR_ISRELATIVE ) +{ + hb_retl( hbqt_par_QDir( 1 )->isRelative() ); +} + +/* + * bool isRoot () const + */ +HB_FUNC( QT_QDIR_ISROOT ) +{ + hb_retl( hbqt_par_QDir( 1 )->isRoot() ); +} + +/* + * bool makeAbsolute () + */ +HB_FUNC( QT_QDIR_MAKEABSOLUTE ) +{ + hb_retl( hbqt_par_QDir( 1 )->makeAbsolute() ); +} + +/* + * bool mkdir ( const QString & dirName ) const + */ +HB_FUNC( QT_QDIR_MKDIR ) +{ + hb_retl( hbqt_par_QDir( 1 )->mkdir( hbqt_par_QString( 2 ) ) ); +} + +/* + * bool mkpath ( const QString & dirPath ) const + */ +HB_FUNC( QT_QDIR_MKPATH ) +{ + hb_retl( hbqt_par_QDir( 1 )->mkpath( hbqt_par_QString( 2 ) ) ); +} + +/* + * QStringList nameFilters () const + */ +HB_FUNC( QT_QDIR_NAMEFILTERS ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QStringList( hbqt_par_QDir( 1 )->nameFilters() ), release_QStringList ) ); +} + +/* + * QString path () const + */ +HB_FUNC( QT_QDIR_PATH ) +{ + hb_retc( hbqt_par_QDir( 1 )->path().toAscii().data() ); +} + +/* + * void refresh () const + */ +HB_FUNC( QT_QDIR_REFRESH ) +{ + hbqt_par_QDir( 1 )->refresh(); +} + +/* + * QString relativeFilePath ( const QString & fileName ) const + */ +HB_FUNC( QT_QDIR_RELATIVEFILEPATH ) +{ + hb_retc( hbqt_par_QDir( 1 )->relativeFilePath( hbqt_par_QString( 2 ) ).toAscii().data() ); +} + +/* + * bool remove ( const QString & fileName ) + */ +HB_FUNC( QT_QDIR_REMOVE ) +{ + hb_retl( hbqt_par_QDir( 1 )->remove( hbqt_par_QString( 2 ) ) ); +} + +/* + * bool rename ( const QString & oldName, const QString & newName ) + */ +HB_FUNC( QT_QDIR_RENAME ) +{ + hb_retl( hbqt_par_QDir( 1 )->rename( hbqt_par_QString( 2 ), hbqt_par_QString( 3 ) ) ); +} + +/* + * bool rmdir ( const QString & dirName ) const + */ +HB_FUNC( QT_QDIR_RMDIR ) +{ + hb_retl( hbqt_par_QDir( 1 )->rmdir( hbqt_par_QString( 2 ) ) ); +} + +/* + * bool rmpath ( const QString & dirPath ) const + */ +HB_FUNC( QT_QDIR_RMPATH ) +{ + hb_retl( hbqt_par_QDir( 1 )->rmpath( hbqt_par_QString( 2 ) ) ); +} + +/* + * void setFilter ( Filters filters ) + */ +HB_FUNC( QT_QDIR_SETFILTER ) +{ + hbqt_par_QDir( 1 )->setFilter( ( QDir::Filters ) hb_parni( 2 ) ); +} + +/* + * void setNameFilters ( const QStringList & nameFilters ) + */ +HB_FUNC( QT_QDIR_SETNAMEFILTERS ) +{ + hbqt_par_QDir( 1 )->setNameFilters( *hbqt_par_QStringList( 2 ) ); +} + +/* + * void setPath ( const QString & path ) + */ +HB_FUNC( QT_QDIR_SETPATH ) +{ + hbqt_par_QDir( 1 )->setPath( hbqt_par_QString( 2 ) ); +} + +/* + * void setSorting ( SortFlags sort ) + */ +HB_FUNC( QT_QDIR_SETSORTING ) +{ + hbqt_par_QDir( 1 )->setSorting( ( QDir::SortFlags ) hb_parni( 2 ) ); +} + +/* + * SortFlags sorting () const + */ +HB_FUNC( QT_QDIR_SORTING ) +{ + hb_retni( ( QDir::SortFlags ) hbqt_par_QDir( 1 )->sorting() ); +} + +/* + * void addSearchPath ( const QString & prefix, const QString & path ) + */ +HB_FUNC( QT_QDIR_ADDSEARCHPATH ) +{ + hbqt_par_QDir( 1 )->addSearchPath( hbqt_par_QString( 2 ), hbqt_par_QString( 3 ) ); +} + +/* + * QString cleanPath ( const QString & path ) + */ +HB_FUNC( QT_QDIR_CLEANPATH ) +{ + hb_retc( hbqt_par_QDir( 1 )->cleanPath( hbqt_par_QString( 2 ) ).toAscii().data() ); +} + +/* + * QDir current () + */ +HB_FUNC( QT_QDIR_CURRENT ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDir( hbqt_par_QDir( 1 )->current() ), release_QDir ) ); +} + +/* + * QString currentPath () + */ +HB_FUNC( QT_QDIR_CURRENTPATH ) +{ + hb_retc( hbqt_par_QDir( 1 )->currentPath().toAscii().data() ); +} + +/* + * QString fromNativeSeparators ( const QString & pathName ) + */ +HB_FUNC( QT_QDIR_FROMNATIVESEPARATORS ) +{ + hb_retc( hbqt_par_QDir( 1 )->fromNativeSeparators( hbqt_par_QString( 2 ) ).toAscii().data() ); +} + +/* + * QDir home () + */ +HB_FUNC( QT_QDIR_HOME ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDir( hbqt_par_QDir( 1 )->home() ), release_QDir ) ); +} + +/* + * QString homePath () + */ +HB_FUNC( QT_QDIR_HOMEPATH ) +{ + hb_retc( hbqt_par_QDir( 1 )->homePath().toAscii().data() ); +} + +/* + * bool isAbsolutePath ( const QString & path ) + */ +HB_FUNC( QT_QDIR_ISABSOLUTEPATH ) +{ + hb_retl( hbqt_par_QDir( 1 )->isAbsolutePath( hbqt_par_QString( 2 ) ) ); +} + +/* + * bool isRelativePath ( const QString & path ) + */ +HB_FUNC( QT_QDIR_ISRELATIVEPATH ) +{ + hb_retl( hbqt_par_QDir( 1 )->isRelativePath( hbqt_par_QString( 2 ) ) ); +} + +/* + * bool match ( const QString & filter, const QString & fileName ) + */ +HB_FUNC( QT_QDIR_MATCH ) +{ + hb_retl( hbqt_par_QDir( 1 )->match( hbqt_par_QString( 2 ), hbqt_par_QString( 3 ) ) ); +} + +/* + * bool match ( const QStringList & filters, const QString & fileName ) + */ +HB_FUNC( QT_QDIR_MATCH_1 ) +{ + hb_retl( hbqt_par_QDir( 1 )->match( *hbqt_par_QStringList( 2 ), hbqt_par_QString( 3 ) ) ); +} + +/* + * QDir root () + */ +HB_FUNC( QT_QDIR_ROOT ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDir( hbqt_par_QDir( 1 )->root() ), release_QDir ) ); +} + +/* + * QString rootPath () + */ +HB_FUNC( QT_QDIR_ROOTPATH ) +{ + hb_retc( hbqt_par_QDir( 1 )->rootPath().toAscii().data() ); +} + +/* + * QStringList searchPaths ( const QString & prefix ) + */ +HB_FUNC( QT_QDIR_SEARCHPATHS ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QStringList( hbqt_par_QDir( 1 )->searchPaths( hbqt_par_QString( 2 ) ) ), release_QStringList ) ); +} + +/* + * bool setCurrent ( const QString & path ) + */ +HB_FUNC( QT_QDIR_SETCURRENT ) +{ + hb_retl( hbqt_par_QDir( 1 )->setCurrent( hbqt_par_QString( 2 ) ) ); +} + +/* + * void setSearchPaths ( const QString & prefix, const QStringList & searchPaths ) + */ +HB_FUNC( QT_QDIR_SETSEARCHPATHS ) +{ + hbqt_par_QDir( 1 )->setSearchPaths( hbqt_par_QString( 2 ), *hbqt_par_QStringList( 3 ) ); +} + +/* + * QDir temp () + */ +HB_FUNC( QT_QDIR_TEMP ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDir( hbqt_par_QDir( 1 )->temp() ), release_QDir ) ); +} + +/* + * QString tempPath () + */ +HB_FUNC( QT_QDIR_TEMPPATH ) +{ + hb_retc( hbqt_par_QDir( 1 )->tempPath().toAscii().data() ); +} + +/* + * QString toNativeSeparators ( const QString & pathName ) + */ +HB_FUNC( QT_QDIR_TONATIVESEPARATORS ) +{ + hb_retc( hbqt_par_QDir( 1 )->toNativeSeparators( hbqt_par_QString( 2 ) ).toAscii().data() ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QEvent.cpp b/harbour/contrib/hbqt/qtcore/QEvent.cpp new file mode 100644 index 0000000000..5c624ee05f --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QEvent.cpp @@ -0,0 +1,163 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +/* + * enum Type { None, AccessibilityDescription, AccessibilityHelp, AccessibilityPrepare, ..., MaxUser } + */ + +#include + +#include + + +/* + * QEvent ( Type type ) + * virtual ~QEvent () + */ + +QT_G_FUNC( release_QEvent ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QEvent" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QEvent * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QEVENT ) +{ + void * pObj = NULL; + + pObj = ( QEvent* ) new QEvent( ( QEvent::Type ) hb_parni( 1 ) ) ; + + hb_retptr( pObj ); +} +/* + * void accept () + */ +HB_FUNC( QT_QEVENT_ACCEPT ) +{ + hbqt_par_QEvent( 1 )->accept(); +} + +/* + * void ignore () + */ +HB_FUNC( QT_QEVENT_IGNORE ) +{ + hbqt_par_QEvent( 1 )->ignore(); +} + +/* + * bool isAccepted () const + */ +HB_FUNC( QT_QEVENT_ISACCEPTED ) +{ + hb_retl( hbqt_par_QEvent( 1 )->isAccepted() ); +} + +/* + * void setAccepted ( bool accepted ) + */ +HB_FUNC( QT_QEVENT_SETACCEPTED ) +{ + hbqt_par_QEvent( 1 )->setAccepted( hb_parl( 2 ) ); +} + +/* + * bool spontaneous () const + */ +HB_FUNC( QT_QEVENT_SPONTANEOUS ) +{ + hb_retl( hbqt_par_QEvent( 1 )->spontaneous() ); +} + +/* + * Type type () const + */ +HB_FUNC( QT_QEVENT_TYPE ) +{ + hb_retni( ( QEvent::Type ) hbqt_par_QEvent( 1 )->type() ); +} + +/* + * int registerEventType ( int hint = -1 ) + */ +HB_FUNC( QT_QEVENT_REGISTEREVENTTYPE ) +{ + hb_retni( hbqt_par_QEvent( 1 )->registerEventType( ( HB_ISNUM( 2 ) ? hb_parni( 2 ) : -1 ) ) ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QEventLoop.cpp b/harbour/contrib/hbqt/qtcore/QEventLoop.cpp new file mode 100644 index 0000000000..9a112234cb --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QEventLoop.cpp @@ -0,0 +1,170 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +/* + * enum ProcessEventsFlag { AllEvents, ExcludeUserInputEvents, ExcludeSocketNotifiers, WaitForMoreEvents, DeferredDeletion } + * flags ProcessEventsFlags + */ + +#include + +#include +#include + +/* + * QEventLoop ( QObject * parent = 0 ) + * ~QEventLoop () + */ + +QT_G_FUNC( release_QEventLoop ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QEventLoop" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + const QMetaObject * m = ( ( QObject * ) ph )->metaObject(); + if( ( QString ) m->className() != ( QString ) "QObject" ) + { + delete ( ( QEventLoop * ) ph ); + ph = NULL; + } + else + { +#if defined(__debug__) + hb_snprintf( str, sizeof(str), " Object Name Missing: QEventLoop" ); OutputDebugString( str ); +#endif + } + } +} + +HB_FUNC( QT_QEVENTLOOP ) +{ + QGC_POINTER * p = ( QGC_POINTER * ) hb_gcAlloc( sizeof( QGC_POINTER ), Q_release ); + QPointer< QEventLoop > pObj = NULL; + + pObj = new QEventLoop( hbqt_par_QObject( 1 ) ) ; + + p->ph = pObj; + p->func = release_QEventLoop; + + hb_retptrGC( p ); +} +/* + * int exec ( ProcessEventsFlags flags = AllEvents ) + */ +HB_FUNC( QT_QEVENTLOOP_EXEC ) +{ + hb_retni( hbqt_par_QEventLoop( 1 )->exec( ( HB_ISNUM( 2 ) ? ( QEventLoop::ProcessEventsFlags ) hb_parni( 2 ) : ( QEventLoop::ProcessEventsFlags ) QEventLoop::AllEvents ) ) ); +} + +/* + * void exit ( int returnCode = 0 ) + */ +HB_FUNC( QT_QEVENTLOOP_EXIT ) +{ + hbqt_par_QEventLoop( 1 )->exit( hb_parni( 2 ) ); +} + +/* + * bool isRunning () const + */ +HB_FUNC( QT_QEVENTLOOP_ISRUNNING ) +{ + hb_retl( hbqt_par_QEventLoop( 1 )->isRunning() ); +} + +/* + * bool processEvents ( ProcessEventsFlags flags = AllEvents ) + */ +HB_FUNC( QT_QEVENTLOOP_PROCESSEVENTS ) +{ + hb_retl( hbqt_par_QEventLoop( 1 )->processEvents( ( HB_ISNUM( 2 ) ? ( QEventLoop::ProcessEventsFlags ) hb_parni( 2 ) : ( QEventLoop::ProcessEventsFlags ) QEventLoop::AllEvents ) ) ); +} + +/* + * void processEvents ( ProcessEventsFlags flags, int maxTime ) + */ +HB_FUNC( QT_QEVENTLOOP_PROCESSEVENTS_1 ) +{ + hbqt_par_QEventLoop( 1 )->processEvents( ( QEventLoop::ProcessEventsFlags ) hb_parni( 2 ), hb_parni( 3 ) ); +} + +/* + * void wakeUp () + */ +HB_FUNC( QT_QEVENTLOOP_WAKEUP ) +{ + hbqt_par_QEventLoop( 1 )->wakeUp(); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QFile.cpp b/harbour/contrib/hbqt/qtcore/QFile.cpp new file mode 100644 index 0000000000..747fca4cfd --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QFile.cpp @@ -0,0 +1,402 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +/* + * enum FileError { NoError, ReadError, WriteError, FatalError, ..., CopyError } + * enum MemoryMapFlags { NoOptions } + * enum Permission { ReadOwner, WriteOwner, ExeOwner, ReadUser, ..., ExeOther } + * flags Permissions + * flags OpenMode + * enum OpenModeFlag { NotOpen, ReadOnly, WriteOnly, ReadWrite, ..., Unbuffered } + */ + +#include + +#include + + +/* QFile ( const QString & name ) + * QFile ( QObject * parent ) + * QFile ( const QString & name, QObject * parent ) + * ~QFile () + */ + +QT_G_FUNC( release_QFile ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QFile" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + const QMetaObject * m = ( ( QObject * ) ph )->metaObject(); + if( ( QString ) m->className() != ( QString ) "QObject" ) + { + delete ( ( QFile * ) ph ); + ph = NULL; + } + else + { +#if defined(__debug__) + hb_snprintf( str, sizeof(str), " Object Name Missing: QFile" ); OutputDebugString( str ); +#endif + } + } +} + +HB_FUNC( QT_QFILE ) +{ + QGC_POINTER * p = ( QGC_POINTER * ) hb_gcAlloc( sizeof( QGC_POINTER ), Q_release ); + QPointer< QFile > pObj = NULL; + + if( hb_pcount() == 1 && HB_ISCHAR( 1 ) ) + { + pObj = new QFile( hbqt_par_QString( 1 ) ) ; + } + + p->ph = pObj; + p->func = release_QFile; + + hb_retptrGC( p ); +} +/* + * virtual bool atEnd () const + */ +HB_FUNC( QT_QFILE_ATEND ) +{ + hb_retl( hbqt_par_QFile( 1 )->atEnd() ); +} + +/* + * virtual void close () + */ +HB_FUNC( QT_QFILE_CLOSE ) +{ + hbqt_par_QFile( 1 )->close(); +} + +/* + * bool copy ( const QString & newName ) + */ +HB_FUNC( QT_QFILE_COPY ) +{ + hb_retl( hbqt_par_QFile( 1 )->copy( hbqt_par_QString( 2 ) ) ); +} + +/* + * FileError error () const + */ +HB_FUNC( QT_QFILE_ERROR ) +{ + hb_retni( ( QFile::FileError ) hbqt_par_QFile( 1 )->error() ); +} + +/* + * bool exists () const + */ +HB_FUNC( QT_QFILE_EXISTS ) +{ + hb_retl( hbqt_par_QFile( 1 )->exists() ); +} + +/* + * QString fileName () const + */ +HB_FUNC( QT_QFILE_FILENAME ) +{ + hb_retc( hbqt_par_QFile( 1 )->fileName().toAscii().data() ); +} + +/* + * bool flush () + */ +HB_FUNC( QT_QFILE_FLUSH ) +{ + hb_retl( hbqt_par_QFile( 1 )->flush() ); +} + +/* + * int handle () const + */ +HB_FUNC( QT_QFILE_HANDLE ) +{ + hb_retni( hbqt_par_QFile( 1 )->handle() ); +} + +/* + * virtual bool isSequential () const + */ +HB_FUNC( QT_QFILE_ISSEQUENTIAL ) +{ + hb_retl( hbqt_par_QFile( 1 )->isSequential() ); +} + +/* + * bool link ( const QString & linkName ) + */ +HB_FUNC( QT_QFILE_LINK ) +{ + hb_retl( hbqt_par_QFile( 1 )->link( hbqt_par_QString( 2 ) ) ); +} + +/* + * uchar * map ( qint64 offset, qint64 size, MemoryMapFlags flags = NoOptions ) + */ +HB_FUNC( QT_QFILE_MAP ) +{ + hb_retptr( ( uchar* ) hbqt_par_QFile( 1 )->map( hb_parnint( 2 ), hb_parnint( 3 ), ( HB_ISNUM( 4 ) ? ( QFile::MemoryMapFlags ) hb_parni( 4 ) : ( QFile::MemoryMapFlags ) QFile::NoOptions ) ) ); +} + +/* + * virtual bool open ( OpenMode mode ) + */ +HB_FUNC( QT_QFILE_OPEN ) +{ + hb_retl( hbqt_par_QFile( 1 )->open( ( QFile::OpenMode ) hb_parni( 2 ) ) ); +} + +/* + * bool open ( int fd, OpenMode mode ) + */ +HB_FUNC( QT_QFILE_OPEN_1 ) +{ + hb_retl( hbqt_par_QFile( 1 )->open( hb_parni( 2 ), ( QFile::OpenMode ) hb_parni( 3 ) ) ); +} + +/* + * Permissions permissions () const + */ +HB_FUNC( QT_QFILE_PERMISSIONS ) +{ + hb_retni( ( QFile::Permissions ) hbqt_par_QFile( 1 )->permissions() ); +} + +/* + * bool remove () + */ +HB_FUNC( QT_QFILE_REMOVE ) +{ + hb_retl( hbqt_par_QFile( 1 )->remove() ); +} + +/* + * bool rename ( const QString & newName ) + */ +HB_FUNC( QT_QFILE_RENAME ) +{ + hb_retl( hbqt_par_QFile( 1 )->rename( hbqt_par_QString( 2 ) ) ); +} + +/* + * bool resize ( qint64 sz ) + */ +HB_FUNC( QT_QFILE_RESIZE ) +{ + hb_retl( hbqt_par_QFile( 1 )->resize( hb_parnint( 2 ) ) ); +} + +/* + * void setFileName ( const QString & name ) + */ +HB_FUNC( QT_QFILE_SETFILENAME ) +{ + hbqt_par_QFile( 1 )->setFileName( hbqt_par_QString( 2 ) ); +} + +/* + * bool setPermissions ( Permissions permissions ) + */ +HB_FUNC( QT_QFILE_SETPERMISSIONS ) +{ + hb_retl( hbqt_par_QFile( 1 )->setPermissions( ( QFile::Permissions ) hb_parni( 2 ) ) ); +} + +/* + * virtual qint64 size () const + */ +HB_FUNC( QT_QFILE_SIZE ) +{ + hb_retnint( hbqt_par_QFile( 1 )->size() ); +} + +/* + * QString symLinkTarget () const + */ +HB_FUNC( QT_QFILE_SYMLINKTARGET ) +{ + hb_retc( hbqt_par_QFile( 1 )->symLinkTarget().toAscii().data() ); +} + +/* + * void unsetError () + */ +HB_FUNC( QT_QFILE_UNSETERROR ) +{ + hbqt_par_QFile( 1 )->unsetError(); +} + +/* + * bool copy ( const QString & fileName, const QString & newName ) + */ +HB_FUNC( QT_QFILE_COPY_1 ) +{ + hb_retl( hbqt_par_QFile( 1 )->copy( hbqt_par_QString( 2 ), hbqt_par_QString( 3 ) ) ); +} + +/* + * QString decodeName ( const QByteArray & localFileName ) + */ +HB_FUNC( QT_QFILE_DECODENAME ) +{ + hb_retc( hbqt_par_QFile( 1 )->decodeName( *hbqt_par_QByteArray( 2 ) ).toAscii().data() ); +} + +/* + * QString decodeName ( const char * localFileName ) + */ +HB_FUNC( QT_QFILE_DECODENAME_1 ) +{ + hb_retc( hbqt_par_QFile( 1 )->decodeName( hbqt_par_char( 2 ) ).toAscii().data() ); +} + +/* + * QByteArray encodeName ( const QString & fileName ) + */ +HB_FUNC( QT_QFILE_ENCODENAME ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QFile( 1 )->encodeName( hbqt_par_QString( 2 ) ) ), release_QByteArray ) ); +} + +/* + * bool exists ( const QString & fileName ) + */ +HB_FUNC( QT_QFILE_EXISTS_1 ) +{ + hb_retl( hbqt_par_QFile( 1 )->exists( hbqt_par_QString( 2 ) ) ); +} + +/* + * bool link ( const QString & fileName, const QString & linkName ) + */ +HB_FUNC( QT_QFILE_LINK_1 ) +{ + hb_retl( hbqt_par_QFile( 1 )->link( hbqt_par_QString( 2 ), hbqt_par_QString( 3 ) ) ); +} + +/* + * Permissions permissions ( const QString & fileName ) + */ +HB_FUNC( QT_QFILE_PERMISSIONS_1 ) +{ + hb_retni( ( QFile::Permissions ) hbqt_par_QFile( 1 )->permissions( hbqt_par_QString( 2 ) ) ); +} + +/* + * bool remove ( const QString & fileName ) + */ +HB_FUNC( QT_QFILE_REMOVE_1 ) +{ + hb_retl( hbqt_par_QFile( 1 )->remove( hbqt_par_QString( 2 ) ) ); +} + +/* + * bool rename ( const QString & oldName, const QString & newName ) + */ +HB_FUNC( QT_QFILE_RENAME_1 ) +{ + hb_retl( hbqt_par_QFile( 1 )->rename( hbqt_par_QString( 2 ), hbqt_par_QString( 3 ) ) ); +} + +/* + * bool resize ( const QString & fileName, qint64 sz ) + */ +HB_FUNC( QT_QFILE_RESIZE_1 ) +{ + hb_retl( hbqt_par_QFile( 1 )->resize( hbqt_par_QString( 2 ), hb_parnint( 3 ) ) ); +} + +/* + * bool setPermissions ( const QString & fileName, Permissions permissions ) + */ +HB_FUNC( QT_QFILE_SETPERMISSIONS_1 ) +{ + hb_retl( hbqt_par_QFile( 1 )->setPermissions( hbqt_par_QString( 2 ), ( QFile::Permissions ) hb_parni( 3 ) ) ); +} + +/* + * QString symLinkTarget ( const QString & fileName ) + */ +HB_FUNC( QT_QFILE_SYMLINKTARGET_1 ) +{ + hb_retc( hbqt_par_QFile( 1 )->symLinkTarget( hbqt_par_QString( 2 ) ).toAscii().data() ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QFileInfo.cpp b/harbour/contrib/hbqt/qtcore/QFileInfo.cpp new file mode 100644 index 0000000000..c14ddfa229 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QFileInfo.cpp @@ -0,0 +1,464 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +/* + * flags PermissionSpec + */ + +#include + +#include +#include +#include + + +/* QFileInfo () + * QFileInfo ( const QString & file ) + * QFileInfo ( const QFile & file ) + * QFileInfo ( const QDir & dir, const QString & file ) + * QFileInfo ( const QFileInfo & fileinfo ) + * ~QFileInfo () + */ + +QT_G_FUNC( release_QFileInfo ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QFileInfo" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QFileInfo * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QFILEINFO ) +{ + void * pObj = NULL; + + pObj = new QFileInfo() ; + + hb_retptr( pObj ); +} +/* + * QDir absoluteDir () const + */ +HB_FUNC( QT_QFILEINFO_ABSOLUTEDIR ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDir( hbqt_par_QFileInfo( 1 )->absoluteDir() ), release_QDir ) ); +} + +/* + * QString absoluteFilePath () const + */ +HB_FUNC( QT_QFILEINFO_ABSOLUTEFILEPATH ) +{ + hb_retc( hbqt_par_QFileInfo( 1 )->absoluteFilePath().toAscii().data() ); +} + +/* + * QString absolutePath () const + */ +HB_FUNC( QT_QFILEINFO_ABSOLUTEPATH ) +{ + hb_retc( hbqt_par_QFileInfo( 1 )->absolutePath().toAscii().data() ); +} + +/* + * QString baseName () const + */ +HB_FUNC( QT_QFILEINFO_BASENAME ) +{ + hb_retc( hbqt_par_QFileInfo( 1 )->baseName().toAscii().data() ); +} + +/* + * QString bundleName () const + */ +HB_FUNC( QT_QFILEINFO_BUNDLENAME ) +{ + hb_retc( hbqt_par_QFileInfo( 1 )->bundleName().toAscii().data() ); +} + +/* + * bool caching () const + */ +HB_FUNC( QT_QFILEINFO_CACHING ) +{ + hb_retl( hbqt_par_QFileInfo( 1 )->caching() ); +} + +/* + * QString canonicalFilePath () const + */ +HB_FUNC( QT_QFILEINFO_CANONICALFILEPATH ) +{ + hb_retc( hbqt_par_QFileInfo( 1 )->canonicalFilePath().toAscii().data() ); +} + +/* + * QString canonicalPath () const + */ +HB_FUNC( QT_QFILEINFO_CANONICALPATH ) +{ + hb_retc( hbqt_par_QFileInfo( 1 )->canonicalPath().toAscii().data() ); +} + +/* + * QString completeBaseName () const + */ +HB_FUNC( QT_QFILEINFO_COMPLETEBASENAME ) +{ + hb_retc( hbqt_par_QFileInfo( 1 )->completeBaseName().toAscii().data() ); +} + +/* + * QString completeSuffix () const + */ +HB_FUNC( QT_QFILEINFO_COMPLETESUFFIX ) +{ + hb_retc( hbqt_par_QFileInfo( 1 )->completeSuffix().toAscii().data() ); +} + +/* + * QDateTime created () const + */ +HB_FUNC( QT_QFILEINFO_CREATED ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDateTime( hbqt_par_QFileInfo( 1 )->created() ), release_QDateTime ) ); +} + +/* + * QDir dir () const + */ +HB_FUNC( QT_QFILEINFO_DIR ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDir( hbqt_par_QFileInfo( 1 )->dir() ), release_QDir ) ); +} + +/* + * bool exists () const + */ +HB_FUNC( QT_QFILEINFO_EXISTS ) +{ + hb_retl( hbqt_par_QFileInfo( 1 )->exists() ); +} + +/* + * QString fileName () const + */ +HB_FUNC( QT_QFILEINFO_FILENAME ) +{ + hb_retc( hbqt_par_QFileInfo( 1 )->fileName().toAscii().data() ); +} + +/* + * QString filePath () const + */ +HB_FUNC( QT_QFILEINFO_FILEPATH ) +{ + hb_retc( hbqt_par_QFileInfo( 1 )->filePath().toAscii().data() ); +} + +/* + * QString group () const + */ +HB_FUNC( QT_QFILEINFO_GROUP ) +{ + hb_retc( hbqt_par_QFileInfo( 1 )->group().toAscii().data() ); +} + +/* + * uint groupId () const + */ +HB_FUNC( QT_QFILEINFO_GROUPID ) +{ + hb_retni( hbqt_par_QFileInfo( 1 )->groupId() ); +} + +/* + * bool isAbsolute () const + */ +HB_FUNC( QT_QFILEINFO_ISABSOLUTE ) +{ + hb_retl( hbqt_par_QFileInfo( 1 )->isAbsolute() ); +} + +/* + * bool isBundle () const + */ +HB_FUNC( QT_QFILEINFO_ISBUNDLE ) +{ + hb_retl( hbqt_par_QFileInfo( 1 )->isBundle() ); +} + +/* + * bool isDir () const + */ +HB_FUNC( QT_QFILEINFO_ISDIR ) +{ + hb_retl( hbqt_par_QFileInfo( 1 )->isDir() ); +} + +/* + * bool isExecutable () const + */ +HB_FUNC( QT_QFILEINFO_ISEXECUTABLE ) +{ + hb_retl( hbqt_par_QFileInfo( 1 )->isExecutable() ); +} + +/* + * bool isFile () const + */ +HB_FUNC( QT_QFILEINFO_ISFILE ) +{ + hb_retl( hbqt_par_QFileInfo( 1 )->isFile() ); +} + +/* + * bool isHidden () const + */ +HB_FUNC( QT_QFILEINFO_ISHIDDEN ) +{ + hb_retl( hbqt_par_QFileInfo( 1 )->isHidden() ); +} + +/* + * bool isReadable () const + */ +HB_FUNC( QT_QFILEINFO_ISREADABLE ) +{ + hb_retl( hbqt_par_QFileInfo( 1 )->isReadable() ); +} + +/* + * bool isRelative () const + */ +HB_FUNC( QT_QFILEINFO_ISRELATIVE ) +{ + hb_retl( hbqt_par_QFileInfo( 1 )->isRelative() ); +} + +/* + * bool isRoot () const + */ +HB_FUNC( QT_QFILEINFO_ISROOT ) +{ + hb_retl( hbqt_par_QFileInfo( 1 )->isRoot() ); +} + +/* + * bool isSymLink () const + */ +HB_FUNC( QT_QFILEINFO_ISSYMLINK ) +{ + hb_retl( hbqt_par_QFileInfo( 1 )->isSymLink() ); +} + +/* + * bool isWritable () const + */ +HB_FUNC( QT_QFILEINFO_ISWRITABLE ) +{ + hb_retl( hbqt_par_QFileInfo( 1 )->isWritable() ); +} + +/* + * QDateTime lastModified () const + */ +HB_FUNC( QT_QFILEINFO_LASTMODIFIED ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDateTime( hbqt_par_QFileInfo( 1 )->lastModified() ), release_QDateTime ) ); +} + +/* + * QDateTime lastRead () const + */ +HB_FUNC( QT_QFILEINFO_LASTREAD ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDateTime( hbqt_par_QFileInfo( 1 )->lastRead() ), release_QDateTime ) ); +} + +/* + * bool makeAbsolute () + */ +HB_FUNC( QT_QFILEINFO_MAKEABSOLUTE ) +{ + hb_retl( hbqt_par_QFileInfo( 1 )->makeAbsolute() ); +} + +/* + * QString owner () const + */ +HB_FUNC( QT_QFILEINFO_OWNER ) +{ + hb_retc( hbqt_par_QFileInfo( 1 )->owner().toAscii().data() ); +} + +/* + * uint ownerId () const + */ +HB_FUNC( QT_QFILEINFO_OWNERID ) +{ + hb_retni( hbqt_par_QFileInfo( 1 )->ownerId() ); +} + +/* + * QString path () const + */ +HB_FUNC( QT_QFILEINFO_PATH ) +{ + hb_retc( hbqt_par_QFileInfo( 1 )->path().toAscii().data() ); +} + +/* + * bool permission ( QFile::Permissions permissions ) const + */ +HB_FUNC( QT_QFILEINFO_PERMISSION ) +{ + hb_retl( hbqt_par_QFileInfo( 1 )->permission( ( QFile::Permissions ) hb_parni( 2 ) ) ); +} + +/* + * QFile::Permissions permissions () const + */ +HB_FUNC( QT_QFILEINFO_PERMISSIONS ) +{ + hb_retni( ( QFile::Permissions ) hbqt_par_QFileInfo( 1 )->permissions() ); +} + +/* + * void refresh () + */ +HB_FUNC( QT_QFILEINFO_REFRESH ) +{ + hbqt_par_QFileInfo( 1 )->refresh(); +} + +/* + * void setCaching ( bool enable ) + */ +HB_FUNC( QT_QFILEINFO_SETCACHING ) +{ + hbqt_par_QFileInfo( 1 )->setCaching( hb_parl( 2 ) ); +} + +/* + * void setFile ( const QString & file ) + */ +HB_FUNC( QT_QFILEINFO_SETFILE ) +{ + hbqt_par_QFileInfo( 1 )->setFile( hbqt_par_QString( 2 ) ); +} + +/* + * void setFile ( const QFile & file ) + */ +HB_FUNC( QT_QFILEINFO_SETFILE_1 ) +{ + hbqt_par_QFileInfo( 1 )->setFile( *hbqt_par_QFile( 2 ) ); +} + +/* + * void setFile ( const QDir & dir, const QString & file ) + */ +HB_FUNC( QT_QFILEINFO_SETFILE_2 ) +{ + hbqt_par_QFileInfo( 1 )->setFile( *hbqt_par_QDir( 2 ), hbqt_par_QString( 3 ) ); +} + +/* + * qint64 size () const + */ +HB_FUNC( QT_QFILEINFO_SIZE ) +{ + hb_retnint( hbqt_par_QFileInfo( 1 )->size() ); +} + +/* + * QString suffix () const + */ +HB_FUNC( QT_QFILEINFO_SUFFIX ) +{ + hb_retc( hbqt_par_QFileInfo( 1 )->suffix().toAscii().data() ); +} + +/* + * QString symLinkTarget () const + */ +HB_FUNC( QT_QFILEINFO_SYMLINKTARGET ) +{ + hb_retc( hbqt_par_QFileInfo( 1 )->symLinkTarget().toAscii().data() ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QIODevice.cpp b/harbour/contrib/hbqt/qtcore/QIODevice.cpp new file mode 100644 index 0000000000..a0ced7c684 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QIODevice.cpp @@ -0,0 +1,378 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +/* + * flags OpenMode + * enum OpenModeFlag { NotOpen, ReadOnly, WriteOnly, ReadWrite, ..., Unbuffered } + */ + +#include + +#include + + +/* + * QIODevice () + * QIODevice ( QObject * parent ) + * virtual ~QIODevice () + */ + +QT_G_FUNC( release_QIODevice ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QIODevice" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + const QMetaObject * m = ( ( QObject * ) ph )->metaObject(); + if( ( QString ) m->className() != ( QString ) "QObject" ) + { + delete ( ( QIODevice * ) ph ); + ph = NULL; + } + else + { +#if defined(__debug__) + hb_snprintf( str, sizeof(str), " Object Name Missing: QIODevice" ); OutputDebugString( str ); +#endif + } + } +} + +HB_FUNC( QT_QIODEVICE ) +{ +} +/* + * virtual bool atEnd () const + */ +HB_FUNC( QT_QIODEVICE_ATEND ) +{ + hb_retl( hbqt_par_QIODevice( 1 )->atEnd() ); +} + +/* + * virtual qint64 bytesAvailable () const + */ +HB_FUNC( QT_QIODEVICE_BYTESAVAILABLE ) +{ + hb_retnint( hbqt_par_QIODevice( 1 )->bytesAvailable() ); +} + +/* + * virtual qint64 bytesToWrite () const + */ +HB_FUNC( QT_QIODEVICE_BYTESTOWRITE ) +{ + hb_retnint( hbqt_par_QIODevice( 1 )->bytesToWrite() ); +} + +/* + * virtual bool canReadLine () const + */ +HB_FUNC( QT_QIODEVICE_CANREADLINE ) +{ + hb_retl( hbqt_par_QIODevice( 1 )->canReadLine() ); +} + +/* + * virtual void close () + */ +HB_FUNC( QT_QIODEVICE_CLOSE ) +{ + hbqt_par_QIODevice( 1 )->close(); +} + +/* + * QString errorString () const + */ +HB_FUNC( QT_QIODEVICE_ERRORSTRING ) +{ + hb_retc( hbqt_par_QIODevice( 1 )->errorString().toAscii().data() ); +} + +/* + * bool getChar ( char * c ) + */ +HB_FUNC( QT_QIODEVICE_GETCHAR ) +{ + hb_retl( hbqt_par_QIODevice( 1 )->getChar( ( char * ) hb_parc( 2 ) ) ); +} + +/* + * bool isOpen () const + */ +HB_FUNC( QT_QIODEVICE_ISOPEN ) +{ + hb_retl( hbqt_par_QIODevice( 1 )->isOpen() ); +} + +/* + * bool isReadable () const + */ +HB_FUNC( QT_QIODEVICE_ISREADABLE ) +{ + hb_retl( hbqt_par_QIODevice( 1 )->isReadable() ); +} + +/* + * virtual bool isSequential () const + */ +HB_FUNC( QT_QIODEVICE_ISSEQUENTIAL ) +{ + hb_retl( hbqt_par_QIODevice( 1 )->isSequential() ); +} + +/* + * bool isTextModeEnabled () const + */ +HB_FUNC( QT_QIODEVICE_ISTEXTMODEENABLED ) +{ + hb_retl( hbqt_par_QIODevice( 1 )->isTextModeEnabled() ); +} + +/* + * bool isWritable () const + */ +HB_FUNC( QT_QIODEVICE_ISWRITABLE ) +{ + hb_retl( hbqt_par_QIODevice( 1 )->isWritable() ); +} + +/* + * virtual bool open ( OpenMode mode ) + */ +HB_FUNC( QT_QIODEVICE_OPEN ) +{ + hb_retl( hbqt_par_QIODevice( 1 )->open( ( QIODevice::OpenMode ) hb_parni( 2 ) ) ); +} + +/* + * OpenMode openMode () const + */ +HB_FUNC( QT_QIODEVICE_OPENMODE ) +{ + hb_retni( ( QIODevice::OpenMode ) hbqt_par_QIODevice( 1 )->openMode() ); +} + +/* + * qint64 peek ( char * data, qint64 maxSize ) + */ +HB_FUNC( QT_QIODEVICE_PEEK ) +{ + hb_retnint( hbqt_par_QIODevice( 1 )->peek( ( char * ) hb_parc( 2 ), hb_parnint( 3 ) ) ); +} + +/* + * QByteArray peek ( qint64 maxSize ) + */ +HB_FUNC( QT_QIODEVICE_PEEK_1 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QIODevice( 1 )->peek( hb_parnint( 2 ) ) ), release_QByteArray ) ); +} + +/* + * virtual qint64 pos () const + */ +HB_FUNC( QT_QIODEVICE_POS ) +{ + hb_retnint( hbqt_par_QIODevice( 1 )->pos() ); +} + +/* + * bool putChar ( char c ) + */ +HB_FUNC( QT_QIODEVICE_PUTCHAR ) +{ + hb_retl( hbqt_par_QIODevice( 1 )->putChar( ( char ) hb_parni( 2 ) ) ); +} + +/* + * qint64 read ( char * data, qint64 maxSize ) + */ +HB_FUNC( QT_QIODEVICE_READ ) +{ + hb_retnint( hbqt_par_QIODevice( 1 )->read( ( char * ) hb_parc( 2 ), hb_parnint( 3 ) ) ); +} + +/* + * QByteArray read ( qint64 maxSize ) + */ +HB_FUNC( QT_QIODEVICE_READ_1 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QIODevice( 1 )->read( hb_parnint( 2 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray readAll () + */ +HB_FUNC( QT_QIODEVICE_READALL ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QIODevice( 1 )->readAll() ), release_QByteArray ) ); +} + +/* + * qint64 readLine ( char * data, qint64 maxSize ) + */ +HB_FUNC( QT_QIODEVICE_READLINE ) +{ + hb_retnint( hbqt_par_QIODevice( 1 )->readLine( ( char * ) hb_parc( 2 ), hb_parnint( 3 ) ) ); +} + +/* + * QByteArray readLine ( qint64 maxSize = 0 ) + */ +HB_FUNC( QT_QIODEVICE_READLINE_1 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QIODevice( 1 )->readLine( hb_parnint( 2 ) ) ), release_QByteArray ) ); +} + +/* + * virtual bool reset () + */ +HB_FUNC( QT_QIODEVICE_RESET ) +{ + hb_retl( hbqt_par_QIODevice( 1 )->reset() ); +} + +/* + * virtual bool seek ( qint64 pos ) + */ +HB_FUNC( QT_QIODEVICE_SEEK ) +{ + hb_retl( hbqt_par_QIODevice( 1 )->seek( hb_parnint( 2 ) ) ); +} + +/* + * void setTextModeEnabled ( bool enabled ) + */ +HB_FUNC( QT_QIODEVICE_SETTEXTMODEENABLED ) +{ + hbqt_par_QIODevice( 1 )->setTextModeEnabled( hb_parl( 2 ) ); +} + +/* + * virtual qint64 size () const + */ +HB_FUNC( QT_QIODEVICE_SIZE ) +{ + hb_retnint( hbqt_par_QIODevice( 1 )->size() ); +} + +/* + * void ungetChar ( char c ) + */ +HB_FUNC( QT_QIODEVICE_UNGETCHAR ) +{ + hbqt_par_QIODevice( 1 )->ungetChar( ( char ) hb_parni( 2 ) ); +} + +/* + * virtual bool waitForBytesWritten ( int msecs ) + */ +HB_FUNC( QT_QIODEVICE_WAITFORBYTESWRITTEN ) +{ + hb_retl( hbqt_par_QIODevice( 1 )->waitForBytesWritten( hb_parni( 2 ) ) ); +} + +/* + * virtual bool waitForReadyRead ( int msecs ) + */ +HB_FUNC( QT_QIODEVICE_WAITFORREADYREAD ) +{ + hb_retl( hbqt_par_QIODevice( 1 )->waitForReadyRead( hb_parni( 2 ) ) ); +} + +/* + * qint64 write ( const char * data, qint64 maxSize ) + */ +HB_FUNC( QT_QIODEVICE_WRITE ) +{ + hb_retnint( hbqt_par_QIODevice( 1 )->write( hbqt_par_char( 2 ), hb_parnint( 3 ) ) ); +} + +/* + * qint64 write ( const char * data ) + */ +HB_FUNC( QT_QIODEVICE_WRITE_1 ) +{ + hb_retnint( hbqt_par_QIODevice( 1 )->write( hbqt_par_char( 2 ) ) ); +} + +/* + * qint64 write ( const QByteArray & byteArray ) + */ +HB_FUNC( QT_QIODEVICE_WRITE_2 ) +{ + hb_retnint( hbqt_par_QIODevice( 1 )->write( *hbqt_par_QByteArray( 2 ) ) ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QLatin1Char.cpp b/harbour/contrib/hbqt/qtcore/QLatin1Char.cpp new file mode 100644 index 0000000000..434ba4feae --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QLatin1Char.cpp @@ -0,0 +1,118 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +#include + +#include + + +/* + * QLatin1Char ( char c ) + */ + +QT_G_FUNC( release_QLatin1Char ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QLatin1Char" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QLatin1Char * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QLATIN1CHAR ) +{ + void * pObj = NULL; + + pObj = ( QLatin1Char* ) new QLatin1Char( *hb_parcx( 1 ) ) ; + + hb_retptr( pObj ); +} +/* + * char toLatin1 () const + */ +HB_FUNC( QT_QLATIN1CHAR_TOLATIN1 ) +{ + hb_retni( hbqt_par_QLatin1Char( 1 )->toLatin1() ); +} + +/* + * ushort unicode () const + */ +HB_FUNC( QT_QLATIN1CHAR_UNICODE ) +{ + hb_retni( hbqt_par_QLatin1Char( 1 )->unicode() ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QLatin1String.cpp b/harbour/contrib/hbqt/qtcore/QLatin1String.cpp new file mode 100644 index 0000000000..f0c9431766 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QLatin1String.cpp @@ -0,0 +1,110 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +#include + +#include + + +/* + * QLatin1String ( const char * str ) + */ + +QT_G_FUNC( release_QLatin1String ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QLatin1String" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QLatin1String * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QLATIN1STRING ) +{ + void * pObj = NULL; + + pObj = ( QLatin1String* ) new QLatin1String( hb_parcx( 1 ) ) ; + + hb_retptr( pObj ); +} +/* + * const char * latin1 () const + */ +HB_FUNC( QT_QLATIN1STRING_LATIN1 ) +{ + hb_retc( hbqt_par_QLatin1String( 1 )->latin1() ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QLine.cpp b/harbour/contrib/hbqt/qtcore/QLine.cpp new file mode 100644 index 0000000000..2b2b8cfe21 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QLine.cpp @@ -0,0 +1,259 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +#include + +#include + + +/* + * QLine () + * QLine ( const QPoint & p1, const QPoint & p2 ) + * QLine ( int x1, int y1, int x2, int y2 ) + */ + +QT_G_FUNC( release_QLine ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QLine" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QLine * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QLINE ) +{ + QGC_POINTER * p = ( QGC_POINTER * ) hb_gcAlloc( sizeof( QGC_POINTER ), Q_release ); + void * pObj = NULL; + + if( hb_pcount() == 1 && HB_ISPOINTER( 1 ) ) + { + pObj = ( QLine* ) new QLine( *hbqt_par_QLine( 1 ) ) ; + } + else if( hb_pcount() == 2 && HB_ISPOINTER( 1 ) && HB_ISPOINTER( 2 ) ) + { + pObj = ( QLine* ) new QLine( *hbqt_par_QPoint( 1 ), *hbqt_par_QPoint( 2 ) ) ; + } + else if( hb_pcount() == 4 && HB_ISNUM( 1 ) && HB_ISNUM( 2 ) && HB_ISNUM( 3 ) && HB_ISNUM( 4 ) ) + { + pObj = ( QLine* ) new QLine( hb_parni( 1 ), hb_parni( 2 ), hb_parni( 3 ), hb_parni( 4 ) ) ; + } + else + { + pObj = ( QLine* ) new QLine() ; + } + + p->ph = pObj; + p->func = release_QLine; + + hb_retptrGC( p ); +} +/* + * QPoint p1 () const + */ +HB_FUNC( QT_QLINE_P1 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QPoint( hbqt_par_QLine( 1 )->p1() ), release_QPoint ) ); +} + +/* + * QPoint p2 () const + */ +HB_FUNC( QT_QLINE_P2 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QPoint( hbqt_par_QLine( 1 )->p2() ), release_QPoint ) ); +} + +/* + * int x1 () const + */ +HB_FUNC( QT_QLINE_X1 ) +{ + hb_retni( hbqt_par_QLine( 1 )->x1() ); +} + +/* + * int x2 () const + */ +HB_FUNC( QT_QLINE_X2 ) +{ + hb_retni( hbqt_par_QLine( 1 )->x2() ); +} + +/* + * int y1 () const + */ +HB_FUNC( QT_QLINE_Y1 ) +{ + hb_retni( hbqt_par_QLine( 1 )->y1() ); +} + +/* + * int y2 () const + */ +HB_FUNC( QT_QLINE_Y2 ) +{ + hb_retni( hbqt_par_QLine( 1 )->y2() ); +} + +/* + * int dx () const + */ +HB_FUNC( QT_QLINE_DX ) +{ + hb_retni( hbqt_par_QLine( 1 )->dx() ); +} + +/* + * int dy () const + */ +HB_FUNC( QT_QLINE_DY ) +{ + hb_retni( hbqt_par_QLine( 1 )->dy() ); +} + +/* + * bool isNull () const + */ +HB_FUNC( QT_QLINE_ISNULL ) +{ + hb_retl( hbqt_par_QLine( 1 )->isNull() ); +} + +/* + * void setP1 ( const QPoint & p1 ) + */ +HB_FUNC( QT_QLINE_SETP1 ) +{ + hbqt_par_QLine( 1 )->setP1( *hbqt_par_QPoint( 2 ) ); +} + +/* + * void setP2 ( const QPoint & p2 ) + */ +HB_FUNC( QT_QLINE_SETP2 ) +{ + hbqt_par_QLine( 1 )->setP2( *hbqt_par_QPoint( 2 ) ); +} + +/* + * void setLine ( int x1, int y1, int x2, int y2 ) + */ +HB_FUNC( QT_QLINE_SETLINE ) +{ + hbqt_par_QLine( 1 )->setLine( hb_parni( 2 ), hb_parni( 3 ), hb_parni( 4 ), hb_parni( 5 ) ); +} + +/* + * void setPoints ( const QPoint & p1, const QPoint & p2 ) + */ +HB_FUNC( QT_QLINE_SETPOINTS ) +{ + hbqt_par_QLine( 1 )->setPoints( *hbqt_par_QPoint( 2 ), *hbqt_par_QPoint( 3 ) ); +} + +/* + * void translate ( const QPoint & offset ) + */ +HB_FUNC( QT_QLINE_TRANSLATE ) +{ + hbqt_par_QLine( 1 )->translate( *hbqt_par_QPoint( 2 ) ); +} + +/* + * void translate ( int dx, int dy ) + */ +HB_FUNC( QT_QLINE_TRANSLATE_1 ) +{ + hbqt_par_QLine( 1 )->translate( hb_parni( 2 ), hb_parni( 3 ) ); +} + +/* + * QLine translated ( const QPoint & offset ) const + */ +HB_FUNC( QT_QLINE_TRANSLATED ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QLine( hbqt_par_QLine( 1 )->translated( *hbqt_par_QPoint( 2 ) ) ), release_QLine ) ); +} + +/* + * QLine translated ( int dx, int dy ) const + */ +HB_FUNC( QT_QLINE_TRANSLATED_1 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QLine( hbqt_par_QLine( 1 )->translated( hb_parni( 2 ), hb_parni( 3 ) ) ), release_QLine ) ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QLineF.cpp b/harbour/contrib/hbqt/qtcore/QLineF.cpp new file mode 100644 index 0000000000..b202ac410c --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QLineF.cpp @@ -0,0 +1,328 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +/* + * enum IntersectType { NoIntersection, UnboundedIntersection, BoundedIntersection } + */ + +#include + +#include + + +/* QLineF () + * QLineF ( const QPointF & p1, const QPointF & p2 ) + * QLineF ( qreal x1, qreal y1, qreal x2, qreal y2 ) + * QLineF ( const QLine & line ) + */ + +QT_G_FUNC( release_QLineF ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QLineF" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QLineF * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QLINEF ) +{ + QGC_POINTER * p = ( QGC_POINTER * ) hb_gcAlloc( sizeof( QGC_POINTER ), Q_release ); + void * pObj = NULL; + + pObj = new QLineF() ; + + p->ph = pObj; + p->func = release_QLineF; + + hb_retptrGC( p ); +} +/* + * QPointF p1 () const + */ +HB_FUNC( QT_QLINEF_P1 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QPointF( hbqt_par_QLineF( 1 )->p1() ), release_QPointF ) ); +} + +/* + * QPointF p2 () const + */ +HB_FUNC( QT_QLINEF_P2 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QPointF( hbqt_par_QLineF( 1 )->p2() ), release_QPointF ) ); +} + +/* + * qreal x1 () const + */ +HB_FUNC( QT_QLINEF_X1 ) +{ + hb_retnd( hbqt_par_QLineF( 1 )->x1() ); +} + +/* + * qreal x2 () const + */ +HB_FUNC( QT_QLINEF_X2 ) +{ + hb_retnd( hbqt_par_QLineF( 1 )->x2() ); +} + +/* + * qreal y1 () const + */ +HB_FUNC( QT_QLINEF_Y1 ) +{ + hb_retnd( hbqt_par_QLineF( 1 )->y1() ); +} + +/* + * qreal y2 () const + */ +HB_FUNC( QT_QLINEF_Y2 ) +{ + hb_retnd( hbqt_par_QLineF( 1 )->y2() ); +} + +/* + * qreal angle () const + */ +HB_FUNC( QT_QLINEF_ANGLE ) +{ + hb_retnd( hbqt_par_QLineF( 1 )->angle() ); +} + +/* + * qreal angleTo ( const QLineF & line ) const + */ +HB_FUNC( QT_QLINEF_ANGLETO ) +{ + hb_retnd( hbqt_par_QLineF( 1 )->angleTo( *hbqt_par_QLineF( 2 ) ) ); +} + +/* + * qreal dx () const + */ +HB_FUNC( QT_QLINEF_DX ) +{ + hb_retnd( hbqt_par_QLineF( 1 )->dx() ); +} + +/* + * qreal dy () const + */ +HB_FUNC( QT_QLINEF_DY ) +{ + hb_retnd( hbqt_par_QLineF( 1 )->dy() ); +} + +/* + * IntersectType intersect ( const QLineF & line, QPointF * intersectionPoint ) const + */ +HB_FUNC( QT_QLINEF_INTERSECT ) +{ + hb_retni( ( QLineF::IntersectType ) hbqt_par_QLineF( 1 )->intersect( *hbqt_par_QLineF( 2 ), hbqt_par_QPointF( 3 ) ) ); +} + +/* + * bool isNull () const + */ +HB_FUNC( QT_QLINEF_ISNULL ) +{ + hb_retl( hbqt_par_QLineF( 1 )->isNull() ); +} + +/* + * qreal length () const + */ +HB_FUNC( QT_QLINEF_LENGTH ) +{ + hb_retnd( hbqt_par_QLineF( 1 )->length() ); +} + +/* + * QLineF normalVector () const + */ +HB_FUNC( QT_QLINEF_NORMALVECTOR ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QLineF( hbqt_par_QLineF( 1 )->normalVector() ), release_QLineF ) ); +} + +/* + * QPointF pointAt ( qreal t ) const + */ +HB_FUNC( QT_QLINEF_POINTAT ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QPointF( hbqt_par_QLineF( 1 )->pointAt( hb_parnd( 2 ) ) ), release_QPointF ) ); +} + +/* + * void setP1 ( const QPointF & p1 ) + */ +HB_FUNC( QT_QLINEF_SETP1 ) +{ + hbqt_par_QLineF( 1 )->setP1( *hbqt_par_QPointF( 2 ) ); +} + +/* + * void setP2 ( const QPointF & p2 ) + */ +HB_FUNC( QT_QLINEF_SETP2 ) +{ + hbqt_par_QLineF( 1 )->setP2( *hbqt_par_QPointF( 2 ) ); +} + +/* + * void setAngle ( qreal angle ) + */ +HB_FUNC( QT_QLINEF_SETANGLE ) +{ + hbqt_par_QLineF( 1 )->setAngle( hb_parnd( 2 ) ); +} + +/* + * void setLength ( qreal length ) + */ +HB_FUNC( QT_QLINEF_SETLENGTH ) +{ + hbqt_par_QLineF( 1 )->setLength( hb_parnd( 2 ) ); +} + +/* + * void setLine ( qreal x1, qreal y1, qreal x2, qreal y2 ) + */ +HB_FUNC( QT_QLINEF_SETLINE ) +{ + hbqt_par_QLineF( 1 )->setLine( hb_parnd( 2 ), hb_parnd( 3 ), hb_parnd( 4 ), hb_parnd( 5 ) ); +} + +/* + * void setPoints ( const QPointF & p1, const QPointF & p2 ) + */ +HB_FUNC( QT_QLINEF_SETPOINTS ) +{ + hbqt_par_QLineF( 1 )->setPoints( *hbqt_par_QPointF( 2 ), *hbqt_par_QPointF( 3 ) ); +} + +/* + * QLine toLine () const + */ +HB_FUNC( QT_QLINEF_TOLINE ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QLine( hbqt_par_QLineF( 1 )->toLine() ), release_QLine ) ); +} + +/* + * void translate ( const QPointF & offset ) + */ +HB_FUNC( QT_QLINEF_TRANSLATE ) +{ + hbqt_par_QLineF( 1 )->translate( *hbqt_par_QPointF( 2 ) ); +} + +/* + * void translate ( qreal dx, qreal dy ) + */ +HB_FUNC( QT_QLINEF_TRANSLATE_1 ) +{ + hbqt_par_QLineF( 1 )->translate( hb_parnd( 2 ), hb_parnd( 3 ) ); +} + +/* + * QLineF translated ( const QPointF & offset ) const + */ +HB_FUNC( QT_QLINEF_TRANSLATED ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QLineF( hbqt_par_QLineF( 1 )->translated( *hbqt_par_QPointF( 2 ) ) ), release_QLineF ) ); +} + +/* + * QLineF translated ( qreal dx, qreal dy ) const + */ +HB_FUNC( QT_QLINEF_TRANSLATED_1 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QLineF( hbqt_par_QLineF( 1 )->translated( hb_parnd( 2 ), hb_parnd( 3 ) ) ), release_QLineF ) ); +} + +/* + * QLineF unitVector () const + */ +HB_FUNC( QT_QLINEF_UNITVECTOR ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QLineF( hbqt_par_QLineF( 1 )->unitVector() ), release_QLineF ) ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QList.cpp b/harbour/contrib/hbqt/qtcore/QList.cpp new file mode 100644 index 0000000000..16ac32c7df --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QList.cpp @@ -0,0 +1,451 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +/* + * Constructed[ 40/55 [ 72.73% ] ] + * + * *** Unconvered Prototypes *** + * ----------------------------- + * + * void append ( const QList & value ) + * iterator begin () + * iterator erase ( iterator pos ) + * iterator erase ( iterator begin, iterator end ) + * iterator insert ( iterator before, const T & value ) + * QList mid ( int pos, int length = -1 ) const + * QSet toSet () const + * std::list toStdList () const + * QVector toVector () const + * + * *** Commented out protos which construct fine but do not compile *** + * + * //const_iterator begin () const + * //const_iterator constBegin () const + * //const_iterator constEnd () const + * //bool contains ( const T & value ) const + * //iterator end () + * //const_iterator end () const + */ + +#include + +#include + + +/* + * QList () + * QList ( const QList & other ) + * ~QList () + */ + +QT_G_FUNC( release_QList ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QList" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QList< void * > * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QLIST ) +{ + void * pObj = NULL; + + QList* list = NULL; + pObj = ( QList* ) list ; + + hb_retptr( pObj ); +} +/* + * void append ( const T & value ) + */ +HB_FUNC( QT_QLIST_APPEND ) +{ + hbqt_par_QList( 1 )->append( hb_param( 2, HB_IT_ANY ) ); +} + +/* + * const T & at ( int i ) const + */ +HB_FUNC( QT_QLIST_AT ) +{ + hb_retptr( hbqt_par_QList( 1 )->at( hb_parni( 2 ) ) ); +} + +/* + * T & back () + */ +HB_FUNC( QT_QLIST_BACK ) +{ + hb_retptr( hbqt_par_QList( 1 )->back() ); +} + +/* + * const T & back () const + */ +HB_FUNC( QT_QLIST_BACK_1 ) +{ + hb_retptr( hbqt_par_QList( 1 )->back() ); +} + +/* + * void clear () + */ +HB_FUNC( QT_QLIST_CLEAR ) +{ + hbqt_par_QList( 1 )->clear(); +} + +/* + * int count ( const T & value ) const + */ +HB_FUNC( QT_QLIST_COUNT ) +{ + hb_retni( hbqt_par_QList( 1 )->count( hb_param( 2, HB_IT_ANY ) ) ); +} + +/* + * int count () const + */ +HB_FUNC( QT_QLIST_COUNT_1 ) +{ + hb_retni( hbqt_par_QList( 1 )->count() ); +} + +/* + * bool empty () const + */ +HB_FUNC( QT_QLIST_EMPTY ) +{ + hb_retl( hbqt_par_QList( 1 )->empty() ); +} + +/* + * bool endsWith ( const T & value ) const + */ +HB_FUNC( QT_QLIST_ENDSWITH ) +{ + hb_retl( hbqt_par_QList( 1 )->endsWith( hb_param( 2, HB_IT_ANY ) ) ); +} + +/* + * T & first () + */ +HB_FUNC( QT_QLIST_FIRST ) +{ + hb_retptr( hbqt_par_QList( 1 )->first() ); +} + +/* + * const T & first () const + */ +HB_FUNC( QT_QLIST_FIRST_1 ) +{ + hb_retptr( hbqt_par_QList( 1 )->first() ); +} + +/* + * T & front () + */ +HB_FUNC( QT_QLIST_FRONT ) +{ + hb_retptr( hbqt_par_QList( 1 )->front() ); +} + +/* + * const T & front () const + */ +HB_FUNC( QT_QLIST_FRONT_1 ) +{ + hb_retptr( hbqt_par_QList( 1 )->front() ); +} + +/* + * int indexOf ( const T & value, int from = 0 ) const + */ +HB_FUNC( QT_QLIST_INDEXOF ) +{ + hb_retni( hbqt_par_QList( 1 )->indexOf( hb_param( 2, HB_IT_ANY ), hb_parni( 3 ) ) ); +} + +/* + * void insert ( int i, const T & value ) + */ +HB_FUNC( QT_QLIST_INSERT ) +{ + hbqt_par_QList( 1 )->insert( hb_parni( 2 ), hb_param( 3, HB_IT_ANY ) ); +} + +/* + * bool isEmpty () const + */ +HB_FUNC( QT_QLIST_ISEMPTY ) +{ + hb_retl( hbqt_par_QList( 1 )->isEmpty() ); +} + +/* + * T & last () + */ +HB_FUNC( QT_QLIST_LAST ) +{ + hb_retptr( hbqt_par_QList( 1 )->last() ); +} + +/* + * const T & last () const + */ +HB_FUNC( QT_QLIST_LAST_1 ) +{ + hb_retptr( hbqt_par_QList( 1 )->last() ); +} + +/* + * int lastIndexOf ( const T & value, int from = -1 ) const + */ +HB_FUNC( QT_QLIST_LASTINDEXOF ) +{ + hb_retni( hbqt_par_QList( 1 )->lastIndexOf( hb_param( 2, HB_IT_ANY ), ( HB_ISNUM( 3 ) ? hb_parni( 3 ) : -1 ) ) ); +} + +/* + * int length () const + */ +HB_FUNC( QT_QLIST_LENGTH ) +{ + hb_retni( hbqt_par_QList( 1 )->length() ); +} + +/* + * void move ( int from, int to ) + */ +HB_FUNC( QT_QLIST_MOVE ) +{ + hbqt_par_QList( 1 )->move( hb_parni( 2 ), hb_parni( 3 ) ); +} + +/* + * void pop_back () + */ +HB_FUNC( QT_QLIST_POP_BACK ) +{ + hbqt_par_QList( 1 )->pop_back(); +} + +/* + * void pop_front () + */ +HB_FUNC( QT_QLIST_POP_FRONT ) +{ + hbqt_par_QList( 1 )->pop_front(); +} + +/* + * void prepend ( const T & value ) + */ +HB_FUNC( QT_QLIST_PREPEND ) +{ + hbqt_par_QList( 1 )->prepend( hb_param( 2, HB_IT_ANY ) ); +} + +/* + * void push_back ( const T & value ) + */ +HB_FUNC( QT_QLIST_PUSH_BACK ) +{ + hbqt_par_QList( 1 )->push_back( hb_param( 2, HB_IT_ANY ) ); +} + +/* + * void push_front ( const T & value ) + */ +HB_FUNC( QT_QLIST_PUSH_FRONT ) +{ + hbqt_par_QList( 1 )->push_front( hb_param( 2, HB_IT_ANY ) ); +} + +/* + * int removeAll ( const T & value ) + */ +HB_FUNC( QT_QLIST_REMOVEALL ) +{ + hb_retni( hbqt_par_QList( 1 )->removeAll( hb_param( 2, HB_IT_ANY ) ) ); +} + +/* + * void removeAt ( int i ) + */ +HB_FUNC( QT_QLIST_REMOVEAT ) +{ + hbqt_par_QList( 1 )->removeAt( hb_parni( 2 ) ); +} + +/* + * void removeFirst () + */ +HB_FUNC( QT_QLIST_REMOVEFIRST ) +{ + hbqt_par_QList( 1 )->removeFirst(); +} + +/* + * void removeLast () + */ +HB_FUNC( QT_QLIST_REMOVELAST ) +{ + hbqt_par_QList( 1 )->removeLast(); +} + +/* + * bool removeOne ( const T & value ) + */ +HB_FUNC( QT_QLIST_REMOVEONE ) +{ + hb_retl( hbqt_par_QList( 1 )->removeOne( hb_param( 2, HB_IT_ANY ) ) ); +} + +/* + * void replace ( int i, const T & value ) + */ +HB_FUNC( QT_QLIST_REPLACE ) +{ + hbqt_par_QList( 1 )->replace( hb_parni( 2 ), hb_param( 3, HB_IT_ANY ) ); +} + +/* + * int size () const + */ +HB_FUNC( QT_QLIST_SIZE ) +{ + hb_retni( hbqt_par_QList( 1 )->size() ); +} + +/* + * bool startsWith ( const T & value ) const + */ +HB_FUNC( QT_QLIST_STARTSWITH ) +{ + hb_retl( hbqt_par_QList( 1 )->startsWith( hb_param( 2, HB_IT_ANY ) ) ); +} + +/* + * void swap ( int i, int j ) + */ +HB_FUNC( QT_QLIST_SWAP ) +{ + hbqt_par_QList( 1 )->swap( hb_parni( 2 ), hb_parni( 3 ) ); +} + +/* + * T takeAt ( int i ) + */ +HB_FUNC( QT_QLIST_TAKEAT ) +{ + hb_retptr( hbqt_par_QList( 1 )->takeAt( hb_parni( 2 ) ) ); +} + +/* + * T takeFirst () + */ +HB_FUNC( QT_QLIST_TAKEFIRST ) +{ + hb_retptr( hbqt_par_QList( 1 )->takeFirst() ); +} + +/* + * T takeLast () + */ +HB_FUNC( QT_QLIST_TAKELAST ) +{ + hb_retptr( hbqt_par_QList( 1 )->takeLast() ); +} + +/* + * T value ( int i ) const + */ +HB_FUNC( QT_QLIST_VALUE ) +{ + hb_retptr( hbqt_par_QList( 1 )->value( hb_parni( 2 ) ) ); +} + +/* + * T value ( int i, const T & defaultValue ) const + */ +HB_FUNC( QT_QLIST_VALUE_1 ) +{ + hb_retptr( hbqt_par_QList( 1 )->value( hb_parni( 2 ), hb_param( 3, HB_IT_ANY ) ) ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QLocale.cpp b/harbour/contrib/hbqt/qtcore/QLocale.cpp new file mode 100644 index 0000000000..81a3136e15 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QLocale.cpp @@ -0,0 +1,552 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +/* + * enum Country { AnyCountry, Afghanistan, Albania, Algeria, ..., Zimbabwe } + * enum FormatType { LongFormat, ShortFormat, NarrowFormat } + * enum Language { C, Abkhazian, Afan, Afar, ..., Chewa } + * enum MeasurementSystem { MetricSystem, ImperialSystem } + * enum NumberOption { OmitGroupSeparator, RejectGroupSeparator } + * flags NumberOptions + */ + +/* + * Constructed[ 48/56 [ 85.71% ] ] + * + * *** Unconvered Prototypes *** + * ----------------------------- + * + * QList countriesForLanguage ( Language language ) + * + * *** Commented out protos which construct fine but do not compile *** + * + * // QChar decimalPoint () const + * // QChar exponential () const + * // QChar groupSeparator () const + * // QChar negativeSign () const + * // QChar percent () const + * // QChar positiveSign () const + * // QChar zeroDigit () const + */ + +#include + +#include +#include + +/* QLocale () + * QLocale ( const QString & name ) + * QLocale ( Language language, Country country = AnyCountry ) + * QLocale ( const QLocale & other ) + */ + +QT_G_FUNC( release_QLocale ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QLocale" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QLocale * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QLOCALE ) +{ + QGC_POINTER * p = ( QGC_POINTER * ) hb_gcAlloc( sizeof( QGC_POINTER ), Q_release ); + void * pObj = NULL; + + pObj = new QLocale() ; + + p->ph = pObj; + p->func = release_QLocale; + + hb_retptrGC( p ); +} +/* + * QString amText () const + */ +HB_FUNC( QT_QLOCALE_AMTEXT ) +{ + hb_retc( hbqt_par_QLocale( 1 )->amText().toAscii().data() ); +} + +/* + * Country country () const + */ +HB_FUNC( QT_QLOCALE_COUNTRY ) +{ + hb_retni( ( QLocale::Country ) hbqt_par_QLocale( 1 )->country() ); +} + +/* + * QString dateFormat ( FormatType format = LongFormat ) const + */ +HB_FUNC( QT_QLOCALE_DATEFORMAT ) +{ + hb_retc( hbqt_par_QLocale( 1 )->dateFormat( ( HB_ISNUM( 2 ) ? ( QLocale::FormatType ) hb_parni( 2 ) : ( QLocale::FormatType ) QLocale::LongFormat ) ).toAscii().data() ); +} + +/* + * QString dateTimeFormat ( FormatType format = LongFormat ) const + */ +HB_FUNC( QT_QLOCALE_DATETIMEFORMAT ) +{ + hb_retc( hbqt_par_QLocale( 1 )->dateTimeFormat( ( HB_ISNUM( 2 ) ? ( QLocale::FormatType ) hb_parni( 2 ) : ( QLocale::FormatType ) QLocale::LongFormat ) ).toAscii().data() ); +} + +/* + * QString dayName ( int day, FormatType type = LongFormat ) const + */ +HB_FUNC( QT_QLOCALE_DAYNAME ) +{ + hb_retc( hbqt_par_QLocale( 1 )->dayName( hb_parni( 2 ), ( HB_ISNUM( 3 ) ? ( QLocale::FormatType ) hb_parni( 3 ) : ( QLocale::FormatType ) QLocale::LongFormat ) ).toAscii().data() ); +} + +/* + * Language language () const + */ +HB_FUNC( QT_QLOCALE_LANGUAGE ) +{ + hb_retni( ( QLocale::Language ) hbqt_par_QLocale( 1 )->language() ); +} + +/* + * MeasurementSystem measurementSystem () const + */ +HB_FUNC( QT_QLOCALE_MEASUREMENTSYSTEM ) +{ + hb_retni( ( QLocale::MeasurementSystem ) hbqt_par_QLocale( 1 )->measurementSystem() ); +} + +/* + * QString monthName ( int month, FormatType type = LongFormat ) const + */ +HB_FUNC( QT_QLOCALE_MONTHNAME ) +{ + hb_retc( hbqt_par_QLocale( 1 )->monthName( hb_parni( 2 ), ( HB_ISNUM( 3 ) ? ( QLocale::FormatType ) hb_parni( 3 ) : ( QLocale::FormatType ) QLocale::LongFormat ) ).toAscii().data() ); +} + +/* + * QString name () const + */ +HB_FUNC( QT_QLOCALE_NAME ) +{ + hb_retc( hbqt_par_QLocale( 1 )->name().toAscii().data() ); +} + +/* + * NumberOptions numberOptions () const + */ +HB_FUNC( QT_QLOCALE_NUMBEROPTIONS ) +{ + hb_retni( ( QLocale::NumberOptions ) hbqt_par_QLocale( 1 )->numberOptions() ); +} + +/* + * QString pmText () const + */ +HB_FUNC( QT_QLOCALE_PMTEXT ) +{ + hb_retc( hbqt_par_QLocale( 1 )->pmText().toAscii().data() ); +} + +/* + * void setNumberOptions ( NumberOptions options ) + */ +HB_FUNC( QT_QLOCALE_SETNUMBEROPTIONS ) +{ + hbqt_par_QLocale( 1 )->setNumberOptions( ( QLocale::NumberOptions ) hb_parni( 2 ) ); +} + +/* + * QString standaloneDayName ( int day, FormatType type = LongFormat ) const + */ +HB_FUNC( QT_QLOCALE_STANDALONEDAYNAME ) +{ + hb_retc( hbqt_par_QLocale( 1 )->standaloneDayName( hb_parni( 2 ), ( HB_ISNUM( 3 ) ? ( QLocale::FormatType ) hb_parni( 3 ) : ( QLocale::FormatType ) QLocale::LongFormat ) ).toAscii().data() ); +} + +/* + * QString standaloneMonthName ( int month, FormatType type = LongFormat ) const + */ +HB_FUNC( QT_QLOCALE_STANDALONEMONTHNAME ) +{ + hb_retc( hbqt_par_QLocale( 1 )->standaloneMonthName( hb_parni( 2 ), ( HB_ISNUM( 3 ) ? ( QLocale::FormatType ) hb_parni( 3 ) : ( QLocale::FormatType ) QLocale::LongFormat ) ).toAscii().data() ); +} + +/* + * QString timeFormat ( FormatType format = LongFormat ) const + */ +HB_FUNC( QT_QLOCALE_TIMEFORMAT ) +{ + hb_retc( hbqt_par_QLocale( 1 )->timeFormat( ( HB_ISNUM( 2 ) ? ( QLocale::FormatType ) hb_parni( 2 ) : ( QLocale::FormatType ) QLocale::LongFormat ) ).toAscii().data() ); +} + +/* + * QDate toDate ( const QString & string, FormatType format = LongFormat ) const + */ +HB_FUNC( QT_QLOCALE_TODATE ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDate( hbqt_par_QLocale( 1 )->toDate( hbqt_par_QString( 2 ), ( HB_ISNUM( 3 ) ? ( QLocale::FormatType ) hb_parni( 3 ) : ( QLocale::FormatType ) QLocale::LongFormat ) ) ), release_QDate ) ); +} + +/* + * QDate toDate ( const QString & string, const QString & format ) const + */ +HB_FUNC( QT_QLOCALE_TODATE_1 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDate( hbqt_par_QLocale( 1 )->toDate( hbqt_par_QString( 2 ), hbqt_par_QString( 3 ) ) ), release_QDate ) ); +} + +/* + * QDateTime toDateTime ( const QString & string, FormatType format = LongFormat ) const + */ +HB_FUNC( QT_QLOCALE_TODATETIME ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDateTime( hbqt_par_QLocale( 1 )->toDateTime( hbqt_par_QString( 2 ), ( HB_ISNUM( 3 ) ? ( QLocale::FormatType ) hb_parni( 3 ) : ( QLocale::FormatType ) QLocale::LongFormat ) ) ), release_QDateTime ) ); +} + +/* + * QDateTime toDateTime ( const QString & string, const QString & format ) const + */ +HB_FUNC( QT_QLOCALE_TODATETIME_1 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDateTime( hbqt_par_QLocale( 1 )->toDateTime( hbqt_par_QString( 2 ), hbqt_par_QString( 3 ) ) ), release_QDateTime ) ); +} + +/* + * double toDouble ( const QString & s, bool * ok = 0 ) const + */ +HB_FUNC( QT_QLOCALE_TODOUBLE ) +{ + bool iOk = 0; + + hb_retnd( hbqt_par_QLocale( 1 )->toDouble( hbqt_par_QString( 2 ), &iOk ) ); + + hb_stornl( iOk, 3 ); +} + +/* + * float toFloat ( const QString & s, bool * ok = 0 ) const + */ +HB_FUNC( QT_QLOCALE_TOFLOAT ) +{ + bool iOk = 0; + + hb_retnd( hbqt_par_QLocale( 1 )->toFloat( hbqt_par_QString( 2 ), &iOk ) ); + + hb_stornl( iOk, 3 ); +} + +/* + * int toInt ( const QString & s, bool * ok = 0, int base = 0 ) const + */ +HB_FUNC( QT_QLOCALE_TOINT ) +{ + bool iOk = 0; + + hb_retni( hbqt_par_QLocale( 1 )->toInt( hbqt_par_QString( 2 ), &iOk, hb_parni( 4 ) ) ); + + hb_stornl( iOk, 3 ); +} + +/* + * qlonglong toLongLong ( const QString & s, bool * ok = 0, int base = 0 ) const + */ +HB_FUNC( QT_QLOCALE_TOLONGLONG ) +{ + bool iOk = 0; + + hb_retnint( hbqt_par_QLocale( 1 )->toLongLong( hbqt_par_QString( 2 ), &iOk, hb_parni( 4 ) ) ); + + hb_stornl( iOk, 3 ); +} + +/* + * short toShort ( const QString & s, bool * ok = 0, int base = 0 ) const + */ +HB_FUNC( QT_QLOCALE_TOSHORT ) +{ + bool iOk = 0; + + hb_retni( hbqt_par_QLocale( 1 )->toShort( hbqt_par_QString( 2 ), &iOk, hb_parni( 4 ) ) ); + + hb_stornl( iOk, 3 ); +} + +/* + * QString toString ( qlonglong i ) const + */ +HB_FUNC( QT_QLOCALE_TOSTRING ) +{ + hb_retc( hbqt_par_QLocale( 1 )->toString( hb_parnint( 2 ) ).toAscii().data() ); +} + +/* + * QString toString ( const QDate & date, const QString & format ) const + */ +HB_FUNC( QT_QLOCALE_TOSTRING_1 ) +{ + hb_retc( hbqt_par_QLocale( 1 )->toString( *hbqt_par_QDate( 2 ), hbqt_par_QString( 3 ) ).toAscii().data() ); +} + +/* + * QString toString ( const QDate & date, FormatType format = LongFormat ) const + */ +HB_FUNC( QT_QLOCALE_TOSTRING_2 ) +{ + hb_retc( hbqt_par_QLocale( 1 )->toString( *hbqt_par_QDate( 2 ), ( HB_ISNUM( 3 ) ? ( QLocale::FormatType ) hb_parni( 3 ) : ( QLocale::FormatType ) QLocale::LongFormat ) ).toAscii().data() ); +} + +/* + * QString toString ( const QTime & time, const QString & format ) const + */ +HB_FUNC( QT_QLOCALE_TOSTRING_3 ) +{ + hb_retc( hbqt_par_QLocale( 1 )->toString( *hbqt_par_QTime( 2 ), hbqt_par_QString( 3 ) ).toAscii().data() ); +} + +/* + * QString toString ( const QTime & time, FormatType format = LongFormat ) const + */ +HB_FUNC( QT_QLOCALE_TOSTRING_4 ) +{ + hb_retc( hbqt_par_QLocale( 1 )->toString( *hbqt_par_QTime( 2 ), ( HB_ISNUM( 3 ) ? ( QLocale::FormatType ) hb_parni( 3 ) : ( QLocale::FormatType ) QLocale::LongFormat ) ).toAscii().data() ); +} + +/* + * QString toString ( const QDateTime & dateTime, FormatType format = LongFormat ) const + */ +HB_FUNC( QT_QLOCALE_TOSTRING_5 ) +{ + hb_retc( hbqt_par_QLocale( 1 )->toString( *hbqt_par_QDateTime( 2 ), ( HB_ISNUM( 3 ) ? ( QLocale::FormatType ) hb_parni( 3 ) : ( QLocale::FormatType ) QLocale::LongFormat ) ).toAscii().data() ); +} + +/* + * QString toString ( const QDateTime & dateTime, const QString & format ) const + */ +HB_FUNC( QT_QLOCALE_TOSTRING_6 ) +{ + hb_retc( hbqt_par_QLocale( 1 )->toString( *hbqt_par_QDateTime( 2 ), hbqt_par_QString( 3 ) ).toAscii().data() ); +} + +/* + * QString toString ( qulonglong i ) const + */ +HB_FUNC( QT_QLOCALE_TOSTRING_7 ) +{ + hb_retc( hbqt_par_QLocale( 1 )->toString( hb_parnint( 2 ) ).toAscii().data() ); +} + +/* + * QString toString ( double i, char f = 'g', int prec = 6 ) const + */ +HB_FUNC( QT_QLOCALE_TOSTRING_8 ) +{ + hb_retc( hbqt_par_QLocale( 1 )->toString( hb_parnd( 2 ), ( char ) hb_parni( 3 ), ( HB_ISNUM( 4 ) ? hb_parni( 4 ) : 6 ) ).toAscii().data() ); +} + +/* + * QString toString ( short i ) const + */ +HB_FUNC( QT_QLOCALE_TOSTRING_9 ) +{ + hb_retc( hbqt_par_QLocale( 1 )->toString( hb_parni( 2 ) ).toAscii().data() ); +} + +/* + * QString toString ( ushort i ) const + */ +HB_FUNC( QT_QLOCALE_TOSTRING_10 ) +{ + hb_retc( hbqt_par_QLocale( 1 )->toString( hb_parni( 2 ) ).toAscii().data() ); +} + +/* + * QString toString ( int i ) const + */ +HB_FUNC( QT_QLOCALE_TOSTRING_11 ) +{ + hb_retc( hbqt_par_QLocale( 1 )->toString( hb_parni( 2 ) ).toAscii().data() ); +} + +/* + * QString toString ( uint i ) const + */ +HB_FUNC( QT_QLOCALE_TOSTRING_12 ) +{ + hb_retc( hbqt_par_QLocale( 1 )->toString( hb_parni( 2 ) ).toAscii().data() ); +} + +/* + * QString toString ( float i, char f = 'g', int prec = 6 ) const + */ +HB_FUNC( QT_QLOCALE_TOSTRING_13 ) +{ + hb_retc( hbqt_par_QLocale( 1 )->toString( hb_parnd( 2 ), ( char ) hb_parni( 3 ), ( HB_ISNUM( 4 ) ? hb_parni( 4 ) : 6 ) ).toAscii().data() ); +} + +/* + * QTime toTime ( const QString & string, FormatType format = LongFormat ) const + */ +HB_FUNC( QT_QLOCALE_TOTIME ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QTime( hbqt_par_QLocale( 1 )->toTime( hbqt_par_QString( 2 ), ( HB_ISNUM( 3 ) ? ( QLocale::FormatType ) hb_parni( 3 ) : ( QLocale::FormatType ) QLocale::LongFormat ) ) ), release_QTime ) ); +} + +/* + * QTime toTime ( const QString & string, const QString & format ) const + */ +HB_FUNC( QT_QLOCALE_TOTIME_1 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QTime( hbqt_par_QLocale( 1 )->toTime( hbqt_par_QString( 2 ), hbqt_par_QString( 3 ) ) ), release_QTime ) ); +} + +/* + * uint toUInt ( const QString & s, bool * ok = 0, int base = 0 ) const + */ +HB_FUNC( QT_QLOCALE_TOUINT ) +{ + bool iOk = 0; + + hb_retni( hbqt_par_QLocale( 1 )->toUInt( hbqt_par_QString( 2 ), &iOk, hb_parni( 4 ) ) ); + + hb_stornl( iOk, 3 ); +} + +/* + * qlonglong toULongLong ( const QString & s, bool * ok = 0, int base = 0 ) const + */ +HB_FUNC( QT_QLOCALE_TOULONGLONG ) +{ + bool iOk = 0; + + hb_retnint( hbqt_par_QLocale( 1 )->toULongLong( hbqt_par_QString( 2 ), &iOk, hb_parni( 4 ) ) ); + + hb_stornl( iOk, 3 ); +} + +/* + * ushort toUShort ( const QString & s, bool * ok = 0, int base = 0 ) const + */ +HB_FUNC( QT_QLOCALE_TOUSHORT ) +{ + bool iOk = 0; + + hb_retni( hbqt_par_QLocale( 1 )->toUShort( hbqt_par_QString( 2 ), &iOk, hb_parni( 4 ) ) ); + + hb_stornl( iOk, 3 ); +} + +/* + * QLocale c () + */ +HB_FUNC( QT_QLOCALE_C ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QLocale( hbqt_par_QLocale( 1 )->c() ), release_QLocale ) ); +} + +/* + * QString countryToString ( Country country ) + */ +HB_FUNC( QT_QLOCALE_COUNTRYTOSTRING ) +{ + hb_retc( hbqt_par_QLocale( 1 )->countryToString( ( QLocale::Country ) hb_parni( 2 ) ).toAscii().data() ); +} + +/* + * QString languageToString ( Language language ) + */ +HB_FUNC( QT_QLOCALE_LANGUAGETOSTRING ) +{ + hb_retc( hbqt_par_QLocale( 1 )->languageToString( ( QLocale::Language ) hb_parni( 2 ) ).toAscii().data() ); +} + +/* + * void setDefault ( const QLocale & locale ) + */ +HB_FUNC( QT_QLOCALE_SETDEFAULT ) +{ + hbqt_par_QLocale( 1 )->setDefault( *hbqt_par_QLocale( 2 ) ); +} + +/* + * QLocale system () + */ +HB_FUNC( QT_QLOCALE_SYSTEM ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QLocale( hbqt_par_QLocale( 1 )->system() ), release_QLocale ) ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QMimeData.cpp b/harbour/contrib/hbqt/qtcore/QMimeData.cpp new file mode 100644 index 0000000000..01e037cb1f --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QMimeData.cpp @@ -0,0 +1,279 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +/* + * Constructed[ 19/21 [ 90.48% ] ] + * + * *** Unconvered Prototypes *** + * ----------------------------- + * + * void setUrls ( const QList & urls ) + * QList urls () const + */ + +#include + +#include +#include + + +/* QMimeData () + * ~QMimeData () + */ + +QT_G_FUNC( release_QMimeData ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QMimeData" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + const QMetaObject * m = ( ( QObject * ) ph )->metaObject(); + if( ( QString ) m->className() != ( QString ) "QObject" ) + { + delete ( ( QMimeData * ) ph ); + ph = NULL; + } + else + { +#if defined(__debug__) + hb_snprintf( str, sizeof(str), " Object Name Missing: QMimeData" ); OutputDebugString( str ); +#endif + } + } +} + +HB_FUNC( QT_QMIMEDATA ) +{ + QGC_POINTER * p = ( QGC_POINTER * ) hb_gcAlloc( sizeof( QGC_POINTER ), Q_release ); + QPointer< QMimeData > pObj = NULL; + + pObj = new QMimeData() ; + + p->ph = pObj; + p->func = release_QMimeData; + + hb_retptrGC( p ); +} +/* + * void clear () + */ +HB_FUNC( QT_QMIMEDATA_CLEAR ) +{ + hbqt_par_QMimeData( 1 )->clear(); +} + +/* + * QVariant colorData () const + */ +HB_FUNC( QT_QMIMEDATA_COLORDATA ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QVariant( hbqt_par_QMimeData( 1 )->colorData() ), release_QVariant ) ); +} + +/* + * QByteArray data ( const QString & mimeType ) const + */ +HB_FUNC( QT_QMIMEDATA_DATA ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QMimeData( 1 )->data( hbqt_par_QString( 2 ) ) ), release_QByteArray ) ); +} + +/* + * virtual QStringList formats () const + */ +HB_FUNC( QT_QMIMEDATA_FORMATS ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QStringList( hbqt_par_QMimeData( 1 )->formats() ), release_QStringList ) ); +} + +/* + * bool hasColor () const + */ +HB_FUNC( QT_QMIMEDATA_HASCOLOR ) +{ + hb_retl( hbqt_par_QMimeData( 1 )->hasColor() ); +} + +/* + * virtual bool hasFormat ( const QString & mimeType ) const + */ +HB_FUNC( QT_QMIMEDATA_HASFORMAT ) +{ + hb_retl( hbqt_par_QMimeData( 1 )->hasFormat( hbqt_par_QString( 2 ) ) ); +} + +/* + * bool hasHtml () const + */ +HB_FUNC( QT_QMIMEDATA_HASHTML ) +{ + hb_retl( hbqt_par_QMimeData( 1 )->hasHtml() ); +} + +/* + * bool hasImage () const + */ +HB_FUNC( QT_QMIMEDATA_HASIMAGE ) +{ + hb_retl( hbqt_par_QMimeData( 1 )->hasImage() ); +} + +/* + * bool hasText () const + */ +HB_FUNC( QT_QMIMEDATA_HASTEXT ) +{ + hb_retl( hbqt_par_QMimeData( 1 )->hasText() ); +} + +/* + * bool hasUrls () const + */ +HB_FUNC( QT_QMIMEDATA_HASURLS ) +{ + hb_retl( hbqt_par_QMimeData( 1 )->hasUrls() ); +} + +/* + * QString html () const + */ +HB_FUNC( QT_QMIMEDATA_HTML ) +{ + hb_retc( hbqt_par_QMimeData( 1 )->html().toAscii().data() ); +} + +/* + * QVariant imageData () const + */ +HB_FUNC( QT_QMIMEDATA_IMAGEDATA ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QVariant( hbqt_par_QMimeData( 1 )->imageData() ), release_QVariant ) ); +} + +/* + * void removeFormat ( const QString & mimeType ) + */ +HB_FUNC( QT_QMIMEDATA_REMOVEFORMAT ) +{ + hbqt_par_QMimeData( 1 )->removeFormat( hbqt_par_QString( 2 ) ); +} + +/* + * void setColorData ( const QVariant & color ) + */ +HB_FUNC( QT_QMIMEDATA_SETCOLORDATA ) +{ + hbqt_par_QMimeData( 1 )->setColorData( *hbqt_par_QVariant( 2 ) ); +} + +/* + * void setData ( const QString & mimeType, const QByteArray & data ) + */ +HB_FUNC( QT_QMIMEDATA_SETDATA ) +{ + hbqt_par_QMimeData( 1 )->setData( hbqt_par_QString( 2 ), *hbqt_par_QByteArray( 3 ) ); +} + +/* + * void setHtml ( const QString & html ) + */ +HB_FUNC( QT_QMIMEDATA_SETHTML ) +{ + hbqt_par_QMimeData( 1 )->setHtml( hbqt_par_QString( 2 ) ); +} + +/* + * void setImageData ( const QVariant & image ) + */ +HB_FUNC( QT_QMIMEDATA_SETIMAGEDATA ) +{ + hbqt_par_QMimeData( 1 )->setImageData( *hbqt_par_QVariant( 2 ) ); +} + +/* + * void setText ( const QString & text ) + */ +HB_FUNC( QT_QMIMEDATA_SETTEXT ) +{ + hbqt_par_QMimeData( 1 )->setText( hbqt_par_QString( 2 ) ); +} + +/* + * QString text () const + */ +HB_FUNC( QT_QMIMEDATA_TEXT ) +{ + hb_retc( hbqt_par_QMimeData( 1 )->text().toAscii().data() ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QModelIndex.cpp b/harbour/contrib/hbqt/qtcore/QModelIndex.cpp new file mode 100644 index 0000000000..518d4759ec --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QModelIndex.cpp @@ -0,0 +1,196 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +#include + +#include + + +/* + * QModelIndex () + * QModelIndex ( const QModelIndex & other ) + * ~QModelIndex () + */ + +QT_G_FUNC( release_QModelIndex ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QModelIndex" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QModelIndex * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QMODELINDEX ) +{ + QGC_POINTER * p = ( QGC_POINTER * ) hb_gcAlloc( sizeof( QGC_POINTER ), Q_release ); + void * pObj = NULL; + + pObj = new QModelIndex() ; + + p->ph = pObj; + p->func = release_QModelIndex; + + hb_retptrGC( p ); +} +/* + * QModelIndex child ( int row, int column ) const + */ +HB_FUNC( QT_QMODELINDEX_CHILD ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QModelIndex( hbqt_par_QModelIndex( 1 )->child( hb_parni( 2 ), hb_parni( 3 ) ) ), release_QModelIndex ) ); +} + +/* + * int column () const + */ +HB_FUNC( QT_QMODELINDEX_COLUMN ) +{ + hb_retni( hbqt_par_QModelIndex( 1 )->column() ); +} + +/* + * QVariant data ( int role = Qt::DisplayRole ) const + */ +HB_FUNC( QT_QMODELINDEX_DATA ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QVariant( hbqt_par_QModelIndex( 1 )->data( ( HB_ISNUM( 2 ) ? hb_parni( 2 ) : Qt::DisplayRole ) ) ), release_QVariant ) ); +} + +/* + * Qt::ItemFlags flags () const + */ +HB_FUNC( QT_QMODELINDEX_FLAGS ) +{ + hb_retni( ( Qt::ItemFlags ) hbqt_par_QModelIndex( 1 )->flags() ); +} + +/* + * qint64 internalId () const + */ +HB_FUNC( QT_QMODELINDEX_INTERNALID ) +{ + hb_retnint( hbqt_par_QModelIndex( 1 )->internalId() ); +} + +/* + * void * internalPointer () const + */ +HB_FUNC( QT_QMODELINDEX_INTERNALPOINTER ) +{ + hbqt_par_QModelIndex( 1 )->internalPointer(); +} + +/* + * bool isValid () const + */ +HB_FUNC( QT_QMODELINDEX_ISVALID ) +{ + hb_retl( hbqt_par_QModelIndex( 1 )->isValid() ); +} + +/* + * const QAbstractItemModel * model () const + */ +HB_FUNC( QT_QMODELINDEX_MODEL ) +{ + hb_retptr( ( QAbstractItemModel* ) hbqt_par_QModelIndex( 1 )->model() ); +} + +/* + * QModelIndex parent () const + */ +HB_FUNC( QT_QMODELINDEX_PARENT ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QModelIndex( hbqt_par_QModelIndex( 1 )->parent() ), release_QModelIndex ) ); +} + +/* + * int row () const + */ +HB_FUNC( QT_QMODELINDEX_ROW ) +{ + hb_retni( hbqt_par_QModelIndex( 1 )->row() ); +} + +/* + * QModelIndex sibling ( int row, int column ) const + */ +HB_FUNC( QT_QMODELINDEX_SIBLING ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QModelIndex( hbqt_par_QModelIndex( 1 )->sibling( hb_parni( 2 ), hb_parni( 3 ) ) ), release_QModelIndex ) ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QObject.cpp b/harbour/contrib/hbqt/qtcore/QObject.cpp new file mode 100644 index 0000000000..ee9149ac1d --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QObject.cpp @@ -0,0 +1,367 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +/* + * Constructed[ 29/35 [ 82.86% ] ] + * + * *** Unconvered Prototypes *** + * ----------------------------- + * + * QList dynamicPropertyNames () const + * QList findChildren ( const QString & name = QString() ) const + * QList findChildren ( const QRegExp & regExp ) const + * const QMetaObject staticMetaObject + * + * *** Commented out protos which construct fine but do not compile *** + * + * // const QObjectList & children () const + * //T findChild ( const QString & name = QString() ) const + */ + +#include + +#include +#include +#include + +/* + * Q_INVOKABLE QObject ( QObject * parent = 0 ) + * virtual ~QObject () + */ + +QT_G_FUNC( release_QObject ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QObject" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + const QMetaObject * m = ( ( QObject * ) ph )->metaObject(); + if( ( QString ) m->className() != ( QString ) "QObject" ) + { + delete ( ( QObject * ) ph ); + ph = NULL; + } + else + { +#if defined(__debug__) + hb_snprintf( str, sizeof(str), " Object Name Missing: QObject" ); OutputDebugString( str ); +#endif + } + } +} + +HB_FUNC( QT_QOBJECT ) +{ + QGC_POINTER * p = ( QGC_POINTER * ) hb_gcAlloc( sizeof( QGC_POINTER ), Q_release ); + QPointer< QObject > pObj = NULL; + + pObj = ( QObject* ) new QObject( hbqt_par_QWidget( 1 ) ) ; + + p->ph = pObj; + p->func = release_QObject; + + hb_retptrGC( p ); +} +/* + * bool blockSignals ( bool block ) + */ +HB_FUNC( QT_QOBJECT_BLOCKSIGNALS ) +{ + hb_retl( hbqt_par_QObject( 1 )->blockSignals( hb_parl( 2 ) ) ); +} + +/* + * bool connect ( const QObject * sender, const char * signal, const char * method, Qt::ConnectionType type = Qt::AutoConnection ) const + */ +HB_FUNC( QT_QOBJECT_CONNECT ) +{ + hb_retl( hbqt_par_QObject( 1 )->connect( hbqt_par_QObject( 2 ), hbqt_par_char( 3 ), hbqt_par_char( 4 ), ( HB_ISNUM( 5 ) ? ( Qt::ConnectionType ) hb_parni( 5 ) : ( Qt::ConnectionType ) Qt::AutoConnection ) ) ); +} + +/* + * bool disconnect ( const char * signal = 0, const QObject * receiver = 0, const char * method = 0 ) + */ +HB_FUNC( QT_QOBJECT_DISCONNECT ) +{ + hb_retl( hbqt_par_QObject( 1 )->disconnect( hbqt_par_char( 2 ), hbqt_par_QObject( 3 ), hbqt_par_char( 4 ) ) ); +} + +/* + * bool disconnect ( const QObject * receiver, const char * method = 0 ) + */ +HB_FUNC( QT_QOBJECT_DISCONNECT_1 ) +{ + hb_retl( hbqt_par_QObject( 1 )->disconnect( hbqt_par_QObject( 2 ), hbqt_par_char( 3 ) ) ); +} + +/* + * void dumpObjectInfo () + */ +HB_FUNC( QT_QOBJECT_DUMPOBJECTINFO ) +{ + hbqt_par_QObject( 1 )->dumpObjectInfo(); +} + +/* + * void dumpObjectTree () + */ +HB_FUNC( QT_QOBJECT_DUMPOBJECTTREE ) +{ + hbqt_par_QObject( 1 )->dumpObjectTree(); +} + +/* + * virtual bool event ( QEvent * e ) + */ +HB_FUNC( QT_QOBJECT_EVENT ) +{ + hb_retl( hbqt_par_QObject( 1 )->event( hbqt_par_QEvent( 2 ) ) ); +} + +/* + * virtual bool eventFilter ( QObject * watched, QEvent * event ) + */ +HB_FUNC( QT_QOBJECT_EVENTFILTER ) +{ + hb_retl( hbqt_par_QObject( 1 )->eventFilter( hbqt_par_QObject( 2 ), hbqt_par_QEvent( 3 ) ) ); +} + +/* + * bool inherits ( const char * className ) const + */ +HB_FUNC( QT_QOBJECT_INHERITS ) +{ + hb_retl( hbqt_par_QObject( 1 )->inherits( hbqt_par_char( 2 ) ) ); +} + +/* + * void installEventFilter ( QObject * filterObj ) + */ +HB_FUNC( QT_QOBJECT_INSTALLEVENTFILTER ) +{ + hbqt_par_QObject( 1 )->installEventFilter( hbqt_par_QObject( 2 ) ); +} + +/* + * bool isWidgetType () const + */ +HB_FUNC( QT_QOBJECT_ISWIDGETTYPE ) +{ + hb_retl( hbqt_par_QObject( 1 )->isWidgetType() ); +} + +/* + * void killTimer ( int id ) + */ +HB_FUNC( QT_QOBJECT_KILLTIMER ) +{ + hbqt_par_QObject( 1 )->killTimer( hb_parni( 2 ) ); +} + +/* + * virtual const QMetaObject * metaObject () const + */ +HB_FUNC( QT_QOBJECT_METAOBJECT ) +{ + hb_retptr( ( QMetaObject* ) hbqt_par_QObject( 1 )->metaObject() ); +} + +/* + * void moveToThread ( QThread * targetThread ) + */ +HB_FUNC( QT_QOBJECT_MOVETOTHREAD ) +{ + hbqt_par_QObject( 1 )->moveToThread( hbqt_par_QThread( 2 ) ); +} + +/* + * QString objectName () const + */ +HB_FUNC( QT_QOBJECT_OBJECTNAME ) +{ + hb_retc( hbqt_par_QObject( 1 )->objectName().toAscii().data() ); +} + +/* + * QObject * parent () const + */ +HB_FUNC( QT_QOBJECT_PARENT ) +{ + hb_retptr( ( QObject* ) hbqt_par_QObject( 1 )->parent() ); +} + +/* + * QVariant property ( const char * name ) const + */ +HB_FUNC( QT_QOBJECT_PROPERTY ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QVariant( hbqt_par_QObject( 1 )->property( hbqt_par_char( 2 ) ) ), release_QVariant ) ); +} + +/* + * void removeEventFilter ( QObject * obj ) + */ +HB_FUNC( QT_QOBJECT_REMOVEEVENTFILTER ) +{ + hbqt_par_QObject( 1 )->removeEventFilter( hbqt_par_QObject( 2 ) ); +} + +/* + * void setObjectName ( const QString & name ) + */ +HB_FUNC( QT_QOBJECT_SETOBJECTNAME ) +{ + hbqt_par_QObject( 1 )->setObjectName( hbqt_par_QString( 2 ) ); +} + +/* + * void setParent ( QObject * parent ) + */ +HB_FUNC( QT_QOBJECT_SETPARENT ) +{ + hbqt_par_QObject( 1 )->setParent( hbqt_par_QObject( 2 ) ); +} + +/* + * bool setProperty ( const char * name, const QVariant & value ) + */ +HB_FUNC( QT_QOBJECT_SETPROPERTY ) +{ + hb_retl( hbqt_par_QObject( 1 )->setProperty( hbqt_par_char( 2 ), *hbqt_par_QVariant( 3 ) ) ); +} + +/* + * bool signalsBlocked () const + */ +HB_FUNC( QT_QOBJECT_SIGNALSBLOCKED ) +{ + hb_retl( hbqt_par_QObject( 1 )->signalsBlocked() ); +} + +/* + * int startTimer ( int interval ) + */ +HB_FUNC( QT_QOBJECT_STARTTIMER ) +{ + hb_retni( hbqt_par_QObject( 1 )->startTimer( hb_parni( 2 ) ) ); +} + +/* + * QThread * thread () const + */ +HB_FUNC( QT_QOBJECT_THREAD ) +{ + hb_retptr( ( QThread* ) hbqt_par_QObject( 1 )->thread() ); +} + +/* + * bool connect ( const QObject * sender, const char * signal, const QObject * receiver, const char * method, Qt::ConnectionType type = Qt::AutoConnection ) + */ +HB_FUNC( QT_QOBJECT_CONNECT_1 ) +{ + hb_retl( hbqt_par_QObject( 1 )->connect( hbqt_par_QObject( 2 ), hbqt_par_char( 3 ), hbqt_par_QObject( 4 ), hbqt_par_char( 5 ), ( HB_ISNUM( 6 ) ? ( Qt::ConnectionType ) hb_parni( 6 ) : ( Qt::ConnectionType ) Qt::AutoConnection ) ) ); +} + +/* + * bool disconnect ( const QObject * sender, const char * signal, const QObject * receiver, const char * method ) + */ +HB_FUNC( QT_QOBJECT_DISCONNECT_2 ) +{ + hb_retl( hbqt_par_QObject( 1 )->disconnect( hbqt_par_QObject( 2 ), hbqt_par_char( 3 ), hbqt_par_QObject( 4 ), hbqt_par_char( 5 ) ) ); +} + +/* + * QString tr ( const char * sourceText, const char * disambiguation = 0, int n = -1 ) + */ +HB_FUNC( QT_QOBJECT_TR ) +{ + hb_retc( hbqt_par_QObject( 1 )->tr( hbqt_par_char( 2 ), hbqt_par_char( 3 ), ( HB_ISNUM( 4 ) ? hb_parni( 4 ) : -1 ) ).toAscii().data() ); +} + +/* + * QString trUtf8 ( const char * sourceText, const char * disambiguation = 0, int n = -1 ) + */ +HB_FUNC( QT_QOBJECT_TRUTF8 ) +{ + hb_retc( hbqt_par_QObject( 1 )->trUtf8( hbqt_par_char( 2 ), hbqt_par_char( 3 ), ( HB_ISNUM( 4 ) ? hb_parni( 4 ) : -1 ) ).toAscii().data() ); +} + +/* + * void deleteLater () + */ +HB_FUNC( QT_QOBJECT_DELETELATER ) +{ + hbqt_par_QObject( 1 )->deleteLater(); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QPoint.cpp b/harbour/contrib/hbqt/qtcore/QPoint.cpp new file mode 100644 index 0000000000..6e507c9f39 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QPoint.cpp @@ -0,0 +1,179 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +#include + +#include + + +/* + * QPoint () + * QPoint ( int x, int y ) + * ~QPoint () + */ + +QT_G_FUNC( release_QPoint ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QPoint" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QPoint * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QPOINT ) +{ + void * pObj = NULL; + + if( hb_pcount() == 2 && HB_ISNUM( 1 ) && HB_ISNUM( 2 ) ) + { + pObj = ( QPoint* ) new QPoint( hb_parni( 1 ), hb_parni( 2 ) ) ; + } + else if( hb_pcount() == 1 && HB_ISPOINTER( 1 ) ) + { + pObj = ( QPoint* ) new QPoint( *hbqt_par_QPoint( 1 ) ) ; + } + else + { + pObj = ( QPoint* ) new QPoint() ; + } + + hb_retptr( pObj ); +} +/* + * bool isNull () const + */ +HB_FUNC( QT_QPOINT_ISNULL ) +{ + hb_retl( hbqt_par_QPoint( 1 )->isNull() ); +} + +/* + * int manhattanLength () const + */ +HB_FUNC( QT_QPOINT_MANHATTANLENGTH ) +{ + hb_retni( hbqt_par_QPoint( 1 )->manhattanLength() ); +} + +/* + * int & rx () + */ +HB_FUNC( QT_QPOINT_RX ) +{ + hb_retni( hbqt_par_QPoint( 1 )->rx() ); +} + +/* + * int & ry () + */ +HB_FUNC( QT_QPOINT_RY ) +{ + hb_retni( hbqt_par_QPoint( 1 )->ry() ); +} + +/* + * void setX ( int x ) + */ +HB_FUNC( QT_QPOINT_SETX ) +{ + hbqt_par_QPoint( 1 )->setX( hb_parni( 2 ) ); +} + +/* + * void setY ( int y ) + */ +HB_FUNC( QT_QPOINT_SETY ) +{ + hbqt_par_QPoint( 1 )->setY( hb_parni( 2 ) ); +} + +/* + * int x () const + */ +HB_FUNC( QT_QPOINT_X ) +{ + hb_retni( hbqt_par_QPoint( 1 )->x() ); +} + +/* + * int y () const + */ +HB_FUNC( QT_QPOINT_Y ) +{ + hb_retni( hbqt_par_QPoint( 1 )->y() ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QPointF.cpp b/harbour/contrib/hbqt/qtcore/QPointF.cpp new file mode 100644 index 0000000000..21f5b58d58 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QPointF.cpp @@ -0,0 +1,183 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +#include + +#include + + +/* + * QPointF () + * QPointF ( const QPoint & point ) + * QPointF ( qreal x, qreal y ) + */ + +QT_G_FUNC( release_QPointF ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QPointF" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QPointF * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QPOINTF ) +{ + QGC_POINTER * p = ( QGC_POINTER * ) hb_gcAlloc( sizeof( QGC_POINTER ), Q_release ); + void * pObj = NULL; + + if( hb_pcount() == 2 && HB_ISNUM( 1 ) && HB_ISNUM( 2 ) ) + { + pObj = ( QPointF* ) new QPointF( ( qreal ) hb_parnd( 1 ), ( qreal ) hb_parnd( 2 ) ) ; + } + else if( hb_pcount() == 1 && HB_ISPOINTER( 1 ) ) + { + pObj = ( QPointF* ) new QPointF( *hbqt_par_QPoint( 1 ) ) ; + } + else + { + pObj = ( QPointF* ) new QPointF() ; + } + + p->ph = pObj; + p->func = release_QPointF; + + hb_retptrGC( p ); +} +/* + * bool isNull () const + */ +HB_FUNC( QT_QPOINTF_ISNULL ) +{ + hb_retl( hbqt_par_QPointF( 1 )->isNull() ); +} + +/* + * qreal & rx () + */ +HB_FUNC( QT_QPOINTF_RX ) +{ + hb_retnd( hbqt_par_QPointF( 1 )->rx() ); +} + +/* + * qreal & ry () + */ +HB_FUNC( QT_QPOINTF_RY ) +{ + hb_retnd( hbqt_par_QPointF( 1 )->ry() ); +} + +/* + * void setX ( qreal x ) + */ +HB_FUNC( QT_QPOINTF_SETX ) +{ + hbqt_par_QPointF( 1 )->setX( hb_parnd( 2 ) ); +} + +/* + * void setY ( qreal y ) + */ +HB_FUNC( QT_QPOINTF_SETY ) +{ + hbqt_par_QPointF( 1 )->setY( hb_parnd( 2 ) ); +} + +/* + * QPoint toPoint () const + */ +HB_FUNC( QT_QPOINTF_TOPOINT ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QPoint( hbqt_par_QPointF( 1 )->toPoint() ), release_QPoint ) ); +} + +/* + * qreal x () const + */ +HB_FUNC( QT_QPOINTF_X ) +{ + hb_retnd( hbqt_par_QPointF( 1 )->x() ); +} + +/* + * qreal y () const + */ +HB_FUNC( QT_QPOINTF_Y ) +{ + hb_retnd( hbqt_par_QPointF( 1 )->y() ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QProcess.cpp b/harbour/contrib/hbqt/qtcore/QProcess.cpp new file mode 100644 index 0000000000..ea95d0e510 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QProcess.cpp @@ -0,0 +1,403 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +/* + * # FROM QIODevice + * flags OpenMode + * enum OpenModeFlag { NotOpen, ReadOnly, WriteOnly, ReadWrite, ..., Unbuffered } + * enum ExitStatus { NormalExit, CrashExit } + * enum ProcessChannel { StandardOutput, StandardError } + * enum ProcessChannelMode { SeparateChannels, MergedChannels, ForwardedChannels } + * enum ProcessError { FailedToStart, Crashed, Timedout, WriteError, ReadError, UnknownError } + * enum ProcessState { NotRunning, Starting, Running } + */ + +#include + +#include + + +/* + * QProcess ( QObject * parent = 0 ) + * virtual ~QProcess () + */ + +QT_G_FUNC( release_QProcess ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QProcess" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + const QMetaObject * m = ( ( QObject * ) ph )->metaObject(); + if( ( QString ) m->className() != ( QString ) "QObject" ) + { + delete ( ( QProcess * ) ph ); + ph = NULL; + } + else + { +#if defined(__debug__) + hb_snprintf( str, sizeof(str), " Object Name Missing: QProcess" ); OutputDebugString( str ); +#endif + } + } +} + +HB_FUNC( QT_QPROCESS ) +{ + QGC_POINTER * p = ( QGC_POINTER * ) hb_gcAlloc( sizeof( QGC_POINTER ), Q_release ); + QPointer< QProcess > pObj = NULL; + + if( hb_pcount() == 1 && HB_ISPOINTER( 1 ) ) + { + pObj = ( QProcess* ) new QProcess( hbqt_par_QObject( 1 ) ) ; + } + else + { + pObj = ( QProcess* ) new QProcess() ; + } + + p->ph = pObj; + p->func = release_QProcess; + + hb_retptrGC( p ); +} +/* + * virtual void close () + */ +HB_FUNC( QT_QPROCESS_CLOSE ) +{ + hbqt_par_QProcess( 1 )->close(); +} + +/* + * void closeReadChannel ( ProcessChannel channel ) + */ +HB_FUNC( QT_QPROCESS_CLOSEREADCHANNEL ) +{ + hbqt_par_QProcess( 1 )->closeReadChannel( ( QProcess::ProcessChannel ) hb_parni( 2 ) ); +} + +/* + * void closeWriteChannel () + */ +HB_FUNC( QT_QPROCESS_CLOSEWRITECHANNEL ) +{ + hbqt_par_QProcess( 1 )->closeWriteChannel(); +} + +/* + * QStringList environment () const + */ +HB_FUNC( QT_QPROCESS_ENVIRONMENT ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QStringList( hbqt_par_QProcess( 1 )->environment() ), release_QStringList ) ); +} + +/* + * QProcess::ProcessError error () const + */ +HB_FUNC( QT_QPROCESS_ERROR ) +{ + hb_retni( ( QProcess::ProcessError ) hbqt_par_QProcess( 1 )->error() ); +} + +/* + * int exitCode () const + */ +HB_FUNC( QT_QPROCESS_EXITCODE ) +{ + hb_retni( hbqt_par_QProcess( 1 )->exitCode() ); +} + +/* + * QProcess::ExitStatus exitStatus () const + */ +HB_FUNC( QT_QPROCESS_EXITSTATUS ) +{ + hb_retni( ( QProcess::ExitStatus ) hbqt_par_QProcess( 1 )->exitStatus() ); +} + +/* + * ProcessChannelMode processChannelMode () const + */ +HB_FUNC( QT_QPROCESS_PROCESSCHANNELMODE ) +{ + hb_retni( ( QProcess::ProcessChannelMode ) hbqt_par_QProcess( 1 )->processChannelMode() ); +} + +/* + * QByteArray readAllStandardError () + */ +HB_FUNC( QT_QPROCESS_READALLSTANDARDERROR ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QProcess( 1 )->readAllStandardError() ), release_QByteArray ) ); +} + +/* + * QByteArray readAllStandardOutput () + */ +HB_FUNC( QT_QPROCESS_READALLSTANDARDOUTPUT ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QProcess( 1 )->readAllStandardOutput() ), release_QByteArray ) ); +} + +/* + * ProcessChannel readChannel () const + */ +HB_FUNC( QT_QPROCESS_READCHANNEL ) +{ + hb_retni( ( QProcess::ProcessChannel ) hbqt_par_QProcess( 1 )->readChannel() ); +} + +/* + * void setEnvironment ( const QStringList & environment ) + */ +HB_FUNC( QT_QPROCESS_SETENVIRONMENT ) +{ + hbqt_par_QProcess( 1 )->setEnvironment( *hbqt_par_QStringList( 2 ) ); +} + +/* + * void setProcessChannelMode ( ProcessChannelMode mode ) + */ +HB_FUNC( QT_QPROCESS_SETPROCESSCHANNELMODE ) +{ + hbqt_par_QProcess( 1 )->setProcessChannelMode( ( QProcess::ProcessChannelMode ) hb_parni( 2 ) ); +} + +/* + * void setReadChannel ( ProcessChannel channel ) + */ +HB_FUNC( QT_QPROCESS_SETREADCHANNEL ) +{ + hbqt_par_QProcess( 1 )->setReadChannel( ( QProcess::ProcessChannel ) hb_parni( 2 ) ); +} + +/* + * void setStandardErrorFile ( const QString & fileName, OpenMode mode = Truncate ) + */ +HB_FUNC( QT_QPROCESS_SETSTANDARDERRORFILE ) +{ + hbqt_par_QProcess( 1 )->setStandardErrorFile( hbqt_par_QString( 2 ), ( HB_ISNUM( 3 ) ? ( QProcess::OpenMode ) hb_parni( 3 ) : ( QProcess::OpenMode ) QProcess::Truncate ) ); +} + +/* + * void setStandardInputFile ( const QString & fileName ) + */ +HB_FUNC( QT_QPROCESS_SETSTANDARDINPUTFILE ) +{ + hbqt_par_QProcess( 1 )->setStandardInputFile( hbqt_par_QString( 2 ) ); +} + +/* + * void setStandardOutputFile ( const QString & fileName, OpenMode mode = Truncate ) + */ +HB_FUNC( QT_QPROCESS_SETSTANDARDOUTPUTFILE ) +{ + hbqt_par_QProcess( 1 )->setStandardOutputFile( hbqt_par_QString( 2 ), ( HB_ISNUM( 3 ) ? ( QProcess::OpenMode ) hb_parni( 3 ) : ( QProcess::OpenMode ) QProcess::Truncate ) ); +} + +/* + * void setStandardOutputProcess ( QProcess * destination ) + */ +HB_FUNC( QT_QPROCESS_SETSTANDARDOUTPUTPROCESS ) +{ + hbqt_par_QProcess( 1 )->setStandardOutputProcess( hbqt_par_QProcess( 2 ) ); +} + +/* + * void setWorkingDirectory ( const QString & dir ) + */ +HB_FUNC( QT_QPROCESS_SETWORKINGDIRECTORY ) +{ + hbqt_par_QProcess( 1 )->setWorkingDirectory( hbqt_par_QString( 2 ) ); +} + +/* + * void start ( const QString & program, const QStringList & arguments, OpenMode mode = ReadWrite ) + */ +HB_FUNC( QT_QPROCESS_START ) +{ + hbqt_par_QProcess( 1 )->start( hbqt_par_QString( 2 ), *hbqt_par_QStringList( 3 ), ( HB_ISNUM( 4 ) ? ( QProcess::OpenMode ) hb_parni( 4 ) : ( QProcess::OpenMode ) QProcess::ReadWrite ) ); +} + +/* + * void start ( const QString & program, OpenMode mode = ReadWrite ) + */ +HB_FUNC( QT_QPROCESS_START_1 ) +{ + hbqt_par_QProcess( 1 )->start( hbqt_par_QString( 2 ), ( HB_ISNUM( 3 ) ? ( QProcess::OpenMode ) hb_parni( 3 ) : ( QProcess::OpenMode ) QProcess::ReadWrite ) ); +} + +/* + * QProcess::ProcessState state () const + */ +HB_FUNC( QT_QPROCESS_STATE ) +{ + hb_retni( ( QProcess::ProcessState ) hbqt_par_QProcess( 1 )->state() ); +} + +/* + * bool waitForFinished ( int msecs = 30000 ) + */ +HB_FUNC( QT_QPROCESS_WAITFORFINISHED ) +{ + hb_retl( hbqt_par_QProcess( 1 )->waitForFinished( ( HB_ISNUM( 2 ) ? hb_parni( 2 ) : 30000 ) ) ); +} + +/* + * bool waitForStarted ( int msecs = 30000 ) + */ +HB_FUNC( QT_QPROCESS_WAITFORSTARTED ) +{ + hb_retl( hbqt_par_QProcess( 1 )->waitForStarted( ( HB_ISNUM( 2 ) ? hb_parni( 2 ) : 30000 ) ) ); +} + +/* + * QString workingDirectory () const + */ +HB_FUNC( QT_QPROCESS_WORKINGDIRECTORY ) +{ + hb_retc( hbqt_par_QProcess( 1 )->workingDirectory().toAscii().data() ); +} + +/* + * int execute ( const QString & program, const QStringList & arguments ) + */ +HB_FUNC( QT_QPROCESS_EXECUTE ) +{ + hb_retni( hbqt_par_QProcess( 1 )->execute( hbqt_par_QString( 2 ), *hbqt_par_QStringList( 3 ) ) ); +} + +/* + * int execute ( const QString & program ) + */ +HB_FUNC( QT_QPROCESS_EXECUTE_1 ) +{ + hb_retni( hbqt_par_QProcess( 1 )->execute( hbqt_par_QString( 2 ) ) ); +} + +/* + * bool startDetached ( const QString & program, const QStringList & arguments, const QString & workingDirectory, qint64 * pid = 0 ) + */ +HB_FUNC( QT_QPROCESS_STARTDETACHED ) +{ + qint64 iPid = 0; + + hb_retl( hbqt_par_QProcess( 1 )->startDetached( hbqt_par_QString( 2 ), *hbqt_par_QStringList( 3 ), hbqt_par_QString( 4 ), &iPid ) ); + + hb_stornint( iPid, 5 ); +} + +/* + * bool startDetached ( const QString & program, const QStringList & arguments ) + */ +HB_FUNC( QT_QPROCESS_STARTDETACHED_1 ) +{ + hb_retl( hbqt_par_QProcess( 1 )->startDetached( hbqt_par_QString( 2 ), *hbqt_par_QStringList( 3 ) ) ); +} + +/* + * bool startDetached ( const QString & program ) + */ +HB_FUNC( QT_QPROCESS_STARTDETACHED_2 ) +{ + hb_retl( hbqt_par_QProcess( 1 )->startDetached( hbqt_par_QString( 2 ) ) ); +} + +/* + * QStringList systemEnvironment () + */ +HB_FUNC( QT_QPROCESS_SYSTEMENVIRONMENT ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QStringList( hbqt_par_QProcess( 1 )->systemEnvironment() ), release_QStringList ) ); +} + +/* + * void kill () + */ +HB_FUNC( QT_QPROCESS_KILL ) +{ + hbqt_par_QProcess( 1 )->kill(); +} + +/* + * void terminate () + */ +HB_FUNC( QT_QPROCESS_TERMINATE ) +{ + hbqt_par_QProcess( 1 )->terminate(); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QRect.cpp b/harbour/contrib/hbqt/qtcore/QRect.cpp new file mode 100644 index 0000000000..fd3db48ec0 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QRect.cpp @@ -0,0 +1,617 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +#include + +#include + + +/* + * QRect () + * QRect ( const QPoint & topLeft, const QPoint & bottomRight ) + * QRect ( const QPoint & topLeft, const QSize & size ) + * QRect ( int x, int y, int width, int height ) + * ~QRect () + */ + +QT_G_FUNC( release_QRect ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QRect" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QRect * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QRECT ) +{ + QGC_POINTER * p = ( QGC_POINTER * ) hb_gcAlloc( sizeof( QGC_POINTER ), Q_release ); + void * pObj = NULL; + + if( hb_pcount() == 1 && HB_ISPOINTER( 1 ) ) + { + pObj = ( QRect* ) new QRect( *hbqt_par_QRect( 1 ) ) ; + } + else if( hb_pcount() == 2 && HB_ISPOINTER( 1 ) && HB_ISPOINTER( 2 ) ) + { + pObj = ( QRect* ) new QRect( *hbqt_par_QPoint( 1 ), *hbqt_par_QPoint( 2 ) ) ; + } + else if( hb_pcount() == 4 && HB_ISNUM( 1 ) && HB_ISNUM( 2 ) && HB_ISNUM( 3 ) && HB_ISNUM( 4 ) ) + { + pObj = ( QRect* ) new QRect( hb_parni( 1 ), hb_parni( 2 ), hb_parni( 3 ), hb_parni( 4 ) ) ; + } + else + { + pObj = ( QRect* ) new QRect() ; + } + + p->ph = pObj; + p->func = release_QRect; + + hb_retptrGC( p ); +} +/* + * void adjust ( int dx1, int dy1, int dx2, int dy2 ) + */ +HB_FUNC( QT_QRECT_ADJUST ) +{ + hbqt_par_QRect( 1 )->adjust( hb_parni( 2 ), hb_parni( 3 ), hb_parni( 4 ), hb_parni( 5 ) ); +} + +/* + * QRect adjusted ( int dx1, int dy1, int dx2, int dy2 ) const + */ +HB_FUNC( QT_QRECT_ADJUSTED ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QRect( hbqt_par_QRect( 1 )->adjusted( hb_parni( 2 ), hb_parni( 3 ), hb_parni( 4 ), hb_parni( 5 ) ) ), release_QRect ) ); +} + +/* + * int bottom () const + */ +HB_FUNC( QT_QRECT_BOTTOM ) +{ + hb_retni( hbqt_par_QRect( 1 )->bottom() ); +} + +/* + * QPoint bottomLeft () const + */ +HB_FUNC( QT_QRECT_BOTTOMLEFT ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QPoint( hbqt_par_QRect( 1 )->bottomLeft() ), release_QPoint ) ); +} + +/* + * QPoint bottomRight () const + */ +HB_FUNC( QT_QRECT_BOTTOMRIGHT ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QPoint( hbqt_par_QRect( 1 )->bottomRight() ), release_QPoint ) ); +} + +/* + * QPoint center () const + */ +HB_FUNC( QT_QRECT_CENTER ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QPoint( hbqt_par_QRect( 1 )->center() ), release_QPoint ) ); +} + +/* + * bool contains ( const QPoint & point, bool proper = false ) const + */ +HB_FUNC( QT_QRECT_CONTAINS ) +{ + hb_retl( hbqt_par_QRect( 1 )->contains( *hbqt_par_QPoint( 2 ), hb_parl( 3 ) ) ); +} + +/* + * bool contains ( int x, int y, bool proper ) const + */ +HB_FUNC( QT_QRECT_CONTAINS_1 ) +{ + hb_retl( hbqt_par_QRect( 1 )->contains( hb_parni( 2 ), hb_parni( 3 ), hb_parl( 4 ) ) ); +} + +/* + * bool contains ( int x, int y ) const + */ +HB_FUNC( QT_QRECT_CONTAINS_2 ) +{ + hb_retl( hbqt_par_QRect( 1 )->contains( hb_parni( 2 ), hb_parni( 3 ) ) ); +} + +/* + * bool contains ( const QRect & rectangle, bool proper = false ) const + */ +HB_FUNC( QT_QRECT_CONTAINS_3 ) +{ + hb_retl( hbqt_par_QRect( 1 )->contains( *hbqt_par_QRect( 2 ), hb_parl( 3 ) ) ); +} + +/* + * void getCoords ( int * x1, int * y1, int * x2, int * y2 ) const + */ +HB_FUNC( QT_QRECT_GETCOORDS ) +{ + int iX1 = 0; + int iY1 = 0; + int iX2 = 0; + int iY2 = 0; + + hbqt_par_QRect( 1 )->getCoords( &iX1, &iY1, &iX2, &iY2 ); + + hb_storni( iX1, 2 ); + hb_storni( iY1, 3 ); + hb_storni( iX2, 4 ); + hb_storni( iY2, 5 ); +} + +/* + * void getRect ( int * x, int * y, int * width, int * height ) const + */ +HB_FUNC( QT_QRECT_GETRECT ) +{ + int iX = 0; + int iY = 0; + int iWidth = 0; + int iHeight = 0; + + hbqt_par_QRect( 1 )->getRect( &iX, &iY, &iWidth, &iHeight ); + + hb_storni( iX, 2 ); + hb_storni( iY, 3 ); + hb_storni( iWidth, 4 ); + hb_storni( iHeight, 5 ); +} + +/* + * int height () const + */ +HB_FUNC( QT_QRECT_HEIGHT ) +{ + hb_retni( hbqt_par_QRect( 1 )->height() ); +} + +/* + * QRect intersected ( const QRect & rectangle ) const + */ +HB_FUNC( QT_QRECT_INTERSECTED ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QRect( hbqt_par_QRect( 1 )->intersected( *hbqt_par_QRect( 2 ) ) ), release_QRect ) ); +} + +/* + * bool intersects ( const QRect & rectangle ) const + */ +HB_FUNC( QT_QRECT_INTERSECTS ) +{ + hb_retl( hbqt_par_QRect( 1 )->intersects( *hbqt_par_QRect( 2 ) ) ); +} + +/* + * bool isEmpty () const + */ +HB_FUNC( QT_QRECT_ISEMPTY ) +{ + hb_retl( hbqt_par_QRect( 1 )->isEmpty() ); +} + +/* + * bool isNull () const + */ +HB_FUNC( QT_QRECT_ISNULL ) +{ + hb_retl( hbqt_par_QRect( 1 )->isNull() ); +} + +/* + * bool isValid () const + */ +HB_FUNC( QT_QRECT_ISVALID ) +{ + hb_retl( hbqt_par_QRect( 1 )->isValid() ); +} + +/* + * int left () const + */ +HB_FUNC( QT_QRECT_LEFT ) +{ + hb_retni( hbqt_par_QRect( 1 )->left() ); +} + +/* + * void moveBottom ( int y ) + */ +HB_FUNC( QT_QRECT_MOVEBOTTOM ) +{ + hbqt_par_QRect( 1 )->moveBottom( hb_parni( 2 ) ); +} + +/* + * void moveBottomLeft ( const QPoint & position ) + */ +HB_FUNC( QT_QRECT_MOVEBOTTOMLEFT ) +{ + hbqt_par_QRect( 1 )->moveBottomLeft( *hbqt_par_QPoint( 2 ) ); +} + +/* + * void moveBottomRight ( const QPoint & position ) + */ +HB_FUNC( QT_QRECT_MOVEBOTTOMRIGHT ) +{ + hbqt_par_QRect( 1 )->moveBottomRight( *hbqt_par_QPoint( 2 ) ); +} + +/* + * void moveCenter ( const QPoint & position ) + */ +HB_FUNC( QT_QRECT_MOVECENTER ) +{ + hbqt_par_QRect( 1 )->moveCenter( *hbqt_par_QPoint( 2 ) ); +} + +/* + * void moveLeft ( int x ) + */ +HB_FUNC( QT_QRECT_MOVELEFT ) +{ + hbqt_par_QRect( 1 )->moveLeft( hb_parni( 2 ) ); +} + +/* + * void moveRight ( int x ) + */ +HB_FUNC( QT_QRECT_MOVERIGHT ) +{ + hbqt_par_QRect( 1 )->moveRight( hb_parni( 2 ) ); +} + +/* + * void moveTo ( int x, int y ) + */ +HB_FUNC( QT_QRECT_MOVETO ) +{ + hbqt_par_QRect( 1 )->moveTo( hb_parni( 2 ), hb_parni( 3 ) ); +} + +/* + * void moveTo ( const QPoint & position ) + */ +HB_FUNC( QT_QRECT_MOVETO_1 ) +{ + hbqt_par_QRect( 1 )->moveTo( *hbqt_par_QPoint( 2 ) ); +} + +/* + * void moveTop ( int y ) + */ +HB_FUNC( QT_QRECT_MOVETOP ) +{ + hbqt_par_QRect( 1 )->moveTop( hb_parni( 2 ) ); +} + +/* + * void moveTopLeft ( const QPoint & position ) + */ +HB_FUNC( QT_QRECT_MOVETOPLEFT ) +{ + hbqt_par_QRect( 1 )->moveTopLeft( *hbqt_par_QPoint( 2 ) ); +} + +/* + * void moveTopRight ( const QPoint & position ) + */ +HB_FUNC( QT_QRECT_MOVETOPRIGHT ) +{ + hbqt_par_QRect( 1 )->moveTopRight( *hbqt_par_QPoint( 2 ) ); +} + +/* + * QRect normalized () const + */ +HB_FUNC( QT_QRECT_NORMALIZED ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QRect( hbqt_par_QRect( 1 )->normalized() ), release_QRect ) ); +} + +/* + * int right () const + */ +HB_FUNC( QT_QRECT_RIGHT ) +{ + hb_retni( hbqt_par_QRect( 1 )->right() ); +} + +/* + * void setBottom ( int y ) + */ +HB_FUNC( QT_QRECT_SETBOTTOM ) +{ + hbqt_par_QRect( 1 )->setBottom( hb_parni( 2 ) ); +} + +/* + * void setBottomLeft ( const QPoint & position ) + */ +HB_FUNC( QT_QRECT_SETBOTTOMLEFT ) +{ + hbqt_par_QRect( 1 )->setBottomLeft( *hbqt_par_QPoint( 2 ) ); +} + +/* + * void setBottomRight ( const QPoint & position ) + */ +HB_FUNC( QT_QRECT_SETBOTTOMRIGHT ) +{ + hbqt_par_QRect( 1 )->setBottomRight( *hbqt_par_QPoint( 2 ) ); +} + +/* + * void setCoords ( int x1, int y1, int x2, int y2 ) + */ +HB_FUNC( QT_QRECT_SETCOORDS ) +{ + hbqt_par_QRect( 1 )->setCoords( hb_parni( 2 ), hb_parni( 3 ), hb_parni( 4 ), hb_parni( 5 ) ); +} + +/* + * void setHeight ( int height ) + */ +HB_FUNC( QT_QRECT_SETHEIGHT ) +{ + hbqt_par_QRect( 1 )->setHeight( hb_parni( 2 ) ); +} + +/* + * void setLeft ( int x ) + */ +HB_FUNC( QT_QRECT_SETLEFT ) +{ + hbqt_par_QRect( 1 )->setLeft( hb_parni( 2 ) ); +} + +/* + * void setRect ( int x, int y, int width, int height ) + */ +HB_FUNC( QT_QRECT_SETRECT ) +{ + hbqt_par_QRect( 1 )->setRect( hb_parni( 2 ), hb_parni( 3 ), hb_parni( 4 ), hb_parni( 5 ) ); +} + +/* + * void setRight ( int x ) + */ +HB_FUNC( QT_QRECT_SETRIGHT ) +{ + hbqt_par_QRect( 1 )->setRight( hb_parni( 2 ) ); +} + +/* + * void setSize ( const QSize & size ) + */ +HB_FUNC( QT_QRECT_SETSIZE ) +{ + hbqt_par_QRect( 1 )->setSize( *hbqt_par_QSize( 2 ) ); +} + +/* + * void setTop ( int y ) + */ +HB_FUNC( QT_QRECT_SETTOP ) +{ + hbqt_par_QRect( 1 )->setTop( hb_parni( 2 ) ); +} + +/* + * void setTopLeft ( const QPoint & position ) + */ +HB_FUNC( QT_QRECT_SETTOPLEFT ) +{ + hbqt_par_QRect( 1 )->setTopLeft( *hbqt_par_QPoint( 2 ) ); +} + +/* + * void setTopRight ( const QPoint & position ) + */ +HB_FUNC( QT_QRECT_SETTOPRIGHT ) +{ + hbqt_par_QRect( 1 )->setTopRight( *hbqt_par_QPoint( 2 ) ); +} + +/* + * void setWidth ( int width ) + */ +HB_FUNC( QT_QRECT_SETWIDTH ) +{ + hbqt_par_QRect( 1 )->setWidth( hb_parni( 2 ) ); +} + +/* + * void setX ( int x ) + */ +HB_FUNC( QT_QRECT_SETX ) +{ + hbqt_par_QRect( 1 )->setX( hb_parni( 2 ) ); +} + +/* + * void setY ( int y ) + */ +HB_FUNC( QT_QRECT_SETY ) +{ + hbqt_par_QRect( 1 )->setY( hb_parni( 2 ) ); +} + +/* + * QSize size () const + */ +HB_FUNC( QT_QRECT_SIZE ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QSize( hbqt_par_QRect( 1 )->size() ), release_QSize ) ); +} + +/* + * int top () const + */ +HB_FUNC( QT_QRECT_TOP ) +{ + hb_retni( hbqt_par_QRect( 1 )->top() ); +} + +/* + * QPoint topLeft () const + */ +HB_FUNC( QT_QRECT_TOPLEFT ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QPoint( hbqt_par_QRect( 1 )->topLeft() ), release_QPoint ) ); +} + +/* + * QPoint topRight () const + */ +HB_FUNC( QT_QRECT_TOPRIGHT ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QPoint( hbqt_par_QRect( 1 )->topRight() ), release_QPoint ) ); +} + +/* + * void translate ( int dx, int dy ) + */ +HB_FUNC( QT_QRECT_TRANSLATE ) +{ + hbqt_par_QRect( 1 )->translate( hb_parni( 2 ), hb_parni( 3 ) ); +} + +/* + * void translate ( const QPoint & offset ) + */ +HB_FUNC( QT_QRECT_TRANSLATE_1 ) +{ + hbqt_par_QRect( 1 )->translate( *hbqt_par_QPoint( 2 ) ); +} + +/* + * QRect translated ( int dx, int dy ) const + */ +HB_FUNC( QT_QRECT_TRANSLATED ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QRect( hbqt_par_QRect( 1 )->translated( hb_parni( 2 ), hb_parni( 3 ) ) ), release_QRect ) ); +} + +/* + * QRect translated ( const QPoint & offset ) const + */ +HB_FUNC( QT_QRECT_TRANSLATED_1 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QRect( hbqt_par_QRect( 1 )->translated( *hbqt_par_QPoint( 2 ) ) ), release_QRect ) ); +} + +/* + * QRect united ( const QRect & rectangle ) const + */ +HB_FUNC( QT_QRECT_UNITED ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QRect( hbqt_par_QRect( 1 )->united( *hbqt_par_QRect( 2 ) ) ), release_QRect ) ); +} + +/* + * int width () const + */ +HB_FUNC( QT_QRECT_WIDTH ) +{ + hb_retni( hbqt_par_QRect( 1 )->width() ); +} + +/* + * int x () const + */ +HB_FUNC( QT_QRECT_X ) +{ + hb_retni( hbqt_par_QRect( 1 )->x() ); +} + +/* + * int y () const + */ +HB_FUNC( QT_QRECT_Y ) +{ + hb_retni( hbqt_par_QRect( 1 )->y() ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QRectF.cpp b/harbour/contrib/hbqt/qtcore/QRectF.cpp new file mode 100644 index 0000000000..ec5c3b12e4 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QRectF.cpp @@ -0,0 +1,626 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +#include + +#include + + +/* + * QRectF () + * QRectF ( const QPointF & topLeft, const QSizeF & size ) + * QRectF ( const QPointF & topLeft, const QPointF & bottomRight ) + * QRectF ( qreal x, qreal y, qreal width, qreal height ) + * QRectF ( const QRect & rectangle ) + * ~QRectF () + */ + +QT_G_FUNC( release_QRectF ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QRectF" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QRectF * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QRECTF ) +{ + QGC_POINTER * p = ( QGC_POINTER * ) hb_gcAlloc( sizeof( QGC_POINTER ), Q_release ); + void * pObj = NULL; + + if( hb_pcount() == 1 && HB_ISPOINTER( 1 ) ) + { + pObj = ( QRectF* ) new QRectF( *hbqt_par_QRectF( 1 ) ) ; + } + else if( hb_pcount() == 2 && HB_ISPOINTER( 1 ) && HB_ISPOINTER( 2 ) ) + { + pObj = ( QRectF* ) new QRectF( *hbqt_par_QPoint( 1 ), *hbqt_par_QPoint( 2 ) ) ; + } + else if( hb_pcount() == 4 && HB_ISNUM( 1 ) && HB_ISNUM( 2 ) && HB_ISNUM( 3 ) && HB_ISNUM( 4 ) ) + { + pObj = ( QRectF* ) new QRectF( hb_parnd( 1 ), hb_parnd( 2 ), hb_parnd( 3 ), hb_parnd( 4 ) ) ; + } + else + { + pObj = ( QRectF* ) new QRectF() ; + } + + p->ph = pObj; + p->func = release_QRectF; + + hb_retptrGC( p ); +} +/* + * void adjust ( qreal dx1, qreal dy1, qreal dx2, qreal dy2 ) + */ +HB_FUNC( QT_QRECTF_ADJUST ) +{ + hbqt_par_QRectF( 1 )->adjust( hb_parnd( 2 ), hb_parnd( 3 ), hb_parnd( 4 ), hb_parnd( 5 ) ); +} + +/* + * QRectF adjusted ( qreal dx1, qreal dy1, qreal dx2, qreal dy2 ) const + */ +HB_FUNC( QT_QRECTF_ADJUSTED ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QRectF( hbqt_par_QRectF( 1 )->adjusted( hb_parnd( 2 ), hb_parnd( 3 ), hb_parnd( 4 ), hb_parnd( 5 ) ) ), release_QRectF ) ); +} + +/* + * qreal bottom () const + */ +HB_FUNC( QT_QRECTF_BOTTOM ) +{ + hb_retnd( hbqt_par_QRectF( 1 )->bottom() ); +} + +/* + * QPointF bottomLeft () const + */ +HB_FUNC( QT_QRECTF_BOTTOMLEFT ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QPointF( hbqt_par_QRectF( 1 )->bottomLeft() ), release_QPointF ) ); +} + +/* + * QPointF bottomRight () const + */ +HB_FUNC( QT_QRECTF_BOTTOMRIGHT ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QPointF( hbqt_par_QRectF( 1 )->bottomRight() ), release_QPointF ) ); +} + +/* + * QPointF center () const + */ +HB_FUNC( QT_QRECTF_CENTER ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QPointF( hbqt_par_QRectF( 1 )->center() ), release_QPointF ) ); +} + +/* + * bool contains ( const QPointF & point ) const + */ +HB_FUNC( QT_QRECTF_CONTAINS ) +{ + hb_retl( hbqt_par_QRectF( 1 )->contains( *hbqt_par_QPointF( 2 ) ) ); +} + +/* + * bool contains ( qreal x, qreal y ) const + */ +HB_FUNC( QT_QRECTF_CONTAINS_1 ) +{ + hb_retl( hbqt_par_QRectF( 1 )->contains( hb_parnd( 2 ), hb_parnd( 3 ) ) ); +} + +/* + * bool contains ( const QRectF & rectangle ) const + */ +HB_FUNC( QT_QRECTF_CONTAINS_2 ) +{ + hb_retl( hbqt_par_QRectF( 1 )->contains( *hbqt_par_QRectF( 2 ) ) ); +} + +/* + * void getCoords ( qreal * x1, qreal * y1, qreal * x2, qreal * y2 ) const + */ +HB_FUNC( QT_QRECTF_GETCOORDS ) +{ + qreal qrX1 = 0; + qreal qrY1 = 0; + qreal qrX2 = 0; + qreal qrY2 = 0; + + hbqt_par_QRectF( 1 )->getCoords( &qrX1, &qrY1, &qrX2, &qrY2 ); + + hb_stornd( qrX1, 2 ); + hb_stornd( qrY1, 3 ); + hb_stornd( qrX2, 4 ); + hb_stornd( qrY2, 5 ); +} + +/* + * void getRect ( qreal * x, qreal * y, qreal * width, qreal * height ) const + */ +HB_FUNC( QT_QRECTF_GETRECT ) +{ + qreal qrX = 0; + qreal qrY = 0; + qreal qrWidth = 0; + qreal qrHeight = 0; + + hbqt_par_QRectF( 1 )->getRect( &qrX, &qrY, &qrWidth, &qrHeight ); + + hb_stornd( qrX, 2 ); + hb_stornd( qrY, 3 ); + hb_stornd( qrWidth, 4 ); + hb_stornd( qrHeight, 5 ); +} + +/* + * qreal height () const + */ +HB_FUNC( QT_QRECTF_HEIGHT ) +{ + hb_retnd( hbqt_par_QRectF( 1 )->height() ); +} + +/* + * QRectF intersected ( const QRectF & rectangle ) const + */ +HB_FUNC( QT_QRECTF_INTERSECTED ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QRectF( hbqt_par_QRectF( 1 )->intersected( *hbqt_par_QRectF( 2 ) ) ), release_QRectF ) ); +} + +/* + * bool intersects ( const QRectF & rectangle ) const + */ +HB_FUNC( QT_QRECTF_INTERSECTS ) +{ + hb_retl( hbqt_par_QRectF( 1 )->intersects( *hbqt_par_QRectF( 2 ) ) ); +} + +/* + * bool isEmpty () const + */ +HB_FUNC( QT_QRECTF_ISEMPTY ) +{ + hb_retl( hbqt_par_QRectF( 1 )->isEmpty() ); +} + +/* + * bool isNull () const + */ +HB_FUNC( QT_QRECTF_ISNULL ) +{ + hb_retl( hbqt_par_QRectF( 1 )->isNull() ); +} + +/* + * bool isValid () const + */ +HB_FUNC( QT_QRECTF_ISVALID ) +{ + hb_retl( hbqt_par_QRectF( 1 )->isValid() ); +} + +/* + * qreal left () const + */ +HB_FUNC( QT_QRECTF_LEFT ) +{ + hb_retnd( hbqt_par_QRectF( 1 )->left() ); +} + +/* + * void moveBottom ( qreal y ) + */ +HB_FUNC( QT_QRECTF_MOVEBOTTOM ) +{ + hbqt_par_QRectF( 1 )->moveBottom( hb_parnd( 2 ) ); +} + +/* + * void moveBottomLeft ( const QPointF & position ) + */ +HB_FUNC( QT_QRECTF_MOVEBOTTOMLEFT ) +{ + hbqt_par_QRectF( 1 )->moveBottomLeft( *hbqt_par_QPointF( 2 ) ); +} + +/* + * void moveBottomRight ( const QPointF & position ) + */ +HB_FUNC( QT_QRECTF_MOVEBOTTOMRIGHT ) +{ + hbqt_par_QRectF( 1 )->moveBottomRight( *hbqt_par_QPointF( 2 ) ); +} + +/* + * void moveCenter ( const QPointF & position ) + */ +HB_FUNC( QT_QRECTF_MOVECENTER ) +{ + hbqt_par_QRectF( 1 )->moveCenter( *hbqt_par_QPointF( 2 ) ); +} + +/* + * void moveLeft ( qreal x ) + */ +HB_FUNC( QT_QRECTF_MOVELEFT ) +{ + hbqt_par_QRectF( 1 )->moveLeft( hb_parnd( 2 ) ); +} + +/* + * void moveRight ( qreal x ) + */ +HB_FUNC( QT_QRECTF_MOVERIGHT ) +{ + hbqt_par_QRectF( 1 )->moveRight( hb_parnd( 2 ) ); +} + +/* + * void moveTo ( qreal x, qreal y ) + */ +HB_FUNC( QT_QRECTF_MOVETO ) +{ + hbqt_par_QRectF( 1 )->moveTo( hb_parnd( 2 ), hb_parnd( 3 ) ); +} + +/* + * void moveTo ( const QPointF & position ) + */ +HB_FUNC( QT_QRECTF_MOVETO_1 ) +{ + hbqt_par_QRectF( 1 )->moveTo( *hbqt_par_QPointF( 2 ) ); +} + +/* + * void moveTop ( qreal y ) + */ +HB_FUNC( QT_QRECTF_MOVETOP ) +{ + hbqt_par_QRectF( 1 )->moveTop( hb_parnd( 2 ) ); +} + +/* + * void moveTopLeft ( const QPointF & position ) + */ +HB_FUNC( QT_QRECTF_MOVETOPLEFT ) +{ + hbqt_par_QRectF( 1 )->moveTopLeft( *hbqt_par_QPointF( 2 ) ); +} + +/* + * void moveTopRight ( const QPointF & position ) + */ +HB_FUNC( QT_QRECTF_MOVETOPRIGHT ) +{ + hbqt_par_QRectF( 1 )->moveTopRight( *hbqt_par_QPointF( 2 ) ); +} + +/* + * QRectF normalized () const + */ +HB_FUNC( QT_QRECTF_NORMALIZED ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QRectF( hbqt_par_QRectF( 1 )->normalized() ), release_QRectF ) ); +} + +/* + * qreal right () const + */ +HB_FUNC( QT_QRECTF_RIGHT ) +{ + hb_retnd( hbqt_par_QRectF( 1 )->right() ); +} + +/* + * void setBottom ( qreal y ) + */ +HB_FUNC( QT_QRECTF_SETBOTTOM ) +{ + hbqt_par_QRectF( 1 )->setBottom( hb_parnd( 2 ) ); +} + +/* + * void setBottomLeft ( const QPointF & position ) + */ +HB_FUNC( QT_QRECTF_SETBOTTOMLEFT ) +{ + hbqt_par_QRectF( 1 )->setBottomLeft( *hbqt_par_QPointF( 2 ) ); +} + +/* + * void setBottomRight ( const QPointF & position ) + */ +HB_FUNC( QT_QRECTF_SETBOTTOMRIGHT ) +{ + hbqt_par_QRectF( 1 )->setBottomRight( *hbqt_par_QPointF( 2 ) ); +} + +/* + * void setCoords ( qreal x1, qreal y1, qreal x2, qreal y2 ) + */ +HB_FUNC( QT_QRECTF_SETCOORDS ) +{ + hbqt_par_QRectF( 1 )->setCoords( hb_parnd( 2 ), hb_parnd( 3 ), hb_parnd( 4 ), hb_parnd( 5 ) ); +} + +/* + * void setHeight ( qreal height ) + */ +HB_FUNC( QT_QRECTF_SETHEIGHT ) +{ + hbqt_par_QRectF( 1 )->setHeight( hb_parnd( 2 ) ); +} + +/* + * void setLeft ( qreal x ) + */ +HB_FUNC( QT_QRECTF_SETLEFT ) +{ + hbqt_par_QRectF( 1 )->setLeft( hb_parnd( 2 ) ); +} + +/* + * void setRect ( qreal x, qreal y, qreal width, qreal height ) + */ +HB_FUNC( QT_QRECTF_SETRECT ) +{ + hbqt_par_QRectF( 1 )->setRect( hb_parnd( 2 ), hb_parnd( 3 ), hb_parnd( 4 ), hb_parnd( 5 ) ); +} + +/* + * void setRight ( qreal x ) + */ +HB_FUNC( QT_QRECTF_SETRIGHT ) +{ + hbqt_par_QRectF( 1 )->setRight( hb_parnd( 2 ) ); +} + +/* + * void setSize ( const QSizeF & size ) + */ +HB_FUNC( QT_QRECTF_SETSIZE ) +{ + hbqt_par_QRectF( 1 )->setSize( *hbqt_par_QSizeF( 2 ) ); +} + +/* + * void setTop ( qreal y ) + */ +HB_FUNC( QT_QRECTF_SETTOP ) +{ + hbqt_par_QRectF( 1 )->setTop( hb_parnd( 2 ) ); +} + +/* + * void setTopLeft ( const QPointF & position ) + */ +HB_FUNC( QT_QRECTF_SETTOPLEFT ) +{ + hbqt_par_QRectF( 1 )->setTopLeft( *hbqt_par_QPointF( 2 ) ); +} + +/* + * void setTopRight ( const QPointF & position ) + */ +HB_FUNC( QT_QRECTF_SETTOPRIGHT ) +{ + hbqt_par_QRectF( 1 )->setTopRight( *hbqt_par_QPointF( 2 ) ); +} + +/* + * void setWidth ( qreal width ) + */ +HB_FUNC( QT_QRECTF_SETWIDTH ) +{ + hbqt_par_QRectF( 1 )->setWidth( hb_parnd( 2 ) ); +} + +/* + * void setX ( qreal x ) + */ +HB_FUNC( QT_QRECTF_SETX ) +{ + hbqt_par_QRectF( 1 )->setX( hb_parnd( 2 ) ); +} + +/* + * void setY ( qreal y ) + */ +HB_FUNC( QT_QRECTF_SETY ) +{ + hbqt_par_QRectF( 1 )->setY( hb_parnd( 2 ) ); +} + +/* + * QSizeF size () const + */ +HB_FUNC( QT_QRECTF_SIZE ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QSizeF( hbqt_par_QRectF( 1 )->size() ), release_QSizeF ) ); +} + +/* + * QRect toAlignedRect () const + */ +HB_FUNC( QT_QRECTF_TOALIGNEDRECT ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QRect( hbqt_par_QRectF( 1 )->toAlignedRect() ), release_QRect ) ); +} + +/* + * QRect toRect () const + */ +HB_FUNC( QT_QRECTF_TORECT ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QRect( hbqt_par_QRectF( 1 )->toRect() ), release_QRect ) ); +} + +/* + * qreal top () const + */ +HB_FUNC( QT_QRECTF_TOP ) +{ + hb_retnd( hbqt_par_QRectF( 1 )->top() ); +} + +/* + * QPointF topLeft () const + */ +HB_FUNC( QT_QRECTF_TOPLEFT ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QPointF( hbqt_par_QRectF( 1 )->topLeft() ), release_QPointF ) ); +} + +/* + * QPointF topRight () const + */ +HB_FUNC( QT_QRECTF_TOPRIGHT ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QPointF( hbqt_par_QRectF( 1 )->topRight() ), release_QPointF ) ); +} + +/* + * void translate ( qreal dx, qreal dy ) + */ +HB_FUNC( QT_QRECTF_TRANSLATE ) +{ + hbqt_par_QRectF( 1 )->translate( hb_parnd( 2 ), hb_parnd( 3 ) ); +} + +/* + * void translate ( const QPointF & offset ) + */ +HB_FUNC( QT_QRECTF_TRANSLATE_1 ) +{ + hbqt_par_QRectF( 1 )->translate( *hbqt_par_QPointF( 2 ) ); +} + +/* + * QRectF translated ( qreal dx, qreal dy ) const + */ +HB_FUNC( QT_QRECTF_TRANSLATED ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QRectF( hbqt_par_QRectF( 1 )->translated( hb_parnd( 2 ), hb_parnd( 3 ) ) ), release_QRectF ) ); +} + +/* + * QRectF translated ( const QPointF & offset ) const + */ +HB_FUNC( QT_QRECTF_TRANSLATED_1 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QRectF( hbqt_par_QRectF( 1 )->translated( *hbqt_par_QPointF( 2 ) ) ), release_QRectF ) ); +} + +/* + * QRectF united ( const QRectF & rectangle ) const + */ +HB_FUNC( QT_QRECTF_UNITED ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QRectF( hbqt_par_QRectF( 1 )->united( *hbqt_par_QRectF( 2 ) ) ), release_QRectF ) ); +} + +/* + * qreal width () const + */ +HB_FUNC( QT_QRECTF_WIDTH ) +{ + hb_retnd( hbqt_par_QRectF( 1 )->width() ); +} + +/* + * qreal x () const + */ +HB_FUNC( QT_QRECTF_X ) +{ + hb_retnd( hbqt_par_QRectF( 1 )->x() ); +} + +/* + * qreal y () const + */ +HB_FUNC( QT_QRECTF_Y ) +{ + hb_retnd( hbqt_par_QRectF( 1 )->y() ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QRegExp.cpp b/harbour/contrib/hbqt/qtcore/QRegExp.cpp new file mode 100644 index 0000000000..53d7296fe3 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QRegExp.cpp @@ -0,0 +1,265 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +/* + * enum CaretMode { CaretAtZero, CaretAtOffset, CaretWontMatch } + * enum PatternSyntax { RegExp, RegExp2, Wildcard, FixedString } + */ + +#include + +#include +#include + +/* QRegExp () + * QRegExp ( const QString & pattern, Qt::CaseSensitivity cs = Qt::CaseSensitive, PatternSyntax syntax = RegExp ) + * QRegExp ( const QRegExp & rx ) + * ~QRegExp () + */ + +QT_G_FUNC( release_QRegExp ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QRegExp" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QRegExp * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QREGEXP ) +{ + QGC_POINTER * p = ( QGC_POINTER * ) hb_gcAlloc( sizeof( QGC_POINTER ), Q_release ); + void * pObj = NULL; + + pObj = new QRegExp() ; + + p->ph = pObj; + p->func = release_QRegExp; + + hb_retptrGC( p ); +} +/* + * QString cap ( int nth = 0 ) const + */ +HB_FUNC( QT_QREGEXP_CAP ) +{ + hb_retc( hbqt_par_QRegExp( 1 )->cap( hb_parni( 2 ) ).toAscii().data() ); +} + +/* + * QStringList capturedTexts () const + */ +HB_FUNC( QT_QREGEXP_CAPTUREDTEXTS ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QStringList( hbqt_par_QRegExp( 1 )->capturedTexts() ), release_QStringList ) ); +} + +/* + * Qt::CaseSensitivity caseSensitivity () const + */ +HB_FUNC( QT_QREGEXP_CASESENSITIVITY ) +{ + hb_retni( ( Qt::CaseSensitivity ) hbqt_par_QRegExp( 1 )->caseSensitivity() ); +} + +/* + * QString errorString () const + */ +HB_FUNC( QT_QREGEXP_ERRORSTRING ) +{ + hb_retc( hbqt_par_QRegExp( 1 )->errorString().toAscii().data() ); +} + +/* + * bool exactMatch ( const QString & str ) const + */ +HB_FUNC( QT_QREGEXP_EXACTMATCH ) +{ + hb_retl( hbqt_par_QRegExp( 1 )->exactMatch( hbqt_par_QString( 2 ) ) ); +} + +/* + * int indexIn ( const QString & str, int offset = 0, CaretMode caretMode = CaretAtZero ) const + */ +HB_FUNC( QT_QREGEXP_INDEXIN ) +{ + hb_retni( hbqt_par_QRegExp( 1 )->indexIn( hbqt_par_QString( 2 ), hb_parni( 3 ), ( HB_ISNUM( 4 ) ? ( QRegExp::CaretMode ) hb_parni( 4 ) : ( QRegExp::CaretMode ) QRegExp::CaretAtZero ) ) ); +} + +/* + * bool isEmpty () const + */ +HB_FUNC( QT_QREGEXP_ISEMPTY ) +{ + hb_retl( hbqt_par_QRegExp( 1 )->isEmpty() ); +} + +/* + * bool isMinimal () const + */ +HB_FUNC( QT_QREGEXP_ISMINIMAL ) +{ + hb_retl( hbqt_par_QRegExp( 1 )->isMinimal() ); +} + +/* + * bool isValid () const + */ +HB_FUNC( QT_QREGEXP_ISVALID ) +{ + hb_retl( hbqt_par_QRegExp( 1 )->isValid() ); +} + +/* + * int lastIndexIn ( const QString & str, int offset = -1, CaretMode caretMode = CaretAtZero ) const + */ +HB_FUNC( QT_QREGEXP_LASTINDEXIN ) +{ + hb_retni( hbqt_par_QRegExp( 1 )->lastIndexIn( hbqt_par_QString( 2 ), ( HB_ISNUM( 3 ) ? hb_parni( 3 ) : -1 ), ( HB_ISNUM( 4 ) ? ( QRegExp::CaretMode ) hb_parni( 4 ) : ( QRegExp::CaretMode ) QRegExp::CaretAtZero ) ) ); +} + +/* + * int matchedLength () const + */ +HB_FUNC( QT_QREGEXP_MATCHEDLENGTH ) +{ + hb_retni( hbqt_par_QRegExp( 1 )->matchedLength() ); +} + +/* + * int numCaptures () const + */ +HB_FUNC( QT_QREGEXP_NUMCAPTURES ) +{ + hb_retni( hbqt_par_QRegExp( 1 )->numCaptures() ); +} + +/* + * QString pattern () const + */ +HB_FUNC( QT_QREGEXP_PATTERN ) +{ + hb_retc( hbqt_par_QRegExp( 1 )->pattern().toAscii().data() ); +} + +/* + * PatternSyntax patternSyntax () const + */ +HB_FUNC( QT_QREGEXP_PATTERNSYNTAX ) +{ + hb_retni( ( QRegExp::PatternSyntax ) hbqt_par_QRegExp( 1 )->patternSyntax() ); +} + +/* + * int pos ( int nth = 0 ) const + */ +HB_FUNC( QT_QREGEXP_POS ) +{ + hb_retni( hbqt_par_QRegExp( 1 )->pos( hb_parni( 2 ) ) ); +} + +/* + * void setCaseSensitivity ( Qt::CaseSensitivity cs ) + */ +HB_FUNC( QT_QREGEXP_SETCASESENSITIVITY ) +{ + hbqt_par_QRegExp( 1 )->setCaseSensitivity( ( Qt::CaseSensitivity ) hb_parni( 2 ) ); +} + +/* + * void setMinimal ( bool minimal ) + */ +HB_FUNC( QT_QREGEXP_SETMINIMAL ) +{ + hbqt_par_QRegExp( 1 )->setMinimal( hb_parl( 2 ) ); +} + +/* + * void setPattern ( const QString & pattern ) + */ +HB_FUNC( QT_QREGEXP_SETPATTERN ) +{ + hbqt_par_QRegExp( 1 )->setPattern( hbqt_par_QString( 2 ) ); +} + +/* + * void setPatternSyntax ( PatternSyntax syntax ) + */ +HB_FUNC( QT_QREGEXP_SETPATTERNSYNTAX ) +{ + hbqt_par_QRegExp( 1 )->setPatternSyntax( ( QRegExp::PatternSyntax ) hb_parni( 2 ) ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QResource.cpp b/harbour/contrib/hbqt/qtcore/QResource.cpp new file mode 100644 index 0000000000..dd24ed18aa --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QResource.cpp @@ -0,0 +1,199 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +#include + +#include + + +/* + * QResource ( const QString & file = QString(), const QLocale & locale = QLocale() ) + * ~QResource () + */ + +QT_G_FUNC( release_QResource ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QResource" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QResource * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QRESOURCE ) +{ + void * pObj = NULL; + + pObj = ( QResource* ) new QResource() ; + + hb_retptr( pObj ); +} +/* + * QString absoluteFilePath () const + */ +HB_FUNC( QT_QRESOURCE_ABSOLUTEFILEPATH ) +{ + hb_retc( hbqt_par_QResource( 1 )->absoluteFilePath().toAscii().data() ); +} + +/* + * const uchar * data () const + */ +HB_FUNC( QT_QRESOURCE_DATA ) +{ + hb_retptr( ( uchar* ) hbqt_par_QResource( 1 )->data() ); +} + +/* + * QString fileName () const + */ +HB_FUNC( QT_QRESOURCE_FILENAME ) +{ + hb_retc( hbqt_par_QResource( 1 )->fileName().toAscii().data() ); +} + +/* + * bool isCompressed () const + */ +HB_FUNC( QT_QRESOURCE_ISCOMPRESSED ) +{ + hb_retl( hbqt_par_QResource( 1 )->isCompressed() ); +} + +/* + * bool isValid () const + */ +HB_FUNC( QT_QRESOURCE_ISVALID ) +{ + hb_retl( hbqt_par_QResource( 1 )->isValid() ); +} + +/* + * QLocale locale () const + */ +HB_FUNC( QT_QRESOURCE_LOCALE ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QLocale( hbqt_par_QResource( 1 )->locale() ), release_QLocale ) ); +} + +/* + * void setFileName ( const QString & file ) + */ +HB_FUNC( QT_QRESOURCE_SETFILENAME ) +{ + hbqt_par_QResource( 1 )->setFileName( hbqt_par_QString( 2 ) ); +} + +/* + * void setLocale ( const QLocale & locale ) + */ +HB_FUNC( QT_QRESOURCE_SETLOCALE ) +{ + hbqt_par_QResource( 1 )->setLocale( *hbqt_par_QLocale( 2 ) ); +} + +/* + * qint64 size () const + */ +HB_FUNC( QT_QRESOURCE_SIZE ) +{ + hb_retnint( hbqt_par_QResource( 1 )->size() ); +} + +/* + * bool registerResource ( const QString & rccFileName, const QString & mapRoot = QString() ) + */ +HB_FUNC( QT_QRESOURCE_REGISTERRESOURCE ) +{ + hb_retl( hbqt_par_QResource( 1 )->registerResource( hbqt_par_QString( 2 ), hbqt_par_QString( 3 ) ) ); +} + +/* + * QStringList searchPaths () + */ +HB_FUNC( QT_QRESOURCE_SEARCHPATHS ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QStringList( hbqt_par_QResource( 1 )->searchPaths() ), release_QStringList ) ); +} + +/* + * bool unregisterResource ( const QString & rccFileName, const QString & mapRoot = QString() ) + */ +HB_FUNC( QT_QRESOURCE_UNREGISTERRESOURCE ) +{ + hb_retl( hbqt_par_QResource( 1 )->unregisterResource( hbqt_par_QString( 2 ), hbqt_par_QString( 3 ) ) ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QSignalMapper.cpp b/harbour/contrib/hbqt/qtcore/QSignalMapper.cpp new file mode 100644 index 0000000000..42cabf0028 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QSignalMapper.cpp @@ -0,0 +1,205 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +#include + +#include + + +/* + * QSignalMapper ( QObject * parent = 0 ) + * ~QSignalMapper () + */ + +QT_G_FUNC( release_QSignalMapper ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QSignalMapper" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + const QMetaObject * m = ( ( QObject * ) ph )->metaObject(); + if( ( QString ) m->className() != ( QString ) "QObject" ) + { + delete ( ( QSignalMapper * ) ph ); + ph = NULL; + } + else + { +#if defined(__debug__) + hb_snprintf( str, sizeof(str), " Object Name Missing: QSignalMapper" ); OutputDebugString( str ); +#endif + } + } +} + +HB_FUNC( QT_QSIGNALMAPPER ) +{ + QGC_POINTER * p = ( QGC_POINTER * ) hb_gcAlloc( sizeof( QGC_POINTER ), Q_release ); + QPointer< QSignalMapper > pObj = NULL; + + pObj = new QSignalMapper( hbqt_par_QObject( 1 ) ) ; + + p->ph = pObj; + p->func = release_QSignalMapper; + + hb_retptrGC( p ); +} +/* + * QObject * mapping ( int id ) const + */ +HB_FUNC( QT_QSIGNALMAPPER_MAPPING ) +{ + hb_retptr( ( QObject* ) hbqt_par_QSignalMapper( 1 )->mapping( hb_parni( 2 ) ) ); +} + +/* + * QObject * mapping ( const QString & id ) const + */ +HB_FUNC( QT_QSIGNALMAPPER_MAPPING_1 ) +{ + hb_retptr( ( QObject* ) hbqt_par_QSignalMapper( 1 )->mapping( hbqt_par_QString( 2 ) ) ); +} + +/* + * QObject * mapping ( QWidget * widget ) const + */ +HB_FUNC( QT_QSIGNALMAPPER_MAPPING_2 ) +{ + hb_retptr( ( QObject* ) hbqt_par_QSignalMapper( 1 )->mapping( hbqt_par_QWidget( 2 ) ) ); +} + +/* + * QObject * mapping ( QObject * object ) const + */ +HB_FUNC( QT_QSIGNALMAPPER_MAPPING_3 ) +{ + hb_retptr( ( QObject* ) hbqt_par_QSignalMapper( 1 )->mapping( hbqt_par_QObject( 2 ) ) ); +} + +/* + * void removeMappings ( QObject * sender ) + */ +HB_FUNC( QT_QSIGNALMAPPER_REMOVEMAPPINGS ) +{ + hbqt_par_QSignalMapper( 1 )->removeMappings( hbqt_par_QObject( 2 ) ); +} + +/* + * void setMapping ( QObject * sender, int id ) + */ +HB_FUNC( QT_QSIGNALMAPPER_SETMAPPING ) +{ + hbqt_par_QSignalMapper( 1 )->setMapping( hbqt_par_QObject( 2 ), hb_parni( 3 ) ); +} + +/* + * void setMapping ( QObject * sender, const QString & text ) + */ +HB_FUNC( QT_QSIGNALMAPPER_SETMAPPING_1 ) +{ + hbqt_par_QSignalMapper( 1 )->setMapping( hbqt_par_QObject( 2 ), hbqt_par_QString( 3 ) ); +} + +/* + * void setMapping ( QObject * sender, QWidget * widget ) + */ +HB_FUNC( QT_QSIGNALMAPPER_SETMAPPING_2 ) +{ + hbqt_par_QSignalMapper( 1 )->setMapping( hbqt_par_QObject( 2 ), hbqt_par_QWidget( 3 ) ); +} + +/* + * void setMapping ( QObject * sender, QObject * object ) + */ +HB_FUNC( QT_QSIGNALMAPPER_SETMAPPING_3 ) +{ + hbqt_par_QSignalMapper( 1 )->setMapping( hbqt_par_QObject( 2 ), hbqt_par_QObject( 3 ) ); +} + +/* + * void map () + */ +HB_FUNC( QT_QSIGNALMAPPER_MAP ) +{ + hbqt_par_QSignalMapper( 1 )->map(); +} + +/* + * void map ( QObject * sender ) + */ +HB_FUNC( QT_QSIGNALMAPPER_MAP_1 ) +{ + hbqt_par_QSignalMapper( 1 )->map( hbqt_par_QObject( 2 ) ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QSize.cpp b/harbour/contrib/hbqt/qtcore/QSize.cpp new file mode 100644 index 0000000000..1cc194ec06 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QSize.cpp @@ -0,0 +1,231 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +#include + +#include + + +/* + * QSize () + * QSize ( int width, int height ) + * ~QSize () + */ + +QT_G_FUNC( release_QSize ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QSize" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QSize * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QSIZE ) +{ + QGC_POINTER * p = ( QGC_POINTER * ) hb_gcAlloc( sizeof( QGC_POINTER ), Q_release ); + void * pObj = NULL; + + if( hb_pcount() == 2 && HB_ISNUM( 1 ) && HB_ISNUM( 2 ) ) + { + pObj = ( QSize* ) new QSize( hb_parni( 1 ), hb_parni( 2 ) ) ; + } + else if( hb_pcount() == 1 && HB_ISPOINTER( 1 ) ) + { + pObj = ( QSize* ) new QSize( *hbqt_par_QSize( 1 ) ) ; + } + else + { + pObj = ( QSize* ) new QSize() ; + } + + p->ph = pObj; + p->func = release_QSize; + + hb_retptrGC( p ); +} +/* + * int height () const + */ +HB_FUNC( QT_QSIZE_HEIGHT ) +{ + hb_retni( hbqt_par_QSize( 1 )->height() ); +} + +/* + * bool isEmpty () const + */ +HB_FUNC( QT_QSIZE_ISEMPTY ) +{ + hb_retl( hbqt_par_QSize( 1 )->isEmpty() ); +} + +/* + * bool isNull () const + */ +HB_FUNC( QT_QSIZE_ISNULL ) +{ + hb_retl( hbqt_par_QSize( 1 )->isNull() ); +} + +/* + * bool isValid () const + */ +HB_FUNC( QT_QSIZE_ISVALID ) +{ + hb_retl( hbqt_par_QSize( 1 )->isValid() ); +} + +/* + * int & rheight () + */ +HB_FUNC( QT_QSIZE_RHEIGHT ) +{ + hb_retni( hbqt_par_QSize( 1 )->rheight() ); +} + +/* + * int & rwidth () + */ +HB_FUNC( QT_QSIZE_RWIDTH ) +{ + hb_retni( hbqt_par_QSize( 1 )->rwidth() ); +} + +/* + * void scale ( int width, int height, Qt::AspectRatioMode mode ) + */ +HB_FUNC( QT_QSIZE_SCALE ) +{ + hbqt_par_QSize( 1 )->scale( hb_parni( 2 ), hb_parni( 3 ), ( Qt::AspectRatioMode ) hb_parni( 4 ) ); +} + +/* + * void scale ( const QSize & size, Qt::AspectRatioMode mode ) + */ +HB_FUNC( QT_QSIZE_SCALE_1 ) +{ + hbqt_par_QSize( 1 )->scale( *hbqt_par_QSize( 2 ), ( Qt::AspectRatioMode ) hb_parni( 3 ) ); +} + +/* + * void setHeight ( int height ) + */ +HB_FUNC( QT_QSIZE_SETHEIGHT ) +{ + hbqt_par_QSize( 1 )->setHeight( hb_parni( 2 ) ); +} + +/* + * void setWidth ( int width ) + */ +HB_FUNC( QT_QSIZE_SETWIDTH ) +{ + hbqt_par_QSize( 1 )->setWidth( hb_parni( 2 ) ); +} + +/* + * void transpose () + */ +HB_FUNC( QT_QSIZE_TRANSPOSE ) +{ + hbqt_par_QSize( 1 )->transpose(); +} + +/* + * int width () const + */ +HB_FUNC( QT_QSIZE_WIDTH ) +{ + hb_retni( hbqt_par_QSize( 1 )->width() ); +} + +/* + * QSize boundedTo ( const QSize & otherSize ) const + */ +HB_FUNC( QT_QSIZE_BOUNDEDTO ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QSize( hbqt_par_QSize( 1 )->boundedTo( *hbqt_par_QSize( 2 ) ) ), release_QSize ) ); +} + +/* + * QSize expandedTo ( const QSize & otherSize ) const + */ +HB_FUNC( QT_QSIZE_EXPANDEDTO ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QSize( hbqt_par_QSize( 1 )->expandedTo( *hbqt_par_QSize( 2 ) ) ), release_QSize ) ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QSizeF.cpp b/harbour/contrib/hbqt/qtcore/QSizeF.cpp new file mode 100644 index 0000000000..8d026189bc --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QSizeF.cpp @@ -0,0 +1,236 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +#include + +#include + + +/* + * QSizeF () + * QSizeF ( const QSize & size ) + * QSizeF ( qreal width, qreal height ) + * ~QSizeF () + */ + +QT_G_FUNC( release_QSizeF ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QSizeF" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QSizeF * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QSIZEF ) +{ + QGC_POINTER * p = ( QGC_POINTER * ) hb_gcAlloc( sizeof( QGC_POINTER ), Q_release ); + void * pObj = NULL; + + if( hb_pcount() == 2 && HB_ISNUM( 1 ) && HB_ISNUM( 2 ) ) + { + pObj = ( QSizeF* ) new QSizeF( hb_parnd( 1 ), hb_parnd( 2 ) ) ; + } + else + { + pObj = ( QSizeF* ) new QSizeF() ; + } + + p->ph = pObj; + p->func = release_QSizeF; + + hb_retptrGC( p ); +} +/* + * QSizeF boundedTo ( const QSizeF & otherSize ) const + */ +HB_FUNC( QT_QSIZEF_BOUNDEDTO ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QSizeF( hbqt_par_QSizeF( 1 )->boundedTo( *hbqt_par_QSizeF( 2 ) ) ), release_QSizeF ) ); +} + +/* + * QSizeF expandedTo ( const QSizeF & otherSize ) const + */ +HB_FUNC( QT_QSIZEF_EXPANDEDTO ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QSizeF( hbqt_par_QSizeF( 1 )->expandedTo( *hbqt_par_QSizeF( 2 ) ) ), release_QSizeF ) ); +} + +/* + * qreal height () const + */ +HB_FUNC( QT_QSIZEF_HEIGHT ) +{ + hb_retnd( hbqt_par_QSizeF( 1 )->height() ); +} + +/* + * bool isEmpty () const + */ +HB_FUNC( QT_QSIZEF_ISEMPTY ) +{ + hb_retl( hbqt_par_QSizeF( 1 )->isEmpty() ); +} + +/* + * bool isNull () const + */ +HB_FUNC( QT_QSIZEF_ISNULL ) +{ + hb_retl( hbqt_par_QSizeF( 1 )->isNull() ); +} + +/* + * bool isValid () const + */ +HB_FUNC( QT_QSIZEF_ISVALID ) +{ + hb_retl( hbqt_par_QSizeF( 1 )->isValid() ); +} + +/* + * qreal & rheight () + */ +HB_FUNC( QT_QSIZEF_RHEIGHT ) +{ + hb_retnd( hbqt_par_QSizeF( 1 )->rheight() ); +} + +/* + * qreal & rwidth () + */ +HB_FUNC( QT_QSIZEF_RWIDTH ) +{ + hb_retnd( hbqt_par_QSizeF( 1 )->rwidth() ); +} + +/* + * void scale ( qreal width, qreal height, Qt::AspectRatioMode mode ) + */ +HB_FUNC( QT_QSIZEF_SCALE ) +{ + hbqt_par_QSizeF( 1 )->scale( hb_parnd( 2 ), hb_parnd( 3 ), ( Qt::AspectRatioMode ) hb_parni( 4 ) ); +} + +/* + * void scale ( const QSizeF & size, Qt::AspectRatioMode mode ) + */ +HB_FUNC( QT_QSIZEF_SCALE_1 ) +{ + hbqt_par_QSizeF( 1 )->scale( *hbqt_par_QSizeF( 2 ), ( Qt::AspectRatioMode ) hb_parni( 3 ) ); +} + +/* + * void setHeight ( qreal height ) + */ +HB_FUNC( QT_QSIZEF_SETHEIGHT ) +{ + hbqt_par_QSizeF( 1 )->setHeight( hb_parnd( 2 ) ); +} + +/* + * void setWidth ( qreal width ) + */ +HB_FUNC( QT_QSIZEF_SETWIDTH ) +{ + hbqt_par_QSizeF( 1 )->setWidth( hb_parnd( 2 ) ); +} + +/* + * QSize toSize () const + */ +HB_FUNC( QT_QSIZEF_TOSIZE ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QSize( hbqt_par_QSizeF( 1 )->toSize() ), release_QSize ) ); +} + +/* + * void transpose () + */ +HB_FUNC( QT_QSIZEF_TRANSPOSE ) +{ + hbqt_par_QSizeF( 1 )->transpose(); +} + +/* + * qreal width () const + */ +HB_FUNC( QT_QSIZEF_WIDTH ) +{ + hb_retnd( hbqt_par_QSizeF( 1 )->width() ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QStringList.cpp b/harbour/contrib/hbqt/qtcore/QStringList.cpp new file mode 100644 index 0000000000..f9a732931e --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QStringList.cpp @@ -0,0 +1,407 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +/* + * Constructed[ 35/42 [ 83.33% ] ] + * + * *** Unconvered Prototypes *** + * ----------------------------- + * + * QList mid ( int pos, int length = -1 ) const + * QSet toSet () const + * std::list toStdList () const + * QVector toVector () const + * + * *** Commented out protos which construct fine but do not compile *** + * + * // bool contains ( const QString & str, Qt::CaseSensitivity cs = Qt::CaseSensitive ) const + * // QStringList & replaceInStrings ( const QString & before, const QString & after, Qt::CaseSensitivity cs = Qt::CaseSensitive ) + * // QStringList & replaceInStrings ( const QRegExp & rx, const QString & after ) + */ + +#include + +#include + + +/* + * QStringList () + * QStringList ( const QString & str ) + * QStringList ( const QStringList & other ) + * QStringList ( const QList & other ) + */ + +QT_G_FUNC( release_QStringList ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QStringList" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QStringList * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QSTRINGLIST ) +{ + QGC_POINTER * p = ( QGC_POINTER * ) hb_gcAlloc( sizeof( QGC_POINTER ), Q_release ); + void * pObj = NULL; + + pObj = ( QStringList* ) new QStringList() ; + + p->ph = pObj; + p->func = release_QStringList; + + hb_retptrGC( p ); +} +/* + * void append ( const QString & value ) + */ +HB_FUNC( QT_QSTRINGLIST_APPEND ) +{ + hbqt_par_QStringList( 1 )->append( hbqt_par_QString( 2 ) ); +} + +/* + * QStringList filter ( const QString & str, Qt::CaseSensitivity cs = Qt::CaseSensitive ) const + */ +HB_FUNC( QT_QSTRINGLIST_FILTER ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QStringList( hbqt_par_QStringList( 1 )->filter( hbqt_par_QString( 2 ), ( HB_ISNUM( 3 ) ? ( Qt::CaseSensitivity ) hb_parni( 3 ) : ( Qt::CaseSensitivity ) Qt::CaseSensitive ) ) ), release_QStringList ) ); +} + +/* + * QStringList filter ( const QRegExp & rx ) const + */ +HB_FUNC( QT_QSTRINGLIST_FILTER_1 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QStringList( hbqt_par_QStringList( 1 )->filter( *hbqt_par_QRegExp( 2 ) ) ), release_QStringList ) ); +} + +/* + * int indexOf ( const QString & value, int from = 0 ) const + */ +HB_FUNC( QT_QSTRINGLIST_INDEXOF ) +{ + hb_retni( hbqt_par_QStringList( 1 )->indexOf( hbqt_par_QString( 2 ), hb_parni( 3 ) ) ); +} + +/* + * int indexOf ( const QRegExp & rx, int from = 0 ) const + */ +HB_FUNC( QT_QSTRINGLIST_INDEXOF_1 ) +{ + hb_retni( hbqt_par_QStringList( 1 )->indexOf( *hbqt_par_QRegExp( 2 ), hb_parni( 3 ) ) ); +} + +/* + * int indexOf ( QRegExp & rx, int from = 0 ) const + */ +HB_FUNC( QT_QSTRINGLIST_INDEXOF_2 ) +{ + hb_retni( hbqt_par_QStringList( 1 )->indexOf( *hbqt_par_QRegExp( 2 ), hb_parni( 3 ) ) ); +} + +/* + * QString join ( const QString & separator ) const + */ +HB_FUNC( QT_QSTRINGLIST_JOIN ) +{ + hb_retc( hbqt_par_QStringList( 1 )->join( hbqt_par_QString( 2 ) ).toAscii().data() ); +} + +/* + * int lastIndexOf ( const QRegExp & rx, int from = -1 ) const + */ +HB_FUNC( QT_QSTRINGLIST_LASTINDEXOF ) +{ + hb_retni( hbqt_par_QStringList( 1 )->lastIndexOf( *hbqt_par_QRegExp( 2 ), ( HB_ISNUM( 3 ) ? hb_parni( 3 ) : -1 ) ) ); +} + +/* + * int lastIndexOf ( const QString & value, int from = -1 ) const + */ +HB_FUNC( QT_QSTRINGLIST_LASTINDEXOF_1 ) +{ + hb_retni( hbqt_par_QStringList( 1 )->lastIndexOf( hbqt_par_QString( 2 ), ( HB_ISNUM( 3 ) ? hb_parni( 3 ) : -1 ) ) ); +} + +/* + * int lastIndexOf ( QRegExp & rx, int from = -1 ) const + */ +HB_FUNC( QT_QSTRINGLIST_LASTINDEXOF_2 ) +{ + hb_retni( hbqt_par_QStringList( 1 )->lastIndexOf( *hbqt_par_QRegExp( 2 ), ( HB_ISNUM( 3 ) ? hb_parni( 3 ) : -1 ) ) ); +} + +/* + * int removeDuplicates () + */ +HB_FUNC( QT_QSTRINGLIST_REMOVEDUPLICATES ) +{ + hb_retni( hbqt_par_QStringList( 1 )->removeDuplicates() ); +} + +/* + * void sort () + */ +HB_FUNC( QT_QSTRINGLIST_SORT ) +{ + hbqt_par_QStringList( 1 )->sort(); +} + +/* + * QString & at ( int i ) const + */ +HB_FUNC( QT_QSTRINGLIST_AT ) +{ + hb_retc( hbqt_par_QStringList( 1 )->at( hb_parni( 2 ) ).toAscii().data() ); +} + +/* + * QString & back () + */ +HB_FUNC( QT_QSTRINGLIST_BACK ) +{ + hb_retc( hbqt_par_QStringList( 1 )->back().toAscii().data() ); +} + +/* + * int count ( const QString & value ) const + */ +HB_FUNC( QT_QSTRINGLIST_COUNT ) +{ + hb_retni( hbqt_par_QStringList( 1 )->count( hbqt_par_QString( 2 ) ) ); +} + +/* + * bool endsWith ( const QString & value ) const + */ +HB_FUNC( QT_QSTRINGLIST_ENDSWITH ) +{ + hb_retl( hbqt_par_QStringList( 1 )->endsWith( hbqt_par_QString( 2 ) ) ); +} + +/* + * QString & first () + */ +HB_FUNC( QT_QSTRINGLIST_FIRST ) +{ + hb_retc( hbqt_par_QStringList( 1 )->first().toAscii().data() ); +} + +/* + * const QString & first () const + */ +HB_FUNC( QT_QSTRINGLIST_FIRST_1 ) +{ + hb_retc( hbqt_par_QStringList( 1 )->first().toAscii().data() ); +} + +/* + * QString & front () + */ +HB_FUNC( QT_QSTRINGLIST_FRONT ) +{ + hb_retc( hbqt_par_QStringList( 1 )->front().toAscii().data() ); +} + +/* + * const QString & front () const + */ +HB_FUNC( QT_QSTRINGLIST_FRONT_1 ) +{ + hb_retc( hbqt_par_QStringList( 1 )->front().toAscii().data() ); +} + +/* + * void insert ( int i, const QString & value ) + */ +HB_FUNC( QT_QSTRINGLIST_INSERT ) +{ + hbqt_par_QStringList( 1 )->insert( hb_parni( 2 ), hbqt_par_QString( 3 ) ); +} + +/* + * QString & last () + */ +HB_FUNC( QT_QSTRINGLIST_LAST ) +{ + hb_retc( hbqt_par_QStringList( 1 )->last().toAscii().data() ); +} + +/* + * const QString & last () const + */ +HB_FUNC( QT_QSTRINGLIST_LAST_1 ) +{ + hb_retc( hbqt_par_QStringList( 1 )->last().toAscii().data() ); +} + +/* + * void prepend ( const QString & value ) + */ +HB_FUNC( QT_QSTRINGLIST_PREPEND ) +{ + hbqt_par_QStringList( 1 )->prepend( hbqt_par_QString( 2 ) ); +} + +/* + * void push_back ( const QString & value ) + */ +HB_FUNC( QT_QSTRINGLIST_PUSH_BACK ) +{ + hbqt_par_QStringList( 1 )->push_back( hbqt_par_QString( 2 ) ); +} + +/* + * void push_front ( const QString & value ) + */ +HB_FUNC( QT_QSTRINGLIST_PUSH_FRONT ) +{ + hbqt_par_QStringList( 1 )->push_front( hbqt_par_QString( 2 ) ); +} + +/* + * int removeAll ( const QString & value ) + */ +HB_FUNC( QT_QSTRINGLIST_REMOVEALL ) +{ + hb_retni( hbqt_par_QStringList( 1 )->removeAll( hbqt_par_QString( 2 ) ) ); +} + +/* + * bool removeOne ( const QString & value ) + */ +HB_FUNC( QT_QSTRINGLIST_REMOVEONE ) +{ + hb_retl( hbqt_par_QStringList( 1 )->removeOne( hbqt_par_QString( 2 ) ) ); +} + +/* + * void replace ( int i, const QString & value ) + */ +HB_FUNC( QT_QSTRINGLIST_REPLACE ) +{ + hbqt_par_QStringList( 1 )->replace( hb_parni( 2 ), hbqt_par_QString( 3 ) ); +} + +/* + * bool startsWith ( const QString & value ) const + */ +HB_FUNC( QT_QSTRINGLIST_STARTSWITH ) +{ + hb_retl( hbqt_par_QStringList( 1 )->startsWith( hbqt_par_QString( 2 ) ) ); +} + +/* + * QString takeAt ( int i ) + */ +HB_FUNC( QT_QSTRINGLIST_TAKEAT ) +{ + hb_retc( hbqt_par_QStringList( 1 )->takeAt( hb_parni( 2 ) ).toAscii().data() ); +} + +/* + * QString takeFirst () + */ +HB_FUNC( QT_QSTRINGLIST_TAKEFIRST ) +{ + hb_retc( hbqt_par_QStringList( 1 )->takeFirst().toAscii().data() ); +} + +/* + * QString takeLast () + */ +HB_FUNC( QT_QSTRINGLIST_TAKELAST ) +{ + hb_retc( hbqt_par_QStringList( 1 )->takeLast().toAscii().data() ); +} + +/* + * QString value ( int i ) const + */ +HB_FUNC( QT_QSTRINGLIST_VALUE ) +{ + hb_retc( hbqt_par_QStringList( 1 )->value( hb_parni( 2 ) ).toAscii().data() ); +} + +/* + * QString value ( int i, const QString & defaultValue ) const + */ +HB_FUNC( QT_QSTRINGLIST_VALUE_1 ) +{ + hb_retc( hbqt_par_QStringList( 1 )->value( hb_parni( 2 ), hbqt_par_QString( 3 ) ).toAscii().data() ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QTextBoundaryFinder.cpp b/harbour/contrib/hbqt/qtcore/QTextBoundaryFinder.cpp new file mode 100644 index 0000000000..a62683668f --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QTextBoundaryFinder.cpp @@ -0,0 +1,200 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +/* + * flags BoundaryReasons + * enum BoundaryReason { NotAtBoundary, StartWord, EndWord } + * enum BoundaryType { Grapheme, Word, Line, Sentence } + */ + +#include + +#include + + +/* + * QTextBoundaryFinder () + * QTextBoundaryFinder ( const QTextBoundaryFinder & other ) + * QTextBoundaryFinder ( BoundaryType type, const QString & string ) + * QTextBoundaryFinder ( BoundaryType type, const QChar * chars, int length, unsigned char * buffer = 0, int bufferSize = 0 ) + * ~QTextBoundaryFinder () + */ + +QT_G_FUNC( release_QTextBoundaryFinder ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QTextBoundaryFinder" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QTextBoundaryFinder * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QTEXTBOUNDARYFINDER ) +{ + void * pObj = NULL; + + pObj = ( QTextBoundaryFinder* ) new QTextBoundaryFinder() ; + + hb_retptr( pObj ); +} +/* + * BoundaryReasons boundaryReasons () const + */ +HB_FUNC( QT_QTEXTBOUNDARYFINDER_BOUNDARYREASONS ) +{ + hb_retni( ( QTextBoundaryFinder::BoundaryReasons ) hbqt_par_QTextBoundaryFinder( 1 )->boundaryReasons() ); +} + +/* + * bool isAtBoundary () const + */ +HB_FUNC( QT_QTEXTBOUNDARYFINDER_ISATBOUNDARY ) +{ + hb_retl( hbqt_par_QTextBoundaryFinder( 1 )->isAtBoundary() ); +} + +/* + * bool isValid () const + */ +HB_FUNC( QT_QTEXTBOUNDARYFINDER_ISVALID ) +{ + hb_retl( hbqt_par_QTextBoundaryFinder( 1 )->isValid() ); +} + +/* + * int position () const + */ +HB_FUNC( QT_QTEXTBOUNDARYFINDER_POSITION ) +{ + hb_retni( hbqt_par_QTextBoundaryFinder( 1 )->position() ); +} + +/* + * void setPosition ( int position ) + */ +HB_FUNC( QT_QTEXTBOUNDARYFINDER_SETPOSITION ) +{ + hbqt_par_QTextBoundaryFinder( 1 )->setPosition( hb_parni( 2 ) ); +} + +/* + * QString string () const + */ +HB_FUNC( QT_QTEXTBOUNDARYFINDER_STRING ) +{ + hb_retc( hbqt_par_QTextBoundaryFinder( 1 )->string().toAscii().data() ); +} + +/* + * void toEnd () + */ +HB_FUNC( QT_QTEXTBOUNDARYFINDER_TOEND ) +{ + hbqt_par_QTextBoundaryFinder( 1 )->toEnd(); +} + +/* + * int toNextBoundary () + */ +HB_FUNC( QT_QTEXTBOUNDARYFINDER_TONEXTBOUNDARY ) +{ + hb_retni( hbqt_par_QTextBoundaryFinder( 1 )->toNextBoundary() ); +} + +/* + * int toPreviousBoundary () + */ +HB_FUNC( QT_QTEXTBOUNDARYFINDER_TOPREVIOUSBOUNDARY ) +{ + hb_retni( hbqt_par_QTextBoundaryFinder( 1 )->toPreviousBoundary() ); +} + +/* + * void toStart () + */ +HB_FUNC( QT_QTEXTBOUNDARYFINDER_TOSTART ) +{ + hbqt_par_QTextBoundaryFinder( 1 )->toStart(); +} + +/* + * BoundaryType type () const + */ +HB_FUNC( QT_QTEXTBOUNDARYFINDER_TYPE ) +{ + hb_retni( ( QTextBoundaryFinder::BoundaryType ) hbqt_par_QTextBoundaryFinder( 1 )->type() ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QTextCodec.cpp b/harbour/contrib/hbqt/qtcore/QTextCodec.cpp new file mode 100644 index 0000000000..c371bac138 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QTextCodec.cpp @@ -0,0 +1,268 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +/* + * enum ConversionFlag { DefaultConversion, ConvertInvalidToNull, IgnoreHeader } + * flags ConversionFlags + */ + +/* + * Constructed[ 20/23 [ 86.96% ] ] + * + * *** Unconvered Prototypes *** + * ----------------------------- + * + * virtual QList aliases () const + * + * *** Commented out protos which construct fine but do not compile *** + * + * // QByteArray fromUnicode ( const QChar * input, int number, ConverterState * state = 0 ) const + * // QString toUnicode ( const char * input, int size, ConverterState * state = 0 ) const + */ + +#include + +#include + + +/* + * + * + */ + +QT_G_FUNC( release_QTextCodec ) +{ +} + +HB_FUNC( QT_QTEXTCODEC ) +{ +} +/* + * bool canEncode ( QChar ch ) const + */ +HB_FUNC( QT_QTEXTCODEC_CANENCODE ) +{ + hb_retl( hbqt_par_QTextCodec( 1 )->canEncode( hb_parni( 2 ) ) ); +} + +/* + * bool canEncode ( const QString & s ) const + */ +HB_FUNC( QT_QTEXTCODEC_CANENCODE_1 ) +{ + hb_retl( hbqt_par_QTextCodec( 1 )->canEncode( hbqt_par_QString( 2 ) ) ); +} + +/* + * QByteArray fromUnicode ( const QString & str ) const + */ +HB_FUNC( QT_QTEXTCODEC_FROMUNICODE ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QTextCodec( 1 )->fromUnicode( hbqt_par_QString( 2 ) ) ), release_QByteArray ) ); +} + +/* + * QTextDecoder * makeDecoder () const + */ +HB_FUNC( QT_QTEXTCODEC_MAKEDECODER ) +{ + hb_retptr( ( QTextDecoder* ) hbqt_par_QTextCodec( 1 )->makeDecoder() ); +} + +/* + * QTextEncoder * makeEncoder () const + */ +HB_FUNC( QT_QTEXTCODEC_MAKEENCODER ) +{ + hb_retptr( ( QTextEncoder* ) hbqt_par_QTextCodec( 1 )->makeEncoder() ); +} + +/* + * virtual int mibEnum () const = 0 + */ +HB_FUNC( QT_QTEXTCODEC_MIBENUM ) +{ + hb_retni( hbqt_par_QTextCodec( 1 )->mibEnum() ); +} + +/* + * virtual QByteArray name () const = 0 + */ +HB_FUNC( QT_QTEXTCODEC_NAME ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QTextCodec( 1 )->name() ), release_QByteArray ) ); +} + +/* + * QString toUnicode ( const QByteArray & a ) const + */ +HB_FUNC( QT_QTEXTCODEC_TOUNICODE ) +{ + hb_retc( hbqt_par_QTextCodec( 1 )->toUnicode( *hbqt_par_QByteArray( 2 ) ).toAscii().data() ); +} + +/* + * QString toUnicode ( const char * chars ) const + */ +HB_FUNC( QT_QTEXTCODEC_TOUNICODE_1 ) +{ + hb_retc( hbqt_par_QTextCodec( 1 )->toUnicode( hbqt_par_char( 2 ) ).toAscii().data() ); +} + +/* + * QTextCodec * codecForCStrings () + */ +HB_FUNC( QT_QTEXTCODEC_CODECFORCSTRINGS ) +{ + hb_retptr( ( QTextCodec* ) hbqt_par_QTextCodec( 1 )->codecForCStrings() ); +} + +/* + * QTextCodec * codecForHtml ( const QByteArray & ba, QTextCodec * defaultCodec ) + */ +HB_FUNC( QT_QTEXTCODEC_CODECFORHTML ) +{ + hb_retptr( ( QTextCodec* ) hbqt_par_QTextCodec( 1 )->codecForHtml( *hbqt_par_QByteArray( 2 ), hbqt_par_QTextCodec( 3 ) ) ); +} + +/* + * QTextCodec * codecForHtml ( const QByteArray & ba ) + */ +HB_FUNC( QT_QTEXTCODEC_CODECFORHTML_1 ) +{ + hb_retptr( ( QTextCodec* ) hbqt_par_QTextCodec( 1 )->codecForHtml( *hbqt_par_QByteArray( 2 ) ) ); +} + +/* + * QTextCodec * codecForLocale () + */ +HB_FUNC( QT_QTEXTCODEC_CODECFORLOCALE ) +{ + hb_retptr( ( QTextCodec* ) hbqt_par_QTextCodec( 1 )->codecForLocale() ); +} + +/* + * QTextCodec * codecForMib ( int mib ) + */ +HB_FUNC( QT_QTEXTCODEC_CODECFORMIB ) +{ + hb_retptr( ( QTextCodec* ) hbqt_par_QTextCodec( 1 )->codecForMib( hb_parni( 2 ) ) ); +} + +/* + * QTextCodec * codecForName ( const QByteArray & name ) + */ +HB_FUNC( QT_QTEXTCODEC_CODECFORNAME ) +{ + hb_retptr( ( QTextCodec* ) hbqt_par_QTextCodec( 1 )->codecForName( *hbqt_par_QByteArray( 2 ) ) ); +} + +/* + * QTextCodec * codecForName ( const char * name ) + */ +HB_FUNC( QT_QTEXTCODEC_CODECFORNAME_1 ) +{ + hb_retptr( ( QTextCodec* ) hbqt_par_QTextCodec( 1 )->codecForName( hbqt_par_char( 2 ) ) ); +} + +/* + * QTextCodec * codecForTr () + */ +HB_FUNC( QT_QTEXTCODEC_CODECFORTR ) +{ + hb_retptr( ( QTextCodec* ) hbqt_par_QTextCodec( 1 )->codecForTr() ); +} + +/* + * void setCodecForCStrings ( QTextCodec * codec ) + */ +HB_FUNC( QT_QTEXTCODEC_SETCODECFORCSTRINGS ) +{ + hbqt_par_QTextCodec( 1 )->setCodecForCStrings( hbqt_par_QTextCodec( 2 ) ); +} + +/* + * void setCodecForLocale ( QTextCodec * c ) + */ +HB_FUNC( QT_QTEXTCODEC_SETCODECFORLOCALE ) +{ + hbqt_par_QTextCodec( 1 )->setCodecForLocale( hbqt_par_QTextCodec( 2 ) ); +} + +/* + * void setCodecForTr ( QTextCodec * c ) + */ +HB_FUNC( QT_QTEXTCODEC_SETCODECFORTR ) +{ + hbqt_par_QTextCodec( 1 )->setCodecForTr( hbqt_par_QTextCodec( 2 ) ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QTextDecoder.cpp b/harbour/contrib/hbqt/qtcore/QTextDecoder.cpp new file mode 100644 index 0000000000..235aee9654 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QTextDecoder.cpp @@ -0,0 +1,111 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +#include + +#include + + +/* + * QTextDecoder ( const QTextCodec * codec ) + * ~QTextDecoder () + */ + +QT_G_FUNC( release_QTextDecoder ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QTextDecoder" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QTextDecoder * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QTEXTDECODER ) +{ + void * pObj = NULL; + + pObj = ( QTextDecoder* ) new QTextDecoder( hbqt_par_QTextCodec( 1 ) ) ; + + hb_retptr( pObj ); +} +/* + * QString toUnicode ( const char * chars, int len ) + */ +HB_FUNC( QT_QTEXTDECODER_TOUNICODE ) +{ + hb_retc( hbqt_par_QTextDecoder( 1 )->toUnicode( hbqt_par_char( 2 ), hb_parni( 3 ) ).toAscii().data() ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QTextEncoder.cpp b/harbour/contrib/hbqt/qtcore/QTextEncoder.cpp new file mode 100644 index 0000000000..343decf8d6 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QTextEncoder.cpp @@ -0,0 +1,111 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +#include + +#include + + +/* + * QTextEncoder ( const QTextCodec * codec ) + * ~QTextEncoder () + */ + +QT_G_FUNC( release_QTextEncoder ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QTextEncoder" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QTextEncoder * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QTEXTENCODER ) +{ + void * pObj = NULL; + + pObj = ( QTextEncoder* ) new QTextEncoder( hbqt_par_QTextCodec( 1 ) ) ; + + hb_retptr( pObj ); +} +/* + * QByteArray fromUnicode ( const QString & str ) + */ +HB_FUNC( QT_QTEXTENCODER_FROMUNICODE ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QTextEncoder( 1 )->fromUnicode( hbqt_par_QString( 2 ) ) ), release_QByteArray ) ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QTextStream.cpp b/harbour/contrib/hbqt/qtcore/QTextStream.cpp new file mode 100644 index 0000000000..939e04c6ca --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QTextStream.cpp @@ -0,0 +1,411 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +/* + * flags NumberFlags + * enum FieldAlignment { AlignLeft, AlignRight, AlignCenter, AlignAccountingStyle } + * enum NumberFlag { ShowBase, ForcePoint, ForceSign, UppercaseBase, UppercaseDigits } + * enum RealNumberNotation { ScientificNotation, FixedNotation, SmartNotation } + * enum Status { Ok, ReadPastEnd, ReadCorruptData } + */ + +#include + +#include + + +/* + * QTextStream () + * QTextStream ( QIODevice * device ) + * QTextStream ( FILE * fileHandle, QIODevice::OpenMode openMode = QIODevice::ReadWrite ) + * QTextStream ( QString * string, QIODevice::OpenMode openMode = QIODevice::ReadWrite ) + * QTextStream ( QByteArray * array, QIODevice::OpenMode openMode = QIODevice::ReadWrite ) + * QTextStream ( const QByteArray & array, QIODevice::OpenMode openMode = QIODevice::ReadOnly ) + * virtual ~QTextStream () + */ +/* + * QChar padChar () const + */ +HB_FUNC( QT_QTEXTSTREAM_PADCHAR ) +{ + +} + +QT_G_FUNC( release_QTextStream ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QTextStream" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QTextStream * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QTEXTSTREAM ) +{ + void * pObj = NULL; + + pObj = new QTextStream( hb_parcx( 1 ), ( QIODevice::OpenMode ) ( HB_ISNUM( 2 ) ? hb_parni( 2 ) : QIODevice::ReadWrite ) ) ; + + hb_retptr( pObj ); +} +/* + * bool atEnd () const + */ +HB_FUNC( QT_QTEXTSTREAM_ATEND ) +{ + hb_retl( hbqt_par_QTextStream( 1 )->atEnd() ); +} + +/* + * bool autoDetectUnicode () const + */ +HB_FUNC( QT_QTEXTSTREAM_AUTODETECTUNICODE ) +{ + hb_retl( hbqt_par_QTextStream( 1 )->autoDetectUnicode() ); +} + +/* + * QTextCodec * codec () const + */ +HB_FUNC( QT_QTEXTSTREAM_CODEC ) +{ + hb_retptr( ( QTextCodec* ) hbqt_par_QTextStream( 1 )->codec() ); +} + +/* + * QIODevice * device () const + */ +HB_FUNC( QT_QTEXTSTREAM_DEVICE ) +{ + hb_retptr( ( QIODevice* ) hbqt_par_QTextStream( 1 )->device() ); +} + +/* + * FieldAlignment fieldAlignment () const + */ +HB_FUNC( QT_QTEXTSTREAM_FIELDALIGNMENT ) +{ + hb_retni( ( QTextStream::FieldAlignment ) hbqt_par_QTextStream( 1 )->fieldAlignment() ); +} + +/* + * int fieldWidth () const + */ +HB_FUNC( QT_QTEXTSTREAM_FIELDWIDTH ) +{ + hb_retni( hbqt_par_QTextStream( 1 )->fieldWidth() ); +} + +/* + * void flush () + */ +HB_FUNC( QT_QTEXTSTREAM_FLUSH ) +{ + hbqt_par_QTextStream( 1 )->flush(); +} + +/* + * bool generateByteOrderMark () const + */ +HB_FUNC( QT_QTEXTSTREAM_GENERATEBYTEORDERMARK ) +{ + hb_retl( hbqt_par_QTextStream( 1 )->generateByteOrderMark() ); +} + +/* + * int integerBase () const + */ +HB_FUNC( QT_QTEXTSTREAM_INTEGERBASE ) +{ + hb_retni( hbqt_par_QTextStream( 1 )->integerBase() ); +} + +/* + * QLocale locale () const + */ +HB_FUNC( QT_QTEXTSTREAM_LOCALE ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QLocale( hbqt_par_QTextStream( 1 )->locale() ), release_QLocale ) ); +} + +/* + * NumberFlags numberFlags () const + */ +HB_FUNC( QT_QTEXTSTREAM_NUMBERFLAGS ) +{ + hb_retni( ( QTextStream::NumberFlags ) hbqt_par_QTextStream( 1 )->numberFlags() ); +} + +/* + * qint64 pos () const + */ +HB_FUNC( QT_QTEXTSTREAM_POS ) +{ + hb_retnint( hbqt_par_QTextStream( 1 )->pos() ); +} + +/* + * QString read ( qint64 maxlen ) + */ +HB_FUNC( QT_QTEXTSTREAM_READ ) +{ + hb_retc( hbqt_par_QTextStream( 1 )->read( hb_parnint( 2 ) ).toAscii().data() ); +} + +/* + * QString readAll () + */ +HB_FUNC( QT_QTEXTSTREAM_READALL ) +{ + hb_retc( hbqt_par_QTextStream( 1 )->readAll().toAscii().data() ); +} + +/* + * QString readLine ( qint64 maxlen = 0 ) + */ +HB_FUNC( QT_QTEXTSTREAM_READLINE ) +{ + hb_retc( hbqt_par_QTextStream( 1 )->readLine( hb_parnint( 2 ) ).toAscii().data() ); +} + +/* + * RealNumberNotation realNumberNotation () const + */ +HB_FUNC( QT_QTEXTSTREAM_REALNUMBERNOTATION ) +{ + hb_retni( ( QTextStream::RealNumberNotation ) hbqt_par_QTextStream( 1 )->realNumberNotation() ); +} + +/* + * int realNumberPrecision () const + */ +HB_FUNC( QT_QTEXTSTREAM_REALNUMBERPRECISION ) +{ + hb_retni( hbqt_par_QTextStream( 1 )->realNumberPrecision() ); +} + +/* + * void reset () + */ +HB_FUNC( QT_QTEXTSTREAM_RESET ) +{ + hbqt_par_QTextStream( 1 )->reset(); +} + +/* + * void resetStatus () + */ +HB_FUNC( QT_QTEXTSTREAM_RESETSTATUS ) +{ + hbqt_par_QTextStream( 1 )->resetStatus(); +} + +/* + * bool seek ( qint64 pos ) + */ +HB_FUNC( QT_QTEXTSTREAM_SEEK ) +{ + hb_retl( hbqt_par_QTextStream( 1 )->seek( hb_parnint( 2 ) ) ); +} + +/* + * void setAutoDetectUnicode ( bool enabled ) + */ +HB_FUNC( QT_QTEXTSTREAM_SETAUTODETECTUNICODE ) +{ + hbqt_par_QTextStream( 1 )->setAutoDetectUnicode( hb_parl( 2 ) ); +} + +/* + * void setCodec ( QTextCodec * codec ) + */ +HB_FUNC( QT_QTEXTSTREAM_SETCODEC ) +{ + hbqt_par_QTextStream( 1 )->setCodec( hbqt_par_QTextCodec( 2 ) ); +} + +/* + * void setCodec ( const char * codecName ) + */ +HB_FUNC( QT_QTEXTSTREAM_SETCODEC_1 ) +{ + hbqt_par_QTextStream( 1 )->setCodec( hbqt_par_char( 2 ) ); +} + +/* + * void setDevice ( QIODevice * device ) + */ +HB_FUNC( QT_QTEXTSTREAM_SETDEVICE ) +{ + hbqt_par_QTextStream( 1 )->setDevice( hbqt_par_QIODevice( 2 ) ); +} + +/* + * void setFieldAlignment ( FieldAlignment mode ) + */ +HB_FUNC( QT_QTEXTSTREAM_SETFIELDALIGNMENT ) +{ + hbqt_par_QTextStream( 1 )->setFieldAlignment( ( QTextStream::FieldAlignment ) hb_parni( 2 ) ); +} + +/* + * void setFieldWidth ( int width ) + */ +HB_FUNC( QT_QTEXTSTREAM_SETFIELDWIDTH ) +{ + hbqt_par_QTextStream( 1 )->setFieldWidth( hb_parni( 2 ) ); +} + +/* + * void setGenerateByteOrderMark ( bool generate ) + */ +HB_FUNC( QT_QTEXTSTREAM_SETGENERATEBYTEORDERMARK ) +{ + hbqt_par_QTextStream( 1 )->setGenerateByteOrderMark( hb_parl( 2 ) ); +} + +/* + * void setIntegerBase ( int base ) + */ +HB_FUNC( QT_QTEXTSTREAM_SETINTEGERBASE ) +{ + hbqt_par_QTextStream( 1 )->setIntegerBase( hb_parni( 2 ) ); +} + +/* + * void setLocale ( const QLocale & locale ) + */ +HB_FUNC( QT_QTEXTSTREAM_SETLOCALE ) +{ + hbqt_par_QTextStream( 1 )->setLocale( *hbqt_par_QLocale( 2 ) ); +} + +/* + * void setNumberFlags ( NumberFlags flags ) + */ +HB_FUNC( QT_QTEXTSTREAM_SETNUMBERFLAGS ) +{ + hbqt_par_QTextStream( 1 )->setNumberFlags( ( QTextStream::NumberFlags ) hb_parni( 2 ) ); +} + +/* + * void setPadChar ( QChar ch ) + */ +HB_FUNC( QT_QTEXTSTREAM_SETPADCHAR ) +{ + hbqt_par_QTextStream( 1 )->setPadChar( hb_parni( 2 ) ); +} + +/* + * void setRealNumberNotation ( RealNumberNotation notation ) + */ +HB_FUNC( QT_QTEXTSTREAM_SETREALNUMBERNOTATION ) +{ + hbqt_par_QTextStream( 1 )->setRealNumberNotation( ( QTextStream::RealNumberNotation ) hb_parni( 2 ) ); +} + +/* + * void setRealNumberPrecision ( int precision ) + */ +HB_FUNC( QT_QTEXTSTREAM_SETREALNUMBERPRECISION ) +{ + hbqt_par_QTextStream( 1 )->setRealNumberPrecision( hb_parni( 2 ) ); +} + +/* + * void setStatus ( Status status ) + */ +HB_FUNC( QT_QTEXTSTREAM_SETSTATUS ) +{ + hbqt_par_QTextStream( 1 )->setStatus( ( QTextStream::Status ) hb_parni( 2 ) ); +} + +/* + * void skipWhiteSpace () + */ +HB_FUNC( QT_QTEXTSTREAM_SKIPWHITESPACE ) +{ + hbqt_par_QTextStream( 1 )->skipWhiteSpace(); +} + +/* + * Status status () const + */ +HB_FUNC( QT_QTEXTSTREAM_STATUS ) +{ + hb_retni( ( QTextStream::Status ) hbqt_par_QTextStream( 1 )->status() ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QThread.cpp b/harbour/contrib/hbqt/qtcore/QThread.cpp new file mode 100644 index 0000000000..6fa3ef9c4d --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QThread.cpp @@ -0,0 +1,232 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +/* + * enum Priority { IdlePriority, LowestPriority, LowPriority, NormalPriority, ..., InheritPriority } + */ + +#include + +#include + + +/* QThread ( QObject * parent = 0 ) + * ~QThread () + */ + +QT_G_FUNC( release_QThread ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QThread" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + const QMetaObject * m = ( ( QObject * ) ph )->metaObject(); + if( ( QString ) m->className() != ( QString ) "QObject" ) + { + delete ( ( QThread * ) ph ); + ph = NULL; + } + else + { +#if defined(__debug__) + hb_snprintf( str, sizeof(str), " Object Name Missing: QThread" ); OutputDebugString( str ); +#endif + } + } +} + +HB_FUNC( QT_QTHREAD ) +{ + QGC_POINTER * p = ( QGC_POINTER * ) hb_gcAlloc( sizeof( QGC_POINTER ), Q_release ); + QPointer< QThread > pObj = NULL; + + pObj = new QThread() ; + + p->ph = pObj; + p->func = release_QThread; + + hb_retptrGC( p ); +} +/* + * void exit ( int returnCode = 0 ) + */ +HB_FUNC( QT_QTHREAD_EXIT ) +{ + hbqt_par_QThread( 1 )->exit( hb_parni( 2 ) ); +} + +/* + * bool isFinished () const + */ +HB_FUNC( QT_QTHREAD_ISFINISHED ) +{ + hb_retl( hbqt_par_QThread( 1 )->isFinished() ); +} + +/* + * bool isRunning () const + */ +HB_FUNC( QT_QTHREAD_ISRUNNING ) +{ + hb_retl( hbqt_par_QThread( 1 )->isRunning() ); +} + +/* + * Priority priority () const + */ +HB_FUNC( QT_QTHREAD_PRIORITY ) +{ + hb_retni( ( QThread::Priority ) hbqt_par_QThread( 1 )->priority() ); +} + +/* + * void setPriority ( Priority priority ) + */ +HB_FUNC( QT_QTHREAD_SETPRIORITY ) +{ + hbqt_par_QThread( 1 )->setPriority( ( QThread::Priority ) hb_parni( 2 ) ); +} + +/* + * void setStackSize ( uint stackSize ) + */ +HB_FUNC( QT_QTHREAD_SETSTACKSIZE ) +{ + hbqt_par_QThread( 1 )->setStackSize( hb_parni( 2 ) ); +} + +/* + * uint stackSize () const + */ +HB_FUNC( QT_QTHREAD_STACKSIZE ) +{ + hb_retni( hbqt_par_QThread( 1 )->stackSize() ); +} + +/* + * bool wait ( unsigned long time = ULONG_MAX ) + */ +HB_FUNC( QT_QTHREAD_WAIT ) +{ + hb_retl( hbqt_par_QThread( 1 )->wait() ); +} + +/* + * QThread * currentThread () + */ +HB_FUNC( QT_QTHREAD_CURRENTTHREAD ) +{ + hb_retptr( ( QThread* ) hbqt_par_QThread( 1 )->currentThread() ); +} + +/* + * int idealThreadCount () + */ +HB_FUNC( QT_QTHREAD_IDEALTHREADCOUNT ) +{ + hb_retni( hbqt_par_QThread( 1 )->idealThreadCount() ); +} + +/* + * void yieldCurrentThread () + */ +HB_FUNC( QT_QTHREAD_YIELDCURRENTTHREAD ) +{ + hbqt_par_QThread( 1 )->yieldCurrentThread(); +} + +/* + * void quit () + */ +HB_FUNC( QT_QTHREAD_QUIT ) +{ + hbqt_par_QThread( 1 )->quit(); +} + +/* + * void start ( Priority priority = InheritPriority ) + */ +HB_FUNC( QT_QTHREAD_START ) +{ + hbqt_par_QThread( 1 )->start( ( HB_ISNUM( 2 ) ? ( QThread::Priority ) hb_parni( 2 ) : ( QThread::Priority ) QThread::InheritPriority ) ); +} + +/* + * void terminate () + */ +HB_FUNC( QT_QTHREAD_TERMINATE ) +{ + hbqt_par_QThread( 1 )->terminate(); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QTime.cpp b/harbour/contrib/hbqt/qtcore/QTime.cpp new file mode 100644 index 0000000000..b82c1d5953 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QTime.cpp @@ -0,0 +1,266 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +#include + +#include + + +/* QTime () + * QTime ( int h, int m, int s = 0, int ms = 0 ) + */ + +QT_G_FUNC( release_QTime ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QTime" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QTime * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QTIME ) +{ + QGC_POINTER * p = ( QGC_POINTER * ) hb_gcAlloc( sizeof( QGC_POINTER ), Q_release ); + void * pObj = NULL; + + pObj = new QTime() ; + + p->ph = pObj; + p->func = release_QTime; + + hb_retptrGC( p ); +} +/* + * QTime addMSecs ( int ms ) const + */ +HB_FUNC( QT_QTIME_ADDMSECS ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QTime( hbqt_par_QTime( 1 )->addMSecs( hb_parni( 2 ) ) ), release_QTime ) ); +} + +/* + * QTime addSecs ( int s ) const + */ +HB_FUNC( QT_QTIME_ADDSECS ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QTime( hbqt_par_QTime( 1 )->addSecs( hb_parni( 2 ) ) ), release_QTime ) ); +} + +/* + * int elapsed () const + */ +HB_FUNC( QT_QTIME_ELAPSED ) +{ + hb_retni( hbqt_par_QTime( 1 )->elapsed() ); +} + +/* + * int hour () const + */ +HB_FUNC( QT_QTIME_HOUR ) +{ + hb_retni( hbqt_par_QTime( 1 )->hour() ); +} + +/* + * bool isNull () const + */ +HB_FUNC( QT_QTIME_ISNULL ) +{ + hb_retl( hbqt_par_QTime( 1 )->isNull() ); +} + +/* + * bool isValid () const + */ +HB_FUNC( QT_QTIME_ISVALID ) +{ + hb_retl( hbqt_par_QTime( 1 )->isValid() ); +} + +/* + * int minute () const + */ +HB_FUNC( QT_QTIME_MINUTE ) +{ + hb_retni( hbqt_par_QTime( 1 )->minute() ); +} + +/* + * int msec () const + */ +HB_FUNC( QT_QTIME_MSEC ) +{ + hb_retni( hbqt_par_QTime( 1 )->msec() ); +} + +/* + * int msecsTo ( const QTime & t ) const + */ +HB_FUNC( QT_QTIME_MSECSTO ) +{ + hb_retni( hbqt_par_QTime( 1 )->msecsTo( *hbqt_par_QTime( 2 ) ) ); +} + +/* + * int restart () + */ +HB_FUNC( QT_QTIME_RESTART ) +{ + hb_retni( hbqt_par_QTime( 1 )->restart() ); +} + +/* + * int second () const + */ +HB_FUNC( QT_QTIME_SECOND ) +{ + hb_retni( hbqt_par_QTime( 1 )->second() ); +} + +/* + * int secsTo ( const QTime & t ) const + */ +HB_FUNC( QT_QTIME_SECSTO ) +{ + hb_retni( hbqt_par_QTime( 1 )->secsTo( *hbqt_par_QTime( 2 ) ) ); +} + +/* + * bool setHMS ( int h, int m, int s, int ms = 0 ) + */ +HB_FUNC( QT_QTIME_SETHMS ) +{ + hb_retl( hbqt_par_QTime( 1 )->setHMS( hb_parni( 2 ), hb_parni( 3 ), hb_parni( 4 ), hb_parni( 5 ) ) ); +} + +/* + * void start () + */ +HB_FUNC( QT_QTIME_START ) +{ + hbqt_par_QTime( 1 )->start(); +} + +/* + * QString toString ( const QString & format ) const + */ +HB_FUNC( QT_QTIME_TOSTRING ) +{ + hb_retc( hbqt_par_QTime( 1 )->toString( hbqt_par_QString( 2 ) ).toAscii().data() ); +} + +/* + * QString toString ( Qt::DateFormat format = Qt::TextDate ) const + */ +HB_FUNC( QT_QTIME_TOSTRING_1 ) +{ + hb_retc( hbqt_par_QTime( 1 )->toString( ( HB_ISNUM( 2 ) ? ( Qt::DateFormat ) hb_parni( 2 ) : ( Qt::DateFormat ) Qt::TextDate ) ).toAscii().data() ); +} + +/* + * QTime currentTime () + */ +HB_FUNC( QT_QTIME_CURRENTTIME ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QTime( hbqt_par_QTime( 1 )->currentTime() ), release_QTime ) ); +} + +/* + * QTime fromString ( const QString & string, Qt::DateFormat format = Qt::TextDate ) + */ +HB_FUNC( QT_QTIME_FROMSTRING ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QTime( hbqt_par_QTime( 1 )->fromString( hbqt_par_QString( 2 ), ( HB_ISNUM( 3 ) ? ( Qt::DateFormat ) hb_parni( 3 ) : ( Qt::DateFormat ) Qt::TextDate ) ) ), release_QTime ) ); +} + +/* + * QTime fromString ( const QString & string, const QString & format ) + */ +HB_FUNC( QT_QTIME_FROMSTRING_1 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QTime( hbqt_par_QTime( 1 )->fromString( hbqt_par_QString( 2 ), hbqt_par_QString( 3 ) ) ), release_QTime ) ); +} + +/* + * bool isValid ( int h, int m, int s, int ms = 0 ) + */ +HB_FUNC( QT_QTIME_ISVALID_1 ) +{ + hb_retl( hbqt_par_QTime( 1 )->isValid( hb_parni( 2 ), hb_parni( 3 ), hb_parni( 4 ), hb_parni( 5 ) ) ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QTimer.cpp b/harbour/contrib/hbqt/qtcore/QTimer.cpp new file mode 100644 index 0000000000..100916b247 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QTimer.cpp @@ -0,0 +1,197 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +#include + +#include + + +/* + * QTimer ( QObject * parent = 0 ) + * ~QTimer () + */ + +QT_G_FUNC( release_QTimer ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QTimer" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + const QMetaObject * m = ( ( QObject * ) ph )->metaObject(); + if( ( QString ) m->className() != ( QString ) "QObject" ) + { + delete ( ( QTimer * ) ph ); + ph = NULL; + } + else + { +#if defined(__debug__) + hb_snprintf( str, sizeof(str), " Object Name Missing: QTimer" ); OutputDebugString( str ); +#endif + } + } +} + +HB_FUNC( QT_QTIMER ) +{ + QGC_POINTER * p = ( QGC_POINTER * ) hb_gcAlloc( sizeof( QGC_POINTER ), Q_release ); + QPointer< QTimer > pObj = NULL; + + pObj = new QTimer( hbqt_par_QObject( 1 ) ) ; + + p->ph = pObj; + p->func = release_QTimer; + + hb_retptrGC( p ); +} +/* + * int interval () const + */ +HB_FUNC( QT_QTIMER_INTERVAL ) +{ + hb_retni( hbqt_par_QTimer( 1 )->interval() ); +} + +/* + * bool isActive () const + */ +HB_FUNC( QT_QTIMER_ISACTIVE ) +{ + hb_retl( hbqt_par_QTimer( 1 )->isActive() ); +} + +/* + * bool isSingleShot () const + */ +HB_FUNC( QT_QTIMER_ISSINGLESHOT ) +{ + hb_retl( hbqt_par_QTimer( 1 )->isSingleShot() ); +} + +/* + * void setInterval ( int msec ) + */ +HB_FUNC( QT_QTIMER_SETINTERVAL ) +{ + hbqt_par_QTimer( 1 )->setInterval( hb_parni( 2 ) ); +} + +/* + * void setSingleShot ( bool singleShot ) + */ +HB_FUNC( QT_QTIMER_SETSINGLESHOT ) +{ + hbqt_par_QTimer( 1 )->setSingleShot( hb_parl( 2 ) ); +} + +/* + * int timerId () const + */ +HB_FUNC( QT_QTIMER_TIMERID ) +{ + hb_retni( hbqt_par_QTimer( 1 )->timerId() ); +} + +/* + * void singleShot ( int msec, QObject * receiver, const char * member ) + */ +HB_FUNC( QT_QTIMER_SINGLESHOT ) +{ + hbqt_par_QTimer( 1 )->singleShot( hb_parni( 2 ), hbqt_par_QObject( 3 ), hbqt_par_char( 4 ) ); +} + +/* + * void start () + */ +HB_FUNC( QT_QTIMER_START ) +{ + hbqt_par_QTimer( 1 )->start(); +} + +/* + * void stop () + */ +HB_FUNC( QT_QTIMER_STOP ) +{ + hbqt_par_QTimer( 1 )->stop(); +} + +/* + * void start ( int msec ) + */ +HB_FUNC( QT_QTIMER_START_1 ) +{ + hbqt_par_QTimer( 1 )->start( hb_parni( 2 ) ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QTranslator.cpp b/harbour/contrib/hbqt/qtcore/QTranslator.cpp new file mode 100644 index 0000000000..0075f9090f --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QTranslator.cpp @@ -0,0 +1,148 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +#include + +#include + + +/* QTranslator ( QObject * parent = 0 ) + * ~QTranslator () + */ + +QT_G_FUNC( release_QTranslator ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QTranslator" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + const QMetaObject * m = ( ( QObject * ) ph )->metaObject(); + if( ( QString ) m->className() != ( QString ) "QObject" ) + { + delete ( ( QTranslator * ) ph ); + ph = NULL; + } + else + { +#if defined(__debug__) + hb_snprintf( str, sizeof(str), " Object Name Missing: QTranslator" ); OutputDebugString( str ); +#endif + } + } +} + +HB_FUNC( QT_QTRANSLATOR ) +{ + QGC_POINTER * p = ( QGC_POINTER * ) hb_gcAlloc( sizeof( QGC_POINTER ), Q_release ); + QPointer< QTranslator > pObj = NULL; + + pObj = new QTranslator() ; + + p->ph = pObj; + p->func = release_QTranslator; + + hb_retptrGC( p ); +} +/* + * virtual bool isEmpty () const + */ +HB_FUNC( QT_QTRANSLATOR_ISEMPTY ) +{ + hb_retl( hbqt_par_QTranslator( 1 )->isEmpty() ); +} + +/* + * bool load ( const QString & filename, const QString & directory = QString(), const QString & search_delimiters = QString(), const QString & suffix = QString() ) + */ +HB_FUNC( QT_QTRANSLATOR_LOAD ) +{ + hb_retl( hbqt_par_QTranslator( 1 )->load( hbqt_par_QString( 2 ), hbqt_par_QString( 3 ), hbqt_par_QString( 4 ), hbqt_par_QString( 5 ) ) ); +} + +/* + * virtual QString translate ( const char * context, const char * sourceText, const char * disambiguation = 0 ) const + */ +HB_FUNC( QT_QTRANSLATOR_TRANSLATE ) +{ + hb_retc( hbqt_par_QTranslator( 1 )->translate( hbqt_par_char( 2 ), hbqt_par_char( 3 ), hbqt_par_char( 4 ) ).toAscii().data() ); +} + +/* + * QString translate ( const char * context, const char * sourceText, const char * disambiguation, int n ) const + */ +HB_FUNC( QT_QTRANSLATOR_TRANSLATE_1 ) +{ + hb_retc( hbqt_par_QTranslator( 1 )->translate( hbqt_par_char( 2 ), hbqt_par_char( 3 ), hbqt_par_char( 4 ), hb_parni( 5 ) ).toAscii().data() ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QUrl.cpp b/harbour/contrib/hbqt/qtcore/QUrl.cpp new file mode 100644 index 0000000000..44b6913ca5 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QUrl.cpp @@ -0,0 +1,693 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +/* + * enum FormattingOption { None, RemoveScheme, RemovePassword, RemoveUserInfo, ..., StripTrailingSlash } + * flags FormattingOptions + * enum ParsingMode { TolerantMode, StrictMode } + */ + +/* + * Constructed[ 69/75 [ 92.00% ] ] + * + * *** Unconvered Prototypes *** + * ----------------------------- + * + * QList allEncodedQueryItemValues ( const QByteArray & key ) const + * QList > encodedQueryItems () const + * QList > queryItems () const + * void setEncodedQueryItems ( const QList > & query ) + * void setQueryItems ( const QList > & query ) + * + * *** Commented out protos which construct fine but do not compile *** + * + * //void setQueryDelimiters ( char valueDelimiter, char pairDelimiter ) + */ + +#include + +#include +#include + + +/* + * QUrl () + * QUrl ( const QString & url ) + * QUrl ( const QUrl & other ) + * QUrl ( const QString & url, ParsingMode parsingMode ) + * ~QUrl () + */ +/* + * void setQueryDelimiters ( char valueDelimiter, char pairDelimiter ) + */ +HB_FUNC( QT_QURL_SETQUERYDELIMITERS ) +{ + hbqt_par_QUrl( 1 )->setQueryDelimiters( ( char ) hb_parni( 2 ), ( char ) hb_parni( 3 ) ); +} + +QT_G_FUNC( release_QUrl ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QUrl" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QUrl * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QURL ) +{ + QGC_POINTER * p = ( QGC_POINTER * ) hb_gcAlloc( sizeof( QGC_POINTER ), Q_release ); + void * pObj = NULL; + + pObj = new QUrl( hbqt_par_QString( 1 ) ) ; + + p->ph = pObj; + p->func = release_QUrl; + + hb_retptrGC( p ); +} +/* + * void addEncodedQueryItem ( const QByteArray & key, const QByteArray & value ) + */ +HB_FUNC( QT_QURL_ADDENCODEDQUERYITEM ) +{ + hbqt_par_QUrl( 1 )->addEncodedQueryItem( *hbqt_par_QByteArray( 2 ), *hbqt_par_QByteArray( 3 ) ); +} + +/* + * void addQueryItem ( const QString & key, const QString & value ) + */ +HB_FUNC( QT_QURL_ADDQUERYITEM ) +{ + hbqt_par_QUrl( 1 )->addQueryItem( hbqt_par_QString( 2 ), hbqt_par_QString( 3 ) ); +} + +/* + * QStringList allQueryItemValues ( const QString & key ) const + */ +HB_FUNC( QT_QURL_ALLQUERYITEMVALUES ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QStringList( hbqt_par_QUrl( 1 )->allQueryItemValues( hbqt_par_QString( 2 ) ) ), release_QStringList ) ); +} + +/* + * QString authority () const + */ +HB_FUNC( QT_QURL_AUTHORITY ) +{ + hb_retc( hbqt_par_QUrl( 1 )->authority().toAscii().data() ); +} + +/* + * void clear () + */ +HB_FUNC( QT_QURL_CLEAR ) +{ + hbqt_par_QUrl( 1 )->clear(); +} + +/* + * QByteArray encodedFragment () const + */ +HB_FUNC( QT_QURL_ENCODEDFRAGMENT ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QUrl( 1 )->encodedFragment() ), release_QByteArray ) ); +} + +/* + * QByteArray encodedHost () const + */ +HB_FUNC( QT_QURL_ENCODEDHOST ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QUrl( 1 )->encodedHost() ), release_QByteArray ) ); +} + +/* + * QByteArray encodedPassword () const + */ +HB_FUNC( QT_QURL_ENCODEDPASSWORD ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QUrl( 1 )->encodedPassword() ), release_QByteArray ) ); +} + +/* + * QByteArray encodedPath () const + */ +HB_FUNC( QT_QURL_ENCODEDPATH ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QUrl( 1 )->encodedPath() ), release_QByteArray ) ); +} + +/* + * QByteArray encodedQuery () const + */ +HB_FUNC( QT_QURL_ENCODEDQUERY ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QUrl( 1 )->encodedQuery() ), release_QByteArray ) ); +} + +/* + * QByteArray encodedQueryItemValue ( const QByteArray & key ) const + */ +HB_FUNC( QT_QURL_ENCODEDQUERYITEMVALUE ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QUrl( 1 )->encodedQueryItemValue( *hbqt_par_QByteArray( 2 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray encodedUserName () const + */ +HB_FUNC( QT_QURL_ENCODEDUSERNAME ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QUrl( 1 )->encodedUserName() ), release_QByteArray ) ); +} + +/* + * QString errorString () const + */ +HB_FUNC( QT_QURL_ERRORSTRING ) +{ + hb_retc( hbqt_par_QUrl( 1 )->errorString().toAscii().data() ); +} + +/* + * QString fragment () const + */ +HB_FUNC( QT_QURL_FRAGMENT ) +{ + hb_retc( hbqt_par_QUrl( 1 )->fragment().toAscii().data() ); +} + +/* + * bool hasEncodedQueryItem ( const QByteArray & key ) const + */ +HB_FUNC( QT_QURL_HASENCODEDQUERYITEM ) +{ + hb_retl( hbqt_par_QUrl( 1 )->hasEncodedQueryItem( *hbqt_par_QByteArray( 2 ) ) ); +} + +/* + * bool hasFragment () const + */ +HB_FUNC( QT_QURL_HASFRAGMENT ) +{ + hb_retl( hbqt_par_QUrl( 1 )->hasFragment() ); +} + +/* + * bool hasQuery () const + */ +HB_FUNC( QT_QURL_HASQUERY ) +{ + hb_retl( hbqt_par_QUrl( 1 )->hasQuery() ); +} + +/* + * bool hasQueryItem ( const QString & key ) const + */ +HB_FUNC( QT_QURL_HASQUERYITEM ) +{ + hb_retl( hbqt_par_QUrl( 1 )->hasQueryItem( hbqt_par_QString( 2 ) ) ); +} + +/* + * QString host () const + */ +HB_FUNC( QT_QURL_HOST ) +{ + hb_retc( hbqt_par_QUrl( 1 )->host().toAscii().data() ); +} + +/* + * bool isEmpty () const + */ +HB_FUNC( QT_QURL_ISEMPTY ) +{ + hb_retl( hbqt_par_QUrl( 1 )->isEmpty() ); +} + +/* + * bool isParentOf ( const QUrl & childUrl ) const + */ +HB_FUNC( QT_QURL_ISPARENTOF ) +{ + hb_retl( hbqt_par_QUrl( 1 )->isParentOf( *hbqt_par_QUrl( 2 ) ) ); +} + +/* + * bool isRelative () const + */ +HB_FUNC( QT_QURL_ISRELATIVE ) +{ + hb_retl( hbqt_par_QUrl( 1 )->isRelative() ); +} + +/* + * bool isValid () const + */ +HB_FUNC( QT_QURL_ISVALID ) +{ + hb_retl( hbqt_par_QUrl( 1 )->isValid() ); +} + +/* + * QString password () const + */ +HB_FUNC( QT_QURL_PASSWORD ) +{ + hb_retc( hbqt_par_QUrl( 1 )->password().toAscii().data() ); +} + +/* + * QString path () const + */ +HB_FUNC( QT_QURL_PATH ) +{ + hb_retc( hbqt_par_QUrl( 1 )->path().toAscii().data() ); +} + +/* + * int port () const + */ +HB_FUNC( QT_QURL_PORT ) +{ + hb_retni( hbqt_par_QUrl( 1 )->port() ); +} + +/* + * int port ( int defaultPort ) const + */ +HB_FUNC( QT_QURL_PORT_1 ) +{ + hb_retni( hbqt_par_QUrl( 1 )->port( hb_parni( 2 ) ) ); +} + +/* + * QString queryItemValue ( const QString & key ) const + */ +HB_FUNC( QT_QURL_QUERYITEMVALUE ) +{ + hb_retc( hbqt_par_QUrl( 1 )->queryItemValue( hbqt_par_QString( 2 ) ).toAscii().data() ); +} + +/* + * char queryPairDelimiter () const + */ +HB_FUNC( QT_QURL_QUERYPAIRDELIMITER ) +{ + hb_retni( hbqt_par_QUrl( 1 )->queryPairDelimiter() ); +} + +/* + * char queryValueDelimiter () const + */ +HB_FUNC( QT_QURL_QUERYVALUEDELIMITER ) +{ + hb_retni( hbqt_par_QUrl( 1 )->queryValueDelimiter() ); +} + +/* + * void removeAllEncodedQueryItems ( const QByteArray & key ) + */ +HB_FUNC( QT_QURL_REMOVEALLENCODEDQUERYITEMS ) +{ + hbqt_par_QUrl( 1 )->removeAllEncodedQueryItems( *hbqt_par_QByteArray( 2 ) ); +} + +/* + * void removeAllQueryItems ( const QString & key ) + */ +HB_FUNC( QT_QURL_REMOVEALLQUERYITEMS ) +{ + hbqt_par_QUrl( 1 )->removeAllQueryItems( hbqt_par_QString( 2 ) ); +} + +/* + * void removeEncodedQueryItem ( const QByteArray & key ) + */ +HB_FUNC( QT_QURL_REMOVEENCODEDQUERYITEM ) +{ + hbqt_par_QUrl( 1 )->removeEncodedQueryItem( *hbqt_par_QByteArray( 2 ) ); +} + +/* + * void removeQueryItem ( const QString & key ) + */ +HB_FUNC( QT_QURL_REMOVEQUERYITEM ) +{ + hbqt_par_QUrl( 1 )->removeQueryItem( hbqt_par_QString( 2 ) ); +} + +/* + * QUrl resolved ( const QUrl & relative ) const + */ +HB_FUNC( QT_QURL_RESOLVED ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QUrl( hbqt_par_QUrl( 1 )->resolved( *hbqt_par_QUrl( 2 ) ) ), release_QUrl ) ); +} + +/* + * QString scheme () const + */ +HB_FUNC( QT_QURL_SCHEME ) +{ + hb_retc( hbqt_par_QUrl( 1 )->scheme().toAscii().data() ); +} + +/* + * void setAuthority ( const QString & authority ) + */ +HB_FUNC( QT_QURL_SETAUTHORITY ) +{ + hbqt_par_QUrl( 1 )->setAuthority( hbqt_par_QString( 2 ) ); +} + +/* + * void setEncodedFragment ( const QByteArray & fragment ) + */ +HB_FUNC( QT_QURL_SETENCODEDFRAGMENT ) +{ + hbqt_par_QUrl( 1 )->setEncodedFragment( *hbqt_par_QByteArray( 2 ) ); +} + +/* + * void setEncodedHost ( const QByteArray & host ) + */ +HB_FUNC( QT_QURL_SETENCODEDHOST ) +{ + hbqt_par_QUrl( 1 )->setEncodedHost( *hbqt_par_QByteArray( 2 ) ); +} + +/* + * void setEncodedPassword ( const QByteArray & password ) + */ +HB_FUNC( QT_QURL_SETENCODEDPASSWORD ) +{ + hbqt_par_QUrl( 1 )->setEncodedPassword( *hbqt_par_QByteArray( 2 ) ); +} + +/* + * void setEncodedPath ( const QByteArray & path ) + */ +HB_FUNC( QT_QURL_SETENCODEDPATH ) +{ + hbqt_par_QUrl( 1 )->setEncodedPath( *hbqt_par_QByteArray( 2 ) ); +} + +/* + * void setEncodedQuery ( const QByteArray & query ) + */ +HB_FUNC( QT_QURL_SETENCODEDQUERY ) +{ + hbqt_par_QUrl( 1 )->setEncodedQuery( *hbqt_par_QByteArray( 2 ) ); +} + +/* + * void setEncodedUrl ( const QByteArray & encodedUrl ) + */ +HB_FUNC( QT_QURL_SETENCODEDURL ) +{ + hbqt_par_QUrl( 1 )->setEncodedUrl( *hbqt_par_QByteArray( 2 ) ); +} + +/* + * void setEncodedUrl ( const QByteArray & encodedUrl, ParsingMode parsingMode ) + */ +HB_FUNC( QT_QURL_SETENCODEDURL_1 ) +{ + hbqt_par_QUrl( 1 )->setEncodedUrl( *hbqt_par_QByteArray( 2 ), ( QUrl::ParsingMode ) hb_parni( 3 ) ); +} + +/* + * void setEncodedUserName ( const QByteArray & userName ) + */ +HB_FUNC( QT_QURL_SETENCODEDUSERNAME ) +{ + hbqt_par_QUrl( 1 )->setEncodedUserName( *hbqt_par_QByteArray( 2 ) ); +} + +/* + * void setFragment ( const QString & fragment ) + */ +HB_FUNC( QT_QURL_SETFRAGMENT ) +{ + hbqt_par_QUrl( 1 )->setFragment( hbqt_par_QString( 2 ) ); +} + +/* + * void setHost ( const QString & host ) + */ +HB_FUNC( QT_QURL_SETHOST ) +{ + hbqt_par_QUrl( 1 )->setHost( hbqt_par_QString( 2 ) ); +} + +/* + * void setPassword ( const QString & password ) + */ +HB_FUNC( QT_QURL_SETPASSWORD ) +{ + hbqt_par_QUrl( 1 )->setPassword( hbqt_par_QString( 2 ) ); +} + +/* + * void setPath ( const QString & path ) + */ +HB_FUNC( QT_QURL_SETPATH ) +{ + hbqt_par_QUrl( 1 )->setPath( hbqt_par_QString( 2 ) ); +} + +/* + * void setPort ( int port ) + */ +HB_FUNC( QT_QURL_SETPORT ) +{ + hbqt_par_QUrl( 1 )->setPort( hb_parni( 2 ) ); +} + +/* + * void setScheme ( const QString & scheme ) + */ +HB_FUNC( QT_QURL_SETSCHEME ) +{ + hbqt_par_QUrl( 1 )->setScheme( hbqt_par_QString( 2 ) ); +} + +/* + * void setUrl ( const QString & url ) + */ +HB_FUNC( QT_QURL_SETURL ) +{ + hbqt_par_QUrl( 1 )->setUrl( hbqt_par_QString( 2 ) ); +} + +/* + * void setUrl ( const QString & url, ParsingMode parsingMode ) + */ +HB_FUNC( QT_QURL_SETURL_1 ) +{ + hbqt_par_QUrl( 1 )->setUrl( hbqt_par_QString( 2 ), ( QUrl::ParsingMode ) hb_parni( 3 ) ); +} + +/* + * void setUserInfo ( const QString & userInfo ) + */ +HB_FUNC( QT_QURL_SETUSERINFO ) +{ + hbqt_par_QUrl( 1 )->setUserInfo( hbqt_par_QString( 2 ) ); +} + +/* + * void setUserName ( const QString & userName ) + */ +HB_FUNC( QT_QURL_SETUSERNAME ) +{ + hbqt_par_QUrl( 1 )->setUserName( hbqt_par_QString( 2 ) ); +} + +/* + * QByteArray toEncoded ( FormattingOptions options = None ) const + */ +HB_FUNC( QT_QURL_TOENCODED ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QUrl( 1 )->toEncoded( ( HB_ISNUM( 2 ) ? ( QUrl::FormattingOptions ) hb_parni( 2 ) : ( QUrl::FormattingOptions ) QUrl::None ) ) ), release_QByteArray ) ); +} + +/* + * QString toLocalFile () const + */ +HB_FUNC( QT_QURL_TOLOCALFILE ) +{ + hb_retc( hbqt_par_QUrl( 1 )->toLocalFile().toAscii().data() ); +} + +/* + * QString toString ( FormattingOptions options = None ) const + */ +HB_FUNC( QT_QURL_TOSTRING ) +{ + hb_retc( hbqt_par_QUrl( 1 )->toString( ( HB_ISNUM( 2 ) ? ( QUrl::FormattingOptions ) hb_parni( 2 ) : ( QUrl::FormattingOptions ) QUrl::None ) ).toAscii().data() ); +} + +/* + * QString userInfo () const + */ +HB_FUNC( QT_QURL_USERINFO ) +{ + hb_retc( hbqt_par_QUrl( 1 )->userInfo().toAscii().data() ); +} + +/* + * QString userName () const + */ +HB_FUNC( QT_QURL_USERNAME ) +{ + hb_retc( hbqt_par_QUrl( 1 )->userName().toAscii().data() ); +} + +/* + * QString fromAce ( const QByteArray & domain ) + */ +HB_FUNC( QT_QURL_FROMACE ) +{ + hb_retc( hbqt_par_QUrl( 1 )->fromAce( *hbqt_par_QByteArray( 2 ) ).toAscii().data() ); +} + +/* + * QUrl fromEncoded ( const QByteArray & input ) + */ +HB_FUNC( QT_QURL_FROMENCODED ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QUrl( hbqt_par_QUrl( 1 )->fromEncoded( *hbqt_par_QByteArray( 2 ) ) ), release_QUrl ) ); +} + +/* + * QUrl fromEncoded ( const QByteArray & input, ParsingMode parsingMode ) + */ +HB_FUNC( QT_QURL_FROMENCODED_1 ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QUrl( hbqt_par_QUrl( 1 )->fromEncoded( *hbqt_par_QByteArray( 2 ), ( QUrl::ParsingMode ) hb_parni( 3 ) ) ), release_QUrl ) ); +} + +/* + * QUrl fromLocalFile ( const QString & localFile ) + */ +HB_FUNC( QT_QURL_FROMLOCALFILE ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QUrl( hbqt_par_QUrl( 1 )->fromLocalFile( hbqt_par_QString( 2 ) ) ), release_QUrl ) ); +} + +/* + * QString fromPercentEncoding ( const QByteArray & input ) + */ +HB_FUNC( QT_QURL_FROMPERCENTENCODING ) +{ + hb_retc( hbqt_par_QUrl( 1 )->fromPercentEncoding( *hbqt_par_QByteArray( 2 ) ).toAscii().data() ); +} + +/* + * QStringList idnWhitelist () + */ +HB_FUNC( QT_QURL_IDNWHITELIST ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QStringList( hbqt_par_QUrl( 1 )->idnWhitelist() ), release_QStringList ) ); +} + +/* + * void setIdnWhitelist ( const QStringList & list ) + */ +HB_FUNC( QT_QURL_SETIDNWHITELIST ) +{ + hbqt_par_QUrl( 1 )->setIdnWhitelist( *hbqt_par_QStringList( 2 ) ); +} + +/* + * QByteArray toAce ( const QString & domain ) + */ +HB_FUNC( QT_QURL_TOACE ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QUrl( 1 )->toAce( hbqt_par_QString( 2 ) ) ), release_QByteArray ) ); +} + +/* + * QByteArray toPercentEncoding ( const QString & input, const QByteArray & exclude = QByteArray(), const QByteArray & include = QByteArray() ) + */ +HB_FUNC( QT_QURL_TOPERCENTENCODING ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QUrl( 1 )->toPercentEncoding( hbqt_par_QString( 2 ), ( HB_ISPOINTER( 3 ) ? *hbqt_par_QByteArray( 3 ) : QByteArray() ), ( HB_ISPOINTER( 4 ) ? *hbqt_par_QByteArray( 4 ) : QByteArray() ) ) ), release_QByteArray ) ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/QVariant.cpp b/harbour/contrib/hbqt/qtcore/QVariant.cpp new file mode 100644 index 0000000000..8895654886 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/QVariant.cpp @@ -0,0 +1,478 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + +#include "hbapi.h" +#include "../hbqt.h" + +/*----------------------------------------------------------------------*/ +#if QT_VERSION >= 0x040500 +/*----------------------------------------------------------------------*/ + +/* + * enum Type { Invalid, BitArray, Bitmap, Bool, ..., UserType } + */ + +/* + * Constructed[ 36/42 [ 85.71% ] ] + * + * *** Unconvered Prototypes *** + * ----------------------------- + * + * QHash toHash () const + * QList toList () const + * QMap toMap () const + * + * *** Commented out protos which construct fine but do not compile *** + * + * //QChar toChar () const + * //const char * typeName () const + * //T value () const + */ + +#include + +#include +#include +#include +#include +#include +#include +#include +#include + + +/* +QVariant () +QVariant ( Qt::GlobalColor color ) +QVariant ( Type type ) +QVariant ( int typeOrUserType, const void * copy ) +QVariant ( const QVariant & p ) +QVariant ( QDataStream & s ) +QVariant ( int val ) +QVariant ( uint val ) +QVariant ( qlonglong val ) +QVariant ( qulonglong val ) +QVariant ( bool val ) +QVariant ( double val ) +QVariant ( const char * val ) +QVariant ( const QByteArray & val ) +QVariant ( const QBitArray & val ) +QVariant ( const QString & val ) +QVariant ( const QLatin1String & val ) +QVariant ( const QStringList & val ) +QVariant ( const QChar & c ) +QVariant ( const QDate & val ) +QVariant ( const QTime & val ) +QVariant ( const QDateTime & val ) +QVariant ( const QList & val ) +QVariant ( const QMap & val ) +QVariant ( const QHash & val ) +QVariant ( const QSize & val ) +QVariant ( const QSizeF & val ) +QVariant ( const QPoint & val ) +QVariant ( const QPointF & val ) +QVariant ( const QLine & val ) +QVariant ( const QLineF & val ) +QVariant ( const QRect & val ) +QVariant ( const QRectF & val ) +QVariant ( const QUrl & val ) +QVariant ( const QLocale & l ) +QVariant ( const QRegExp & regExp ) +~QVariant () + */ + +QT_G_FUNC( release_QVariant ) +{ +#if defined(__debug__) + hb_snprintf( str, sizeof(str), "release_QVariant" ); OutputDebugString( str ); +#endif + void * ph = ( void * ) Cargo; + if( ph ) + { + delete ( ( QVariant * ) ph ); + ph = NULL; + } +} + +HB_FUNC( QT_QVARIANT ) +{ + QGC_POINTER * p = ( QGC_POINTER * ) hb_gcAlloc( sizeof( QGC_POINTER ), Q_release ); + void * pObj = NULL; + + pObj = ( QVariant* ) new QVariant() ; + + p->ph = pObj; + p->func = release_QVariant; + + hb_retptrGC( p ); +} +/* + * bool canConvert ( Type t ) const + */ +HB_FUNC( QT_QVARIANT_CANCONVERT ) +{ + hb_retl( hbqt_par_QVariant( 1 )->canConvert( ( QVariant::Type ) hb_parni( 2 ) ) ); +} + +/* + * bool canConvert ( Type t ) const + */ +HB_FUNC( QT_QVARIANT_CANCONVERT_1 ) +{ + hb_retl( hbqt_par_QVariant( 1 )->canConvert( ( QVariant::Type ) hb_parni( 2 ) ) ); +} + +/* + * void clear () + */ +HB_FUNC( QT_QVARIANT_CLEAR ) +{ + hbqt_par_QVariant( 1 )->clear(); +} + +/* + * bool convert ( Type t ) + */ +HB_FUNC( QT_QVARIANT_CONVERT ) +{ + hb_retl( hbqt_par_QVariant( 1 )->convert( ( QVariant::Type ) hb_parni( 2 ) ) ); +} + +/* + * bool isNull () const + */ +HB_FUNC( QT_QVARIANT_ISNULL ) +{ + hb_retl( hbqt_par_QVariant( 1 )->isNull() ); +} + +/* + * bool isValid () const + */ +HB_FUNC( QT_QVARIANT_ISVALID ) +{ + hb_retl( hbqt_par_QVariant( 1 )->isValid() ); +} + +/* + * void setValue ( const T & value ) + */ +HB_FUNC( QT_QVARIANT_SETVALUE ) +{ + hbqt_par_QVariant( 1 )->setValue( hb_param( 2, HB_IT_ANY ) ); +} + +/* + * QBitArray toBitArray () const + */ +HB_FUNC( QT_QVARIANT_TOBITARRAY ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QBitArray( hbqt_par_QVariant( 1 )->toBitArray() ), release_QBitArray ) ); +} + +/* + * bool toBool () const + */ +HB_FUNC( QT_QVARIANT_TOBOOL ) +{ + hb_retl( hbqt_par_QVariant( 1 )->toBool() ); +} + +/* + * QByteArray toByteArray () const + */ +HB_FUNC( QT_QVARIANT_TOBYTEARRAY ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QByteArray( hbqt_par_QVariant( 1 )->toByteArray() ), release_QByteArray ) ); +} + +/* + * QDate toDate () const + */ +HB_FUNC( QT_QVARIANT_TODATE ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDate( hbqt_par_QVariant( 1 )->toDate() ), release_QDate ) ); +} + +/* + * QDateTime toDateTime () const + */ +HB_FUNC( QT_QVARIANT_TODATETIME ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QDateTime( hbqt_par_QVariant( 1 )->toDateTime() ), release_QDateTime ) ); +} + +/* + * double toDouble ( bool * ok = 0 ) const + */ +HB_FUNC( QT_QVARIANT_TODOUBLE ) +{ + bool iOk = 0; + + hb_retnd( hbqt_par_QVariant( 1 )->toDouble( &iOk ) ); + + hb_stornl( iOk, 2 ); +} + +/* + * int toInt ( bool * ok = 0 ) const + */ +HB_FUNC( QT_QVARIANT_TOINT ) +{ + bool iOk = 0; + + hb_retni( hbqt_par_QVariant( 1 )->toInt( &iOk ) ); + + hb_stornl( iOk, 2 ); +} + +/* + * QLine toLine () const + */ +HB_FUNC( QT_QVARIANT_TOLINE ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QLine( hbqt_par_QVariant( 1 )->toLine() ), release_QLine ) ); +} + +/* + * QLineF toLineF () const + */ +HB_FUNC( QT_QVARIANT_TOLINEF ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QLineF( hbqt_par_QVariant( 1 )->toLineF() ), release_QLineF ) ); +} + +/* + * QLocale toLocale () const + */ +HB_FUNC( QT_QVARIANT_TOLOCALE ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QLocale( hbqt_par_QVariant( 1 )->toLocale() ), release_QLocale ) ); +} + +/* + * qlonglong toLongLong ( bool * ok = 0 ) const + */ +HB_FUNC( QT_QVARIANT_TOLONGLONG ) +{ + bool iOk = 0; + + hb_retnint( hbqt_par_QVariant( 1 )->toLongLong( &iOk ) ); + + hb_stornl( iOk, 2 ); +} + +/* + * QPoint toPoint () const + */ +HB_FUNC( QT_QVARIANT_TOPOINT ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QPoint( hbqt_par_QVariant( 1 )->toPoint() ), release_QPoint ) ); +} + +/* + * QPointF toPointF () const + */ +HB_FUNC( QT_QVARIANT_TOPOINTF ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QPointF( hbqt_par_QVariant( 1 )->toPointF() ), release_QPointF ) ); +} + +/* + * QRect toRect () const + */ +HB_FUNC( QT_QVARIANT_TORECT ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QRect( hbqt_par_QVariant( 1 )->toRect() ), release_QRect ) ); +} + +/* + * QRectF toRectF () const + */ +HB_FUNC( QT_QVARIANT_TORECTF ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QRectF( hbqt_par_QVariant( 1 )->toRectF() ), release_QRectF ) ); +} + +/* + * QRegExp toRegExp () const + */ +HB_FUNC( QT_QVARIANT_TOREGEXP ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QRegExp( hbqt_par_QVariant( 1 )->toRegExp() ), release_QRegExp ) ); +} + +/* + * QSize toSize () const + */ +HB_FUNC( QT_QVARIANT_TOSIZE ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QSize( hbqt_par_QVariant( 1 )->toSize() ), release_QSize ) ); +} + +/* + * QSizeF toSizeF () const + */ +HB_FUNC( QT_QVARIANT_TOSIZEF ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QSizeF( hbqt_par_QVariant( 1 )->toSizeF() ), release_QSizeF ) ); +} + +/* + * QString toString () const + */ +HB_FUNC( QT_QVARIANT_TOSTRING ) +{ + hb_retc( hbqt_par_QVariant( 1 )->toString().toAscii().data() ); +} + +/* + * QStringList toStringList () const + */ +HB_FUNC( QT_QVARIANT_TOSTRINGLIST ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QStringList( hbqt_par_QVariant( 1 )->toStringList() ), release_QStringList ) ); +} + +/* + * QTime toTime () const + */ +HB_FUNC( QT_QVARIANT_TOTIME ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QTime( hbqt_par_QVariant( 1 )->toTime() ), release_QTime ) ); +} + +/* + * uint toUInt ( bool * ok = 0 ) const + */ +HB_FUNC( QT_QVARIANT_TOUINT ) +{ + bool iOk = 0; + + hb_retni( hbqt_par_QVariant( 1 )->toUInt( &iOk ) ); + + hb_stornl( iOk, 2 ); +} + +/* + * qulonglong toULongLong ( bool * ok = 0 ) const + */ +HB_FUNC( QT_QVARIANT_TOULONGLONG ) +{ + bool iOk = 0; + + hb_retnint( hbqt_par_QVariant( 1 )->toULongLong( &iOk ) ); + + hb_stornl( iOk, 2 ); +} + +/* + * QUrl toUrl () const + */ +HB_FUNC( QT_QVARIANT_TOURL ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QUrl( hbqt_par_QVariant( 1 )->toUrl() ), release_QUrl ) ); +} + +/* + * Type type () const + */ +HB_FUNC( QT_QVARIANT_TYPE ) +{ + hb_retni( ( QVariant::Type ) hbqt_par_QVariant( 1 )->type() ); +} + +/* + * int userType () const + */ +HB_FUNC( QT_QVARIANT_USERTYPE ) +{ + hb_retni( hbqt_par_QVariant( 1 )->userType() ); +} + +/* + * QVariant fromValue ( const T & value ) + */ +HB_FUNC( QT_QVARIANT_FROMVALUE ) +{ + hb_retptrGC( hbqt_ptrTOgcpointer( new QVariant( hbqt_par_QVariant( 1 )->fromValue( hb_param( 2, HB_IT_ANY ) ) ), release_QVariant ) ); +} + +/* + * Type nameToType ( const char * name ) + */ +HB_FUNC( QT_QVARIANT_NAMETOTYPE ) +{ + hb_retni( ( QVariant::Type ) hbqt_par_QVariant( 1 )->nameToType( hbqt_par_char( 2 ) ) ); +} + +/* + * const char * typeToName ( Type typ ) + */ +HB_FUNC( QT_QVARIANT_TYPETONAME ) +{ + hb_retc( hbqt_par_QVariant( 1 )->typeToName( ( QVariant::Type ) hb_parni( 2 ) ) ); +} + + +/*----------------------------------------------------------------------*/ +#endif /* #if QT_VERSION >= 0x040500 */ +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQAbstractItemModel.prg b/harbour/contrib/hbqt/qtcore/TQAbstractItemModel.prg new file mode 100644 index 0000000000..67b2ea5fa1 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQAbstractItemModel.prg @@ -0,0 +1,143 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QAbstractItemModel INHERIT QObject + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD buddy( pIndex ) INLINE Qt_QAbstractItemModel_buddy( ::pPtr, pIndex ) + METHOD canFetchMore( pParent ) INLINE Qt_QAbstractItemModel_canFetchMore( ::pPtr, pParent ) + METHOD columnCount( pParent ) INLINE Qt_QAbstractItemModel_columnCount( ::pPtr, pParent ) + METHOD data( pIndex, nRole ) INLINE Qt_QAbstractItemModel_data( ::pPtr, pIndex, nRole ) + METHOD dropMimeData( pData, nAction, nRow, nColumn, pParent ) INLINE Qt_QAbstractItemModel_dropMimeData( ::pPtr, pData, nAction, nRow, nColumn, pParent ) + METHOD fetchMore( pParent ) INLINE Qt_QAbstractItemModel_fetchMore( ::pPtr, pParent ) + METHOD flags( pIndex ) INLINE Qt_QAbstractItemModel_flags( ::pPtr, pIndex ) + METHOD hasChildren( pParent ) INLINE Qt_QAbstractItemModel_hasChildren( ::pPtr, pParent ) + METHOD hasIndex( nRow, nColumn, pParent ) INLINE Qt_QAbstractItemModel_hasIndex( ::pPtr, nRow, nColumn, pParent ) + METHOD headerData( nSection, nOrientation, nRole ) INLINE Qt_QAbstractItemModel_headerData( ::pPtr, nSection, nOrientation, nRole ) + METHOD index( nRow, nColumn, pParent ) INLINE Qt_QAbstractItemModel_index( ::pPtr, nRow, nColumn, pParent ) + METHOD insertColumn( nColumn, pParent ) INLINE Qt_QAbstractItemModel_insertColumn( ::pPtr, nColumn, pParent ) + METHOD insertColumns( nColumn, nCount, pParent ) INLINE Qt_QAbstractItemModel_insertColumns( ::pPtr, nColumn, nCount, pParent ) + METHOD insertRow( nRow, pParent ) INLINE Qt_QAbstractItemModel_insertRow( ::pPtr, nRow, pParent ) + METHOD insertRows( nRow, nCount, pParent ) INLINE Qt_QAbstractItemModel_insertRows( ::pPtr, nRow, nCount, pParent ) + METHOD mimeTypes() INLINE Qt_QAbstractItemModel_mimeTypes( ::pPtr ) + METHOD parent( pIndex ) INLINE Qt_QAbstractItemModel_parent( ::pPtr, pIndex ) + METHOD removeColumn( nColumn, pParent ) INLINE Qt_QAbstractItemModel_removeColumn( ::pPtr, nColumn, pParent ) + METHOD removeColumns( nColumn, nCount, pParent ) INLINE Qt_QAbstractItemModel_removeColumns( ::pPtr, nColumn, nCount, pParent ) + METHOD removeRow( nRow, pParent ) INLINE Qt_QAbstractItemModel_removeRow( ::pPtr, nRow, pParent ) + METHOD removeRows( nRow, nCount, pParent ) INLINE Qt_QAbstractItemModel_removeRows( ::pPtr, nRow, nCount, pParent ) + METHOD rowCount( pParent ) INLINE Qt_QAbstractItemModel_rowCount( ::pPtr, pParent ) + METHOD setData( pIndex, pValue, nRole ) INLINE Qt_QAbstractItemModel_setData( ::pPtr, pIndex, pValue, nRole ) + METHOD setHeaderData( nSection, nOrientation, pValue, nRole ) INLINE Qt_QAbstractItemModel_setHeaderData( ::pPtr, nSection, nOrientation, pValue, nRole ) + METHOD setSupportedDragActions( nActions ) INLINE Qt_QAbstractItemModel_setSupportedDragActions( ::pPtr, nActions ) + METHOD sibling( nRow, nColumn, pIndex ) INLINE Qt_QAbstractItemModel_sibling( ::pPtr, nRow, nColumn, pIndex ) + METHOD sort( nColumn, nOrder ) INLINE Qt_QAbstractItemModel_sort( ::pPtr, nColumn, nOrder ) + METHOD span( pIndex ) INLINE Qt_QAbstractItemModel_span( ::pPtr, pIndex ) + METHOD supportedDragActions() INLINE Qt_QAbstractItemModel_supportedDragActions( ::pPtr ) + METHOD supportedDropActions() INLINE Qt_QAbstractItemModel_supportedDropActions( ::pPtr ) + METHOD revert() INLINE Qt_QAbstractItemModel_revert( ::pPtr ) + METHOD submit() INLINE Qt_QAbstractItemModel_submit( ::pPtr ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QAbstractItemModel + + ::pParent := pParent + + ::pPtr := Qt_QAbstractItemModel( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QAbstractItemModel + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ + + +CREATE CLASS HbDbfModel INHERIT QAbstractItemModel + + METHOD New( bBlock ) INLINE ::pPtr := Qt_HbDbfModel( bBlock ), Self + METHOD Reset() INLINE Qt_HbDbfModel_reset( ::pPtr ) + METHOD Index( nRow, nCol ) INLINE Qt_HbDbfModel_index( ::pPtr, nRow, nCol, 0 ) + METHOD hbSetRowColumns( nRows, nCols ) INLINE Qt_HbDbfModel_hbSetRowColumns( ::pPtr, nRows, nCols ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQAbstractListModel.prg b/harbour/contrib/hbqt/qtcore/TQAbstractListModel.prg new file mode 100644 index 0000000000..cf06c14b0a --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQAbstractListModel.prg @@ -0,0 +1,100 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QAbstractListModel INHERIT QAbstractItemModel + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD index( nRow, nColumn, pParent ) INLINE Qt_QAbstractListModel_index( ::pPtr, nRow, nColumn, pParent ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QAbstractListModel + + ::pParent := pParent + + ::pPtr := Qt_QAbstractListModel( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QAbstractListModel + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQAbstractTableModel.prg b/harbour/contrib/hbqt/qtcore/TQAbstractTableModel.prg new file mode 100644 index 0000000000..fbca1f2c99 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQAbstractTableModel.prg @@ -0,0 +1,100 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QAbstractTableModel INHERIT QAbstractItemModel + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD index( nRow, nColumn, pParent ) INLINE Qt_QAbstractTableModel_index( ::pPtr, nRow, nColumn, pParent ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QAbstractTableModel + + ::pParent := pParent + + ::pPtr := Qt_QAbstractTableModel( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QAbstractTableModel + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQBitArray.prg b/harbour/contrib/hbqt/qtcore/TQBitArray.prg new file mode 100644 index 0000000000..e400f57526 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQBitArray.prg @@ -0,0 +1,115 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QBitArray + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD at( nI ) INLINE Qt_QBitArray_at( ::pPtr, nI ) + METHOD clear() INLINE Qt_QBitArray_clear( ::pPtr ) + METHOD clearBit( nI ) INLINE Qt_QBitArray_clearBit( ::pPtr, nI ) + METHOD count() INLINE Qt_QBitArray_count( ::pPtr ) + METHOD count_1( lOn ) INLINE Qt_QBitArray_count_1( ::pPtr, lOn ) + METHOD fill( lValue, nSize ) INLINE Qt_QBitArray_fill( ::pPtr, lValue, nSize ) + METHOD fill_1( lValue, nBegin, nEnd ) INLINE Qt_QBitArray_fill_1( ::pPtr, lValue, nBegin, nEnd ) + METHOD isEmpty() INLINE Qt_QBitArray_isEmpty( ::pPtr ) + METHOD isNull() INLINE Qt_QBitArray_isNull( ::pPtr ) + METHOD resize( nSize ) INLINE Qt_QBitArray_resize( ::pPtr, nSize ) + METHOD setBit( nI ) INLINE Qt_QBitArray_setBit( ::pPtr, nI ) + METHOD setBit_1( nI, lValue ) INLINE Qt_QBitArray_setBit_1( ::pPtr, nI, lValue ) + METHOD size() INLINE Qt_QBitArray_size( ::pPtr ) + METHOD testBit( nI ) INLINE Qt_QBitArray_testBit( ::pPtr, nI ) + METHOD toggleBit( nI ) INLINE Qt_QBitArray_toggleBit( ::pPtr, nI ) + METHOD truncate( nPos ) INLINE Qt_QBitArray_truncate( ::pPtr, nPos ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QBitArray + + ::pParent := pParent + + ::pPtr := Qt_QBitArray( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QBitArray + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQByteArray.prg b/harbour/contrib/hbqt/qtcore/TQByteArray.prg new file mode 100644 index 0000000000..0fa718bc84 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQByteArray.prg @@ -0,0 +1,196 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QByteArray + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD append( pBa ) INLINE Qt_QByteArray_append( ::pPtr, pBa ) + METHOD append_1( cStr ) INLINE Qt_QByteArray_append_1( ::pPtr, cStr ) + METHOD append_2( pStr ) INLINE Qt_QByteArray_append_2( ::pPtr, pStr ) + METHOD append_3( pStr, nLen ) INLINE Qt_QByteArray_append_3( ::pPtr, pStr, nLen ) + METHOD append_4( cCh ) INLINE Qt_QByteArray_append_4( ::pPtr, cCh ) + METHOD at( nI ) INLINE Qt_QByteArray_at( ::pPtr, nI ) + METHOD capacity() INLINE Qt_QByteArray_capacity( ::pPtr ) + METHOD chop( nN ) INLINE Qt_QByteArray_chop( ::pPtr, nN ) + METHOD clear() INLINE Qt_QByteArray_clear( ::pPtr ) + METHOD constData() INLINE Qt_QByteArray_constData( ::pPtr ) + METHOD count( pBa ) INLINE Qt_QByteArray_count( ::pPtr, pBa ) + METHOD count_1( pStr ) INLINE Qt_QByteArray_count_1( ::pPtr, pStr ) + METHOD count_2( cCh ) INLINE Qt_QByteArray_count_2( ::pPtr, cCh ) + METHOD count_3() INLINE Qt_QByteArray_count_3( ::pPtr ) + METHOD data() INLINE Qt_QByteArray_data( ::pPtr ) + METHOD data_1() INLINE Qt_QByteArray_data_1( ::pPtr ) + METHOD endsWith( pBa ) INLINE Qt_QByteArray_endsWith( ::pPtr, pBa ) + METHOD endsWith_1( pStr ) INLINE Qt_QByteArray_endsWith_1( ::pPtr, pStr ) + METHOD endsWith_2( cCh ) INLINE Qt_QByteArray_endsWith_2( ::pPtr, cCh ) + METHOD fill( cCh, nSize ) INLINE Qt_QByteArray_fill( ::pPtr, cCh, nSize ) + METHOD indexOf( pBa, nFrom ) INLINE Qt_QByteArray_indexOf( ::pPtr, pBa, nFrom ) + METHOD indexOf_1( cStr, nFrom ) INLINE Qt_QByteArray_indexOf_1( ::pPtr, cStr, nFrom ) + METHOD indexOf_2( pStr, nFrom ) INLINE Qt_QByteArray_indexOf_2( ::pPtr, pStr, nFrom ) + METHOD indexOf_3( cCh, nFrom ) INLINE Qt_QByteArray_indexOf_3( ::pPtr, cCh, nFrom ) + METHOD insert( nI, pBa ) INLINE Qt_QByteArray_insert( ::pPtr, nI, pBa ) + METHOD insert_1( nI, cStr ) INLINE Qt_QByteArray_insert_1( ::pPtr, nI, cStr ) + METHOD insert_2( nI, pStr ) INLINE Qt_QByteArray_insert_2( ::pPtr, nI, pStr ) + METHOD insert_3( nI, cCh ) INLINE Qt_QByteArray_insert_3( ::pPtr, nI, cCh ) + METHOD isEmpty() INLINE Qt_QByteArray_isEmpty( ::pPtr ) + METHOD isNull() INLINE Qt_QByteArray_isNull( ::pPtr ) + METHOD lastIndexOf( pBa, nFrom ) INLINE Qt_QByteArray_lastIndexOf( ::pPtr, pBa, nFrom ) + METHOD lastIndexOf_1( cStr, nFrom ) INLINE Qt_QByteArray_lastIndexOf_1( ::pPtr, cStr, nFrom ) + METHOD lastIndexOf_2( pStr, nFrom ) INLINE Qt_QByteArray_lastIndexOf_2( ::pPtr, pStr, nFrom ) + METHOD lastIndexOf_3( cCh, nFrom ) INLINE Qt_QByteArray_lastIndexOf_3( ::pPtr, cCh, nFrom ) + METHOD left( nLen ) INLINE Qt_QByteArray_left( ::pPtr, nLen ) + METHOD leftJustified( nWidth, cFill, lTruncate ) INLINE Qt_QByteArray_leftJustified( ::pPtr, nWidth, cFill, lTruncate ) + METHOD length() INLINE Qt_QByteArray_length( ::pPtr ) + METHOD mid( nPos, nLen ) INLINE Qt_QByteArray_mid( ::pPtr, nPos, nLen ) + METHOD prepend( pBa ) INLINE Qt_QByteArray_prepend( ::pPtr, pBa ) + METHOD prepend_1( pStr ) INLINE Qt_QByteArray_prepend_1( ::pPtr, pStr ) + METHOD prepend_2( cCh ) INLINE Qt_QByteArray_prepend_2( ::pPtr, cCh ) + METHOD push_back( pOther ) INLINE Qt_QByteArray_push_back( ::pPtr, pOther ) + METHOD push_back_1( pStr ) INLINE Qt_QByteArray_push_back_1( ::pPtr, pStr ) + METHOD push_back_2( cCh ) INLINE Qt_QByteArray_push_back_2( ::pPtr, cCh ) + METHOD push_front( pOther ) INLINE Qt_QByteArray_push_front( ::pPtr, pOther ) + METHOD push_front_1( pStr ) INLINE Qt_QByteArray_push_front_1( ::pPtr, pStr ) + METHOD push_front_2( cCh ) INLINE Qt_QByteArray_push_front_2( ::pPtr, cCh ) + METHOD remove( nPos, nLen ) INLINE Qt_QByteArray_remove( ::pPtr, nPos, nLen ) + METHOD repeated( nTimes ) INLINE Qt_QByteArray_repeated( ::pPtr, nTimes ) + METHOD replace( nPos, nLen, pAfter ) INLINE Qt_QByteArray_replace( ::pPtr, nPos, nLen, pAfter ) + METHOD replace_1( nPos, nLen, pAfter ) INLINE Qt_QByteArray_replace_1( ::pPtr, nPos, nLen, pAfter ) + METHOD replace_2( pBefore, pAfter ) INLINE Qt_QByteArray_replace_2( ::pPtr, pBefore, pAfter ) + METHOD replace_3( pBefore, pAfter ) INLINE Qt_QByteArray_replace_3( ::pPtr, pBefore, pAfter ) + METHOD replace_4( pBefore, nBsize, pAfter, nAsize ) INLINE Qt_QByteArray_replace_4( ::pPtr, pBefore, nBsize, pAfter, nAsize ) + METHOD replace_5( pBefore, pAfter ) INLINE Qt_QByteArray_replace_5( ::pPtr, pBefore, pAfter ) + METHOD replace_6( cBefore, pAfter ) INLINE Qt_QByteArray_replace_6( ::pPtr, cBefore, pAfter ) + METHOD replace_7( cBefore, pAfter ) INLINE Qt_QByteArray_replace_7( ::pPtr, cBefore, pAfter ) + METHOD replace_8( pBefore, pAfter ) INLINE Qt_QByteArray_replace_8( ::pPtr, pBefore, pAfter ) + METHOD replace_9( cBefore, pAfter ) INLINE Qt_QByteArray_replace_9( ::pPtr, cBefore, pAfter ) + METHOD replace_10( cBefore, cAfter ) INLINE Qt_QByteArray_replace_10( ::pPtr, cBefore, cAfter ) + METHOD replace_11( cBefore, pAfter ) INLINE Qt_QByteArray_replace_11( ::pPtr, cBefore, pAfter ) + METHOD replace_12( cBefore, cAfter ) INLINE Qt_QByteArray_replace_12( ::pPtr, cBefore, cAfter ) + METHOD reserve( nSize ) INLINE Qt_QByteArray_reserve( ::pPtr, nSize ) + METHOD resize( nSize ) INLINE Qt_QByteArray_resize( ::pPtr, nSize ) + METHOD right( nLen ) INLINE Qt_QByteArray_right( ::pPtr, nLen ) + METHOD rightJustified( nWidth, cFill, lTruncate ) INLINE Qt_QByteArray_rightJustified( ::pPtr, nWidth, cFill, lTruncate ) + METHOD setNum( nN, nBase ) INLINE Qt_QByteArray_setNum( ::pPtr, nN, nBase ) + METHOD setNum_1( nN, nBase ) INLINE Qt_QByteArray_setNum_1( ::pPtr, nN, nBase ) + METHOD setNum_2( nN, nBase ) INLINE Qt_QByteArray_setNum_2( ::pPtr, nN, nBase ) + METHOD setNum_3( nN, nBase ) INLINE Qt_QByteArray_setNum_3( ::pPtr, nN, nBase ) + METHOD setNum_4( nN, nBase ) INLINE Qt_QByteArray_setNum_4( ::pPtr, nN, nBase ) + METHOD setNum_5( nN, nBase ) INLINE Qt_QByteArray_setNum_5( ::pPtr, nN, nBase ) + METHOD setNum_6( nN, cF, nPrec ) INLINE Qt_QByteArray_setNum_6( ::pPtr, nN, cF, nPrec ) + METHOD setNum_7( nN, cF, nPrec ) INLINE Qt_QByteArray_setNum_7( ::pPtr, nN, cF, nPrec ) + METHOD simplified() INLINE Qt_QByteArray_simplified( ::pPtr ) + METHOD size() INLINE Qt_QByteArray_size( ::pPtr ) + METHOD squeeze() INLINE Qt_QByteArray_squeeze( ::pPtr ) + METHOD startsWith( pBa ) INLINE Qt_QByteArray_startsWith( ::pPtr, pBa ) + METHOD startsWith_1( pStr ) INLINE Qt_QByteArray_startsWith_1( ::pPtr, pStr ) + METHOD startsWith_2( cCh ) INLINE Qt_QByteArray_startsWith_2( ::pPtr, cCh ) + METHOD toBase64() INLINE Qt_QByteArray_toBase64( ::pPtr ) + METHOD toDouble( lOk ) INLINE Qt_QByteArray_toDouble( ::pPtr, lOk ) + METHOD toFloat( lOk ) INLINE Qt_QByteArray_toFloat( ::pPtr, lOk ) + METHOD toHex() INLINE Qt_QByteArray_toHex( ::pPtr ) + METHOD toInt( lOk, nBase ) INLINE Qt_QByteArray_toInt( ::pPtr, lOk, nBase ) + METHOD toLong( lOk, nBase ) INLINE Qt_QByteArray_toLong( ::pPtr, lOk, nBase ) + METHOD toLongLong( lOk, nBase ) INLINE Qt_QByteArray_toLongLong( ::pPtr, lOk, nBase ) + METHOD toLower() INLINE Qt_QByteArray_toLower( ::pPtr ) + METHOD toPercentEncoding( pExclude, pInclude, cPercent ) INLINE Qt_QByteArray_toPercentEncoding( ::pPtr, pExclude, pInclude, cPercent ) + METHOD toShort( lOk, nBase ) INLINE Qt_QByteArray_toShort( ::pPtr, lOk, nBase ) + METHOD toUInt( lOk, nBase ) INLINE Qt_QByteArray_toUInt( ::pPtr, lOk, nBase ) + METHOD toULong( lOk, nBase ) INLINE Qt_QByteArray_toULong( ::pPtr, lOk, nBase ) + METHOD toULongLong( lOk, nBase ) INLINE Qt_QByteArray_toULongLong( ::pPtr, lOk, nBase ) + METHOD toUShort( lOk, nBase ) INLINE Qt_QByteArray_toUShort( ::pPtr, lOk, nBase ) + METHOD toUpper() INLINE Qt_QByteArray_toUpper( ::pPtr ) + METHOD trimmed() INLINE Qt_QByteArray_trimmed( ::pPtr ) + METHOD truncate( nPos ) INLINE Qt_QByteArray_truncate( ::pPtr, nPos ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QByteArray + + ::pParent := pParent + + ::pPtr := Qt_QByteArray( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QByteArray + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQCoreApplication.prg b/harbour/contrib/hbqt/qtcore/TQCoreApplication.prg new file mode 100644 index 0000000000..128e6b209e --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQCoreApplication.prg @@ -0,0 +1,139 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QCoreApplication INHERIT QObject + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD notify( pReceiver, pEvent ) INLINE Qt_QCoreApplication_notify( ::pPtr, pReceiver, pEvent ) + METHOD addLibraryPath( cPath ) INLINE Qt_QCoreApplication_addLibraryPath( ::pPtr, cPath ) + METHOD applicationDirPath() INLINE Qt_QCoreApplication_applicationDirPath( ::pPtr ) + METHOD applicationFilePath() INLINE Qt_QCoreApplication_applicationFilePath( ::pPtr ) + METHOD applicationName() INLINE Qt_QCoreApplication_applicationName( ::pPtr ) + METHOD applicationPid() INLINE Qt_QCoreApplication_applicationPid( ::pPtr ) + METHOD applicationVersion() INLINE Qt_QCoreApplication_applicationVersion( ::pPtr ) + METHOD arguments() INLINE Qt_QCoreApplication_arguments( ::pPtr ) + METHOD closingDown() INLINE Qt_QCoreApplication_closingDown( ::pPtr ) + METHOD exec() INLINE Qt_QCoreApplication_exec( ::pPtr ) + METHOD exit( nReturnCode ) INLINE Qt_QCoreApplication_exit( ::pPtr, nReturnCode ) + METHOD flush() INLINE Qt_QCoreApplication_flush( ::pPtr ) + METHOD hasPendingEvents() INLINE Qt_QCoreApplication_hasPendingEvents( ::pPtr ) + METHOD installTranslator( pTranslationFile ) INLINE Qt_QCoreApplication_installTranslator( ::pPtr, pTranslationFile ) + METHOD instance() INLINE Qt_QCoreApplication_instance( ::pPtr ) + METHOD libraryPaths() INLINE Qt_QCoreApplication_libraryPaths( ::pPtr ) + METHOD organizationDomain() INLINE Qt_QCoreApplication_organizationDomain( ::pPtr ) + METHOD organizationName() INLINE Qt_QCoreApplication_organizationName( ::pPtr ) + METHOD postEvent( pReceiver, pEvent ) INLINE Qt_QCoreApplication_postEvent( ::pPtr, pReceiver, pEvent ) + METHOD postEvent_1( pReceiver, pEvent, nPriority ) INLINE Qt_QCoreApplication_postEvent_1( ::pPtr, pReceiver, pEvent, nPriority ) + METHOD processEvents( nFlags ) INLINE Qt_QCoreApplication_processEvents( ::pPtr, nFlags ) + METHOD processEvents_1( nFlags, nMaxtime ) INLINE Qt_QCoreApplication_processEvents_1( ::pPtr, nFlags, nMaxtime ) + METHOD removeLibraryPath( cPath ) INLINE Qt_QCoreApplication_removeLibraryPath( ::pPtr, cPath ) + METHOD removePostedEvents( pReceiver ) INLINE Qt_QCoreApplication_removePostedEvents( ::pPtr, pReceiver ) + METHOD removePostedEvents_1( pReceiver, nEventType ) INLINE Qt_QCoreApplication_removePostedEvents_1( ::pPtr, pReceiver, nEventType ) + METHOD removeTranslator( pTranslationFile ) INLINE Qt_QCoreApplication_removeTranslator( ::pPtr, pTranslationFile ) + METHOD sendEvent( pReceiver, pEvent ) INLINE Qt_QCoreApplication_sendEvent( ::pPtr, pReceiver, pEvent ) + METHOD sendPostedEvents( pReceiver, nEvent_type ) INLINE Qt_QCoreApplication_sendPostedEvents( ::pPtr, pReceiver, nEvent_type ) + METHOD sendPostedEvents_1() INLINE Qt_QCoreApplication_sendPostedEvents_1( ::pPtr ) + METHOD setApplicationName( cApplication ) INLINE Qt_QCoreApplication_setApplicationName( ::pPtr, cApplication ) + METHOD setApplicationVersion( cVersion ) INLINE Qt_QCoreApplication_setApplicationVersion( ::pPtr, cVersion ) + METHOD setAttribute( nAttribute, lOn ) INLINE Qt_QCoreApplication_setAttribute( ::pPtr, nAttribute, lOn ) + METHOD setLibraryPaths( pPaths ) INLINE Qt_QCoreApplication_setLibraryPaths( ::pPtr, pPaths ) + METHOD setOrganizationDomain( cOrgDomain ) INLINE Qt_QCoreApplication_setOrganizationDomain( ::pPtr, cOrgDomain ) + METHOD setOrganizationName( cOrgName ) INLINE Qt_QCoreApplication_setOrganizationName( ::pPtr, cOrgName ) + METHOD startingUp() INLINE Qt_QCoreApplication_startingUp( ::pPtr ) + METHOD testAttribute( nAttribute ) INLINE Qt_QCoreApplication_testAttribute( ::pPtr, nAttribute ) + METHOD translate( pContext, pSourceText, pDisambiguation, nEncoding, nN ) INLINE Qt_QCoreApplication_translate( ::pPtr, pContext, pSourceText, pDisambiguation, nEncoding, nN ) + METHOD translate_1( pContext, pSourceText, pDisambiguation, nEncoding ) INLINE Qt_QCoreApplication_translate_1( ::pPtr, pContext, pSourceText, pDisambiguation, nEncoding ) + METHOD quit() INLINE Qt_QCoreApplication_quit( ::pPtr ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QCoreApplication + + ::pParent := pParent + + ::pPtr := Qt_QCoreApplication( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QCoreApplication + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQDataStream.prg b/harbour/contrib/hbqt/qtcore/TQDataStream.prg new file mode 100644 index 0000000000..1cd1b8bc86 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQDataStream.prg @@ -0,0 +1,112 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QDataStream + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD atEnd() INLINE Qt_QDataStream_atEnd( ::pPtr ) + METHOD byteOrder() INLINE Qt_QDataStream_byteOrder( ::pPtr ) + METHOD device() INLINE Qt_QDataStream_device( ::pPtr ) + METHOD readRawData( cS, nLen ) INLINE Qt_QDataStream_readRawData( ::pPtr, cS, nLen ) + METHOD resetStatus() INLINE Qt_QDataStream_resetStatus( ::pPtr ) + METHOD setByteOrder( nBo ) INLINE Qt_QDataStream_setByteOrder( ::pPtr, nBo ) + METHOD setDevice( pD ) INLINE Qt_QDataStream_setDevice( ::pPtr, pD ) + METHOD setStatus( nStatus ) INLINE Qt_QDataStream_setStatus( ::pPtr, nStatus ) + METHOD setVersion( nV ) INLINE Qt_QDataStream_setVersion( ::pPtr, nV ) + METHOD skipRawData( nLen ) INLINE Qt_QDataStream_skipRawData( ::pPtr, nLen ) + METHOD status() INLINE Qt_QDataStream_status( ::pPtr ) + METHOD version() INLINE Qt_QDataStream_version( ::pPtr ) + METHOD writeRawData( pS, nLen ) INLINE Qt_QDataStream_writeRawData( ::pPtr, pS, nLen ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QDataStream + + ::pParent := pParent + + ::pPtr := Qt_QDataStream( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QDataStream + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQDate.prg b/harbour/contrib/hbqt/qtcore/TQDate.prg new file mode 100644 index 0000000000..c9c760cf51 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQDate.prg @@ -0,0 +1,118 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QDate + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD addDays( nNdays ) INLINE Qt_QDate_addDays( ::pPtr, nNdays ) + METHOD addMonths( nNmonths ) INLINE Qt_QDate_addMonths( ::pPtr, nNmonths ) + METHOD addYears( nNyears ) INLINE Qt_QDate_addYears( ::pPtr, nNyears ) + METHOD day() INLINE Qt_QDate_day( ::pPtr ) + METHOD dayOfWeek() INLINE Qt_QDate_dayOfWeek( ::pPtr ) + METHOD dayOfYear() INLINE Qt_QDate_dayOfYear( ::pPtr ) + METHOD daysInMonth() INLINE Qt_QDate_daysInMonth( ::pPtr ) + METHOD daysInYear() INLINE Qt_QDate_daysInYear( ::pPtr ) + METHOD daysTo( pD ) INLINE Qt_QDate_daysTo( ::pPtr, pD ) + METHOD getDate( nYear, nMonth, nDay ) INLINE Qt_QDate_getDate( ::pPtr, nYear, nMonth, nDay ) + METHOD isNull() INLINE Qt_QDate_isNull( ::pPtr ) + METHOD isValid() INLINE Qt_QDate_isValid( ::pPtr ) + METHOD month() INLINE Qt_QDate_month( ::pPtr ) + METHOD setDate( nYear, nMonth, nDay ) INLINE Qt_QDate_setDate( ::pPtr, nYear, nMonth, nDay ) + METHOD toJulianDay() INLINE Qt_QDate_toJulianDay( ::pPtr ) + METHOD toString( cFormat ) INLINE Qt_QDate_toString( ::pPtr, cFormat ) + METHOD toString_1( nFormat ) INLINE Qt_QDate_toString_1( ::pPtr, nFormat ) + METHOD weekNumber( nYearNumber ) INLINE Qt_QDate_weekNumber( ::pPtr, nYearNumber ) + METHOD year() INLINE Qt_QDate_year( ::pPtr ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QDate + + ::pParent := pParent + + ::pPtr := Qt_QDate( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QDate + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQDateTime.prg b/harbour/contrib/hbqt/qtcore/TQDateTime.prg new file mode 100644 index 0000000000..fa62abcc42 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQDateTime.prg @@ -0,0 +1,125 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QDateTime + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD addDays( nNdays ) INLINE Qt_QDateTime_addDays( ::pPtr, nNdays ) + METHOD addMSecs( nMsecs ) INLINE Qt_QDateTime_addMSecs( ::pPtr, nMsecs ) + METHOD addMonths( nNmonths ) INLINE Qt_QDateTime_addMonths( ::pPtr, nNmonths ) + METHOD addSecs( nS ) INLINE Qt_QDateTime_addSecs( ::pPtr, nS ) + METHOD addYears( nNyears ) INLINE Qt_QDateTime_addYears( ::pPtr, nNyears ) + METHOD date() INLINE Qt_QDateTime_date( ::pPtr ) + METHOD daysTo( pOther ) INLINE Qt_QDateTime_daysTo( ::pPtr, pOther ) + METHOD isNull() INLINE Qt_QDateTime_isNull( ::pPtr ) + METHOD isValid() INLINE Qt_QDateTime_isValid( ::pPtr ) + METHOD secsTo( pOther ) INLINE Qt_QDateTime_secsTo( ::pPtr, pOther ) + METHOD setDate( pDate ) INLINE Qt_QDateTime_setDate( ::pPtr, pDate ) + METHOD setTime( pTime ) INLINE Qt_QDateTime_setTime( ::pPtr, pTime ) + METHOD setTimeSpec( nSpec ) INLINE Qt_QDateTime_setTimeSpec( ::pPtr, nSpec ) + METHOD setTime_t( nSeconds ) INLINE Qt_QDateTime_setTime_t( ::pPtr, nSeconds ) + METHOD time() INLINE Qt_QDateTime_time( ::pPtr ) + METHOD timeSpec() INLINE Qt_QDateTime_timeSpec( ::pPtr ) + METHOD toLocalTime() INLINE Qt_QDateTime_toLocalTime( ::pPtr ) + METHOD toString( cFormat ) INLINE Qt_QDateTime_toString( ::pPtr, cFormat ) + METHOD toString_1( nFormat ) INLINE Qt_QDateTime_toString_1( ::pPtr, nFormat ) + METHOD toTimeSpec( nSpecification ) INLINE Qt_QDateTime_toTimeSpec( ::pPtr, nSpecification ) + METHOD toTime_t() INLINE Qt_QDateTime_toTime_t( ::pPtr ) + METHOD toUTC() INLINE Qt_QDateTime_toUTC( ::pPtr ) + METHOD currentDateTime() INLINE Qt_QDateTime_currentDateTime( ::pPtr ) + METHOD fromString( cString, nFormat ) INLINE Qt_QDateTime_fromString( ::pPtr, cString, nFormat ) + METHOD fromString_1( cString, cFormat ) INLINE Qt_QDateTime_fromString_1( ::pPtr, cString, cFormat ) + METHOD fromTime_t( nSeconds ) INLINE Qt_QDateTime_fromTime_t( ::pPtr, nSeconds ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QDateTime + + ::pParent := pParent + + ::pPtr := Qt_QDateTime( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QDateTime + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQDir.prg b/harbour/contrib/hbqt/qtcore/TQDir.prg new file mode 100644 index 0000000000..243e46ec8b --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQDir.prg @@ -0,0 +1,151 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QDir + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD absoluteFilePath( cFileName ) INLINE Qt_QDir_absoluteFilePath( ::pPtr, cFileName ) + METHOD absolutePath() INLINE Qt_QDir_absolutePath( ::pPtr ) + METHOD canonicalPath() INLINE Qt_QDir_canonicalPath( ::pPtr ) + METHOD cd( cDirName ) INLINE Qt_QDir_cd( ::pPtr, cDirName ) + METHOD cdUp() INLINE Qt_QDir_cdUp( ::pPtr ) + METHOD count() INLINE Qt_QDir_count( ::pPtr ) + METHOD dirName() INLINE Qt_QDir_dirName( ::pPtr ) + METHOD entryList( pNameFilters, nFilters, nSort ) INLINE Qt_QDir_entryList( ::pPtr, pNameFilters, nFilters, nSort ) + METHOD entryList_1( nFilters, nSort ) INLINE Qt_QDir_entryList_1( ::pPtr, nFilters, nSort ) + METHOD exists( cName ) INLINE Qt_QDir_exists( ::pPtr, cName ) + METHOD exists_1() INLINE Qt_QDir_exists_1( ::pPtr ) + METHOD filePath( cFileName ) INLINE Qt_QDir_filePath( ::pPtr, cFileName ) + METHOD filter() INLINE Qt_QDir_filter( ::pPtr ) + METHOD isAbsolute() INLINE Qt_QDir_isAbsolute( ::pPtr ) + METHOD isReadable() INLINE Qt_QDir_isReadable( ::pPtr ) + METHOD isRelative() INLINE Qt_QDir_isRelative( ::pPtr ) + METHOD isRoot() INLINE Qt_QDir_isRoot( ::pPtr ) + METHOD makeAbsolute() INLINE Qt_QDir_makeAbsolute( ::pPtr ) + METHOD mkdir( cDirName ) INLINE Qt_QDir_mkdir( ::pPtr, cDirName ) + METHOD mkpath( cDirPath ) INLINE Qt_QDir_mkpath( ::pPtr, cDirPath ) + METHOD nameFilters() INLINE Qt_QDir_nameFilters( ::pPtr ) + METHOD path() INLINE Qt_QDir_path( ::pPtr ) + METHOD refresh() INLINE Qt_QDir_refresh( ::pPtr ) + METHOD relativeFilePath( cFileName ) INLINE Qt_QDir_relativeFilePath( ::pPtr, cFileName ) + METHOD remove( cFileName ) INLINE Qt_QDir_remove( ::pPtr, cFileName ) + METHOD rename( cOldName, cNewName ) INLINE Qt_QDir_rename( ::pPtr, cOldName, cNewName ) + METHOD rmdir( cDirName ) INLINE Qt_QDir_rmdir( ::pPtr, cDirName ) + METHOD rmpath( cDirPath ) INLINE Qt_QDir_rmpath( ::pPtr, cDirPath ) + METHOD setFilter( nFilters ) INLINE Qt_QDir_setFilter( ::pPtr, nFilters ) + METHOD setNameFilters( pNameFilters ) INLINE Qt_QDir_setNameFilters( ::pPtr, pNameFilters ) + METHOD setPath( cPath ) INLINE Qt_QDir_setPath( ::pPtr, cPath ) + METHOD setSorting( nSort ) INLINE Qt_QDir_setSorting( ::pPtr, nSort ) + METHOD sorting() INLINE Qt_QDir_sorting( ::pPtr ) + METHOD addSearchPath( cPrefix, cPath ) INLINE Qt_QDir_addSearchPath( ::pPtr, cPrefix, cPath ) + METHOD cleanPath( cPath ) INLINE Qt_QDir_cleanPath( ::pPtr, cPath ) + METHOD current() INLINE Qt_QDir_current( ::pPtr ) + METHOD currentPath() INLINE Qt_QDir_currentPath( ::pPtr ) + METHOD fromNativeSeparators( cPathName ) INLINE Qt_QDir_fromNativeSeparators( ::pPtr, cPathName ) + METHOD home() INLINE Qt_QDir_home( ::pPtr ) + METHOD homePath() INLINE Qt_QDir_homePath( ::pPtr ) + METHOD isAbsolutePath( cPath ) INLINE Qt_QDir_isAbsolutePath( ::pPtr, cPath ) + METHOD isRelativePath( cPath ) INLINE Qt_QDir_isRelativePath( ::pPtr, cPath ) + METHOD match( cFilter, cFileName ) INLINE Qt_QDir_match( ::pPtr, cFilter, cFileName ) + METHOD match_1( pFilters, cFileName ) INLINE Qt_QDir_match_1( ::pPtr, pFilters, cFileName ) + METHOD root() INLINE Qt_QDir_root( ::pPtr ) + METHOD rootPath() INLINE Qt_QDir_rootPath( ::pPtr ) + METHOD searchPaths( cPrefix ) INLINE Qt_QDir_searchPaths( ::pPtr, cPrefix ) + METHOD setCurrent( cPath ) INLINE Qt_QDir_setCurrent( ::pPtr, cPath ) + METHOD setSearchPaths( cPrefix, pSearchPaths ) INLINE Qt_QDir_setSearchPaths( ::pPtr, cPrefix, pSearchPaths ) + METHOD temp() INLINE Qt_QDir_temp( ::pPtr ) + METHOD tempPath() INLINE Qt_QDir_tempPath( ::pPtr ) + METHOD toNativeSeparators( cPathName ) INLINE Qt_QDir_toNativeSeparators( ::pPtr, cPathName ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QDir + + ::pParent := pParent + + ::pPtr := Qt_QDir( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QDir + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQEvent.prg b/harbour/contrib/hbqt/qtcore/TQEvent.prg new file mode 100644 index 0000000000..a8563a9176 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQEvent.prg @@ -0,0 +1,106 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QEvent + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD accept() INLINE Qt_QEvent_accept( ::pPtr ) + METHOD ignore() INLINE Qt_QEvent_ignore( ::pPtr ) + METHOD isAccepted() INLINE Qt_QEvent_isAccepted( ::pPtr ) + METHOD setAccepted( lAccepted ) INLINE Qt_QEvent_setAccepted( ::pPtr, lAccepted ) + METHOD spontaneous() INLINE Qt_QEvent_spontaneous( ::pPtr ) + METHOD type() INLINE Qt_QEvent_type( ::pPtr ) + METHOD registerEventType( nHint ) INLINE Qt_QEvent_registerEventType( ::pPtr, nHint ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QEvent + + ::pParent := pParent + + ::pPtr := Qt_QEvent( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QEvent + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQEventLoop.prg b/harbour/contrib/hbqt/qtcore/TQEventLoop.prg new file mode 100644 index 0000000000..5fd648a689 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQEventLoop.prg @@ -0,0 +1,105 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QEventLoop INHERIT QObject + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD exec( nFlags ) INLINE Qt_QEventLoop_exec( ::pPtr, nFlags ) + METHOD exit( nReturnCode ) INLINE Qt_QEventLoop_exit( ::pPtr, nReturnCode ) + METHOD isRunning() INLINE Qt_QEventLoop_isRunning( ::pPtr ) + METHOD processEvents( nFlags ) INLINE Qt_QEventLoop_processEvents( ::pPtr, nFlags ) + METHOD processEvents_1( nFlags, nMaxTime ) INLINE Qt_QEventLoop_processEvents_1( ::pPtr, nFlags, nMaxTime ) + METHOD wakeUp() INLINE Qt_QEventLoop_wakeUp( ::pPtr ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QEventLoop + + ::pParent := pParent + + ::pPtr := Qt_QEventLoop( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QEventLoop + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQFile.prg b/harbour/contrib/hbqt/qtcore/TQFile.prg new file mode 100644 index 0000000000..7ff1985559 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQFile.prg @@ -0,0 +1,133 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QFile INHERIT QIODevice + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD atEnd() INLINE Qt_QFile_atEnd( ::pPtr ) + METHOD close() INLINE Qt_QFile_close( ::pPtr ) + METHOD copy( cNewName ) INLINE Qt_QFile_copy( ::pPtr, cNewName ) + METHOD error() INLINE Qt_QFile_error( ::pPtr ) + METHOD exists() INLINE Qt_QFile_exists( ::pPtr ) + METHOD fileName() INLINE Qt_QFile_fileName( ::pPtr ) + METHOD flush() INLINE Qt_QFile_flush( ::pPtr ) + METHOD handle() INLINE Qt_QFile_handle( ::pPtr ) + METHOD isSequential() INLINE Qt_QFile_isSequential( ::pPtr ) + METHOD link( cLinkName ) INLINE Qt_QFile_link( ::pPtr, cLinkName ) + METHOD map( nOffset, nSize, nFlags ) INLINE Qt_QFile_map( ::pPtr, nOffset, nSize, nFlags ) + METHOD open( nMode ) INLINE Qt_QFile_open( ::pPtr, nMode ) + METHOD open_1( nFd, nMode ) INLINE Qt_QFile_open_1( ::pPtr, nFd, nMode ) + METHOD permissions() INLINE Qt_QFile_permissions( ::pPtr ) + METHOD remove() INLINE Qt_QFile_remove( ::pPtr ) + METHOD rename( cNewName ) INLINE Qt_QFile_rename( ::pPtr, cNewName ) + METHOD resize( nSz ) INLINE Qt_QFile_resize( ::pPtr, nSz ) + METHOD setFileName( cName ) INLINE Qt_QFile_setFileName( ::pPtr, cName ) + METHOD setPermissions( nPermissions ) INLINE Qt_QFile_setPermissions( ::pPtr, nPermissions ) + METHOD size() INLINE Qt_QFile_size( ::pPtr ) + METHOD symLinkTarget() INLINE Qt_QFile_symLinkTarget( ::pPtr ) + METHOD unsetError() INLINE Qt_QFile_unsetError( ::pPtr ) + METHOD copy_1( cFileName, cNewName ) INLINE Qt_QFile_copy_1( ::pPtr, cFileName, cNewName ) + METHOD decodeName( pLocalFileName ) INLINE Qt_QFile_decodeName( ::pPtr, pLocalFileName ) + METHOD decodeName_1( pLocalFileName ) INLINE Qt_QFile_decodeName_1( ::pPtr, pLocalFileName ) + METHOD encodeName( cFileName ) INLINE Qt_QFile_encodeName( ::pPtr, cFileName ) + METHOD exists_1( cFileName ) INLINE Qt_QFile_exists_1( ::pPtr, cFileName ) + METHOD link_1( cFileName, cLinkName ) INLINE Qt_QFile_link_1( ::pPtr, cFileName, cLinkName ) + METHOD permissions_1( cFileName ) INLINE Qt_QFile_permissions_1( ::pPtr, cFileName ) + METHOD remove_1( cFileName ) INLINE Qt_QFile_remove_1( ::pPtr, cFileName ) + METHOD rename_1( cOldName, cNewName ) INLINE Qt_QFile_rename_1( ::pPtr, cOldName, cNewName ) + METHOD resize_1( cFileName, nSz ) INLINE Qt_QFile_resize_1( ::pPtr, cFileName, nSz ) + METHOD setPermissions_1( cFileName, nPermissions ) INLINE Qt_QFile_setPermissions_1( ::pPtr, cFileName, nPermissions ) + METHOD symLinkTarget_1( cFileName ) INLINE Qt_QFile_symLinkTarget_1( ::pPtr, cFileName ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QFile + + ::pParent := pParent + + ::pPtr := Qt_QFile( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QFile + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQFileInfo.prg b/harbour/contrib/hbqt/qtcore/TQFileInfo.prg new file mode 100644 index 0000000000..0d594d75fa --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQFileInfo.prg @@ -0,0 +1,143 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QFileInfo + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD absoluteDir() INLINE Qt_QFileInfo_absoluteDir( ::pPtr ) + METHOD absoluteFilePath() INLINE Qt_QFileInfo_absoluteFilePath( ::pPtr ) + METHOD absolutePath() INLINE Qt_QFileInfo_absolutePath( ::pPtr ) + METHOD baseName() INLINE Qt_QFileInfo_baseName( ::pPtr ) + METHOD bundleName() INLINE Qt_QFileInfo_bundleName( ::pPtr ) + METHOD caching() INLINE Qt_QFileInfo_caching( ::pPtr ) + METHOD canonicalFilePath() INLINE Qt_QFileInfo_canonicalFilePath( ::pPtr ) + METHOD canonicalPath() INLINE Qt_QFileInfo_canonicalPath( ::pPtr ) + METHOD completeBaseName() INLINE Qt_QFileInfo_completeBaseName( ::pPtr ) + METHOD completeSuffix() INLINE Qt_QFileInfo_completeSuffix( ::pPtr ) + METHOD created() INLINE Qt_QFileInfo_created( ::pPtr ) + METHOD dir() INLINE Qt_QFileInfo_dir( ::pPtr ) + METHOD exists() INLINE Qt_QFileInfo_exists( ::pPtr ) + METHOD fileName() INLINE Qt_QFileInfo_fileName( ::pPtr ) + METHOD filePath() INLINE Qt_QFileInfo_filePath( ::pPtr ) + METHOD group() INLINE Qt_QFileInfo_group( ::pPtr ) + METHOD groupId() INLINE Qt_QFileInfo_groupId( ::pPtr ) + METHOD isAbsolute() INLINE Qt_QFileInfo_isAbsolute( ::pPtr ) + METHOD isBundle() INLINE Qt_QFileInfo_isBundle( ::pPtr ) + METHOD isDir() INLINE Qt_QFileInfo_isDir( ::pPtr ) + METHOD isExecutable() INLINE Qt_QFileInfo_isExecutable( ::pPtr ) + METHOD isFile() INLINE Qt_QFileInfo_isFile( ::pPtr ) + METHOD isHidden() INLINE Qt_QFileInfo_isHidden( ::pPtr ) + METHOD isReadable() INLINE Qt_QFileInfo_isReadable( ::pPtr ) + METHOD isRelative() INLINE Qt_QFileInfo_isRelative( ::pPtr ) + METHOD isRoot() INLINE Qt_QFileInfo_isRoot( ::pPtr ) + METHOD isSymLink() INLINE Qt_QFileInfo_isSymLink( ::pPtr ) + METHOD isWritable() INLINE Qt_QFileInfo_isWritable( ::pPtr ) + METHOD lastModified() INLINE Qt_QFileInfo_lastModified( ::pPtr ) + METHOD lastRead() INLINE Qt_QFileInfo_lastRead( ::pPtr ) + METHOD makeAbsolute() INLINE Qt_QFileInfo_makeAbsolute( ::pPtr ) + METHOD owner() INLINE Qt_QFileInfo_owner( ::pPtr ) + METHOD ownerId() INLINE Qt_QFileInfo_ownerId( ::pPtr ) + METHOD path() INLINE Qt_QFileInfo_path( ::pPtr ) + METHOD permission( nPermissions ) INLINE Qt_QFileInfo_permission( ::pPtr, nPermissions ) + METHOD permissions() INLINE Qt_QFileInfo_permissions( ::pPtr ) + METHOD refresh() INLINE Qt_QFileInfo_refresh( ::pPtr ) + METHOD setCaching( lEnable ) INLINE Qt_QFileInfo_setCaching( ::pPtr, lEnable ) + METHOD setFile( cFile ) INLINE Qt_QFileInfo_setFile( ::pPtr, cFile ) + METHOD setFile_1( pFile ) INLINE Qt_QFileInfo_setFile_1( ::pPtr, pFile ) + METHOD setFile_2( pDir, cFile ) INLINE Qt_QFileInfo_setFile_2( ::pPtr, pDir, cFile ) + METHOD size() INLINE Qt_QFileInfo_size( ::pPtr ) + METHOD suffix() INLINE Qt_QFileInfo_suffix( ::pPtr ) + METHOD symLinkTarget() INLINE Qt_QFileInfo_symLinkTarget( ::pPtr ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QFileInfo + + ::pParent := pParent + + ::pPtr := Qt_QFileInfo( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QFileInfo + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQIODevice.prg b/harbour/contrib/hbqt/qtcore/TQIODevice.prg new file mode 100644 index 0000000000..c4859ed331 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQIODevice.prg @@ -0,0 +1,132 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QIODevice INHERIT QObject + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD atEnd() INLINE Qt_QIODevice_atEnd( ::pPtr ) + METHOD bytesAvailable() INLINE Qt_QIODevice_bytesAvailable( ::pPtr ) + METHOD bytesToWrite() INLINE Qt_QIODevice_bytesToWrite( ::pPtr ) + METHOD canReadLine() INLINE Qt_QIODevice_canReadLine( ::pPtr ) + METHOD close() INLINE Qt_QIODevice_close( ::pPtr ) + METHOD errorString() INLINE Qt_QIODevice_errorString( ::pPtr ) + METHOD getChar( cC ) INLINE Qt_QIODevice_getChar( ::pPtr, cC ) + METHOD isOpen() INLINE Qt_QIODevice_isOpen( ::pPtr ) + METHOD isReadable() INLINE Qt_QIODevice_isReadable( ::pPtr ) + METHOD isSequential() INLINE Qt_QIODevice_isSequential( ::pPtr ) + METHOD isTextModeEnabled() INLINE Qt_QIODevice_isTextModeEnabled( ::pPtr ) + METHOD isWritable() INLINE Qt_QIODevice_isWritable( ::pPtr ) + METHOD open( nMode ) INLINE Qt_QIODevice_open( ::pPtr, nMode ) + METHOD openMode() INLINE Qt_QIODevice_openMode( ::pPtr ) + METHOD peek( cData, nMaxSize ) INLINE Qt_QIODevice_peek( ::pPtr, cData, nMaxSize ) + METHOD peek_1( nMaxSize ) INLINE Qt_QIODevice_peek_1( ::pPtr, nMaxSize ) + METHOD pos() INLINE Qt_QIODevice_pos( ::pPtr ) + METHOD putChar( cC ) INLINE Qt_QIODevice_putChar( ::pPtr, cC ) + METHOD read( cData, nMaxSize ) INLINE Qt_QIODevice_read( ::pPtr, cData, nMaxSize ) + METHOD read_1( nMaxSize ) INLINE Qt_QIODevice_read_1( ::pPtr, nMaxSize ) + METHOD readAll() INLINE Qt_QIODevice_readAll( ::pPtr ) + METHOD readLine( cData, nMaxSize ) INLINE Qt_QIODevice_readLine( ::pPtr, cData, nMaxSize ) + METHOD readLine_1( nMaxSize ) INLINE Qt_QIODevice_readLine_1( ::pPtr, nMaxSize ) + METHOD reset() INLINE Qt_QIODevice_reset( ::pPtr ) + METHOD seek( nPos ) INLINE Qt_QIODevice_seek( ::pPtr, nPos ) + METHOD setTextModeEnabled( lEnabled ) INLINE Qt_QIODevice_setTextModeEnabled( ::pPtr, lEnabled ) + METHOD size() INLINE Qt_QIODevice_size( ::pPtr ) + METHOD ungetChar( cC ) INLINE Qt_QIODevice_ungetChar( ::pPtr, cC ) + METHOD waitForBytesWritten( nMsecs ) INLINE Qt_QIODevice_waitForBytesWritten( ::pPtr, nMsecs ) + METHOD waitForReadyRead( nMsecs ) INLINE Qt_QIODevice_waitForReadyRead( ::pPtr, nMsecs ) + METHOD write( pData, nMaxSize ) INLINE Qt_QIODevice_write( ::pPtr, pData, nMaxSize ) + METHOD write_1( pData ) INLINE Qt_QIODevice_write_1( ::pPtr, pData ) + METHOD write_2( pByteArray ) INLINE Qt_QIODevice_write_2( ::pPtr, pByteArray ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QIODevice + + ::pParent := pParent + + ::pPtr := Qt_QIODevice( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QIODevice + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQLatin1Char.prg b/harbour/contrib/hbqt/qtcore/TQLatin1Char.prg new file mode 100644 index 0000000000..5a1750f04c --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQLatin1Char.prg @@ -0,0 +1,101 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QLatin1Char + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD toLatin1() INLINE Qt_QLatin1Char_toLatin1( ::pPtr ) + METHOD unicode() INLINE Qt_QLatin1Char_unicode( ::pPtr ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QLatin1Char + + ::pParent := pParent + + ::pPtr := Qt_QLatin1Char( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QLatin1Char + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQLatin1String.prg b/harbour/contrib/hbqt/qtcore/TQLatin1String.prg new file mode 100644 index 0000000000..dc2f6f9062 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQLatin1String.prg @@ -0,0 +1,100 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QLatin1String + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD latin1() INLINE Qt_QLatin1String_latin1( ::pPtr ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QLatin1String + + ::pParent := pParent + + ::pPtr := Qt_QLatin1String( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QLatin1String + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQLine.prg b/harbour/contrib/hbqt/qtcore/TQLine.prg new file mode 100644 index 0000000000..8ba63857cd --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQLine.prg @@ -0,0 +1,114 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QLine + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD p1() INLINE Qt_QLine_p1( ::pPtr ) + METHOD p2() INLINE Qt_QLine_p2( ::pPtr ) + METHOD x1() INLINE Qt_QLine_x1( ::pPtr ) + METHOD x2() INLINE Qt_QLine_x2( ::pPtr ) + METHOD y1() INLINE Qt_QLine_y1( ::pPtr ) + METHOD y2() INLINE Qt_QLine_y2( ::pPtr ) + METHOD dx() INLINE Qt_QLine_dx( ::pPtr ) + METHOD dy() INLINE Qt_QLine_dy( ::pPtr ) + METHOD isNull() INLINE Qt_QLine_isNull( ::pPtr ) + METHOD setP1( pP1 ) INLINE Qt_QLine_setP1( ::pPtr, pP1 ) + METHOD setP2( pP2 ) INLINE Qt_QLine_setP2( ::pPtr, pP2 ) + METHOD setLine( nX1, nY1, nX2, nY2 ) INLINE Qt_QLine_setLine( ::pPtr, nX1, nY1, nX2, nY2 ) + METHOD setPoints( pP1, pP2 ) INLINE Qt_QLine_setPoints( ::pPtr, pP1, pP2 ) + METHOD translate( pOffset ) INLINE Qt_QLine_translate( ::pPtr, pOffset ) + METHOD translate_1( nDx, nDy ) INLINE Qt_QLine_translate_1( ::pPtr, nDx, nDy ) + METHOD translated( pOffset ) INLINE Qt_QLine_translated( ::pPtr, pOffset ) + METHOD translated_1( nDx, nDy ) INLINE Qt_QLine_translated_1( ::pPtr, nDx, nDy ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( ... ) CLASS QLine + + ::pPtr := Qt_QLine( ... ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QLine + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQLineF.prg b/harbour/contrib/hbqt/qtcore/TQLineF.prg new file mode 100644 index 0000000000..a5ece06f77 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQLineF.prg @@ -0,0 +1,126 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QLineF + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD p1() INLINE Qt_QLineF_p1( ::pPtr ) + METHOD p2() INLINE Qt_QLineF_p2( ::pPtr ) + METHOD x1() INLINE Qt_QLineF_x1( ::pPtr ) + METHOD x2() INLINE Qt_QLineF_x2( ::pPtr ) + METHOD y1() INLINE Qt_QLineF_y1( ::pPtr ) + METHOD y2() INLINE Qt_QLineF_y2( ::pPtr ) + METHOD angle() INLINE Qt_QLineF_angle( ::pPtr ) + METHOD angleTo( pLine ) INLINE Qt_QLineF_angleTo( ::pPtr, pLine ) + METHOD dx() INLINE Qt_QLineF_dx( ::pPtr ) + METHOD dy() INLINE Qt_QLineF_dy( ::pPtr ) + METHOD intersect( pLine, pIntersectionPoint ) INLINE Qt_QLineF_intersect( ::pPtr, pLine, pIntersectionPoint ) + METHOD isNull() INLINE Qt_QLineF_isNull( ::pPtr ) + METHOD length() INLINE Qt_QLineF_length( ::pPtr ) + METHOD normalVector() INLINE Qt_QLineF_normalVector( ::pPtr ) + METHOD pointAt( nT ) INLINE Qt_QLineF_pointAt( ::pPtr, nT ) + METHOD setP1( pP1 ) INLINE Qt_QLineF_setP1( ::pPtr, pP1 ) + METHOD setP2( pP2 ) INLINE Qt_QLineF_setP2( ::pPtr, pP2 ) + METHOD setAngle( nAngle ) INLINE Qt_QLineF_setAngle( ::pPtr, nAngle ) + METHOD setLength( nLength ) INLINE Qt_QLineF_setLength( ::pPtr, nLength ) + METHOD setLine( nX1, nY1, nX2, nY2 ) INLINE Qt_QLineF_setLine( ::pPtr, nX1, nY1, nX2, nY2 ) + METHOD setPoints( pP1, pP2 ) INLINE Qt_QLineF_setPoints( ::pPtr, pP1, pP2 ) + METHOD toLine() INLINE Qt_QLineF_toLine( ::pPtr ) + METHOD translate( pOffset ) INLINE Qt_QLineF_translate( ::pPtr, pOffset ) + METHOD translate_1( nDx, nDy ) INLINE Qt_QLineF_translate_1( ::pPtr, nDx, nDy ) + METHOD translated( pOffset ) INLINE Qt_QLineF_translated( ::pPtr, pOffset ) + METHOD translated_1( nDx, nDy ) INLINE Qt_QLineF_translated_1( ::pPtr, nDx, nDy ) + METHOD unitVector() INLINE Qt_QLineF_unitVector( ::pPtr ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QLineF + + ::pParent := pParent + + ::pPtr := Qt_QLineF( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QLineF + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQList.prg b/harbour/contrib/hbqt/qtcore/TQList.prg new file mode 100644 index 0000000000..a763591d2d --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQList.prg @@ -0,0 +1,139 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QList + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD append( xValue ) INLINE Qt_QList_append( ::pPtr, xValue ) + METHOD at( nI ) INLINE Qt_QList_at( ::pPtr, nI ) + METHOD back() INLINE Qt_QList_back( ::pPtr ) + METHOD back_1() INLINE Qt_QList_back_1( ::pPtr ) + METHOD clear() INLINE Qt_QList_clear( ::pPtr ) + METHOD count( xValue ) INLINE Qt_QList_count( ::pPtr, xValue ) + METHOD count_1() INLINE Qt_QList_count_1( ::pPtr ) + METHOD empty() INLINE Qt_QList_empty( ::pPtr ) + METHOD endsWith( xValue ) INLINE Qt_QList_endsWith( ::pPtr, xValue ) + METHOD first() INLINE Qt_QList_first( ::pPtr ) + METHOD first_1() INLINE Qt_QList_first_1( ::pPtr ) + METHOD front() INLINE Qt_QList_front( ::pPtr ) + METHOD front_1() INLINE Qt_QList_front_1( ::pPtr ) + METHOD indexOf( xValue, nFrom ) INLINE Qt_QList_indexOf( ::pPtr, xValue, nFrom ) + METHOD insert( nI, xValue ) INLINE Qt_QList_insert( ::pPtr, nI, xValue ) + METHOD isEmpty() INLINE Qt_QList_isEmpty( ::pPtr ) + METHOD last() INLINE Qt_QList_last( ::pPtr ) + METHOD last_1() INLINE Qt_QList_last_1( ::pPtr ) + METHOD lastIndexOf( xValue, nFrom ) INLINE Qt_QList_lastIndexOf( ::pPtr, xValue, nFrom ) + METHOD length() INLINE Qt_QList_length( ::pPtr ) + METHOD move( nFrom, nTo ) INLINE Qt_QList_move( ::pPtr, nFrom, nTo ) + METHOD pop_back() INLINE Qt_QList_pop_back( ::pPtr ) + METHOD pop_front() INLINE Qt_QList_pop_front( ::pPtr ) + METHOD prepend( xValue ) INLINE Qt_QList_prepend( ::pPtr, xValue ) + METHOD push_back( xValue ) INLINE Qt_QList_push_back( ::pPtr, xValue ) + METHOD push_front( xValue ) INLINE Qt_QList_push_front( ::pPtr, xValue ) + METHOD removeAll( xValue ) INLINE Qt_QList_removeAll( ::pPtr, xValue ) + METHOD removeAt( nI ) INLINE Qt_QList_removeAt( ::pPtr, nI ) + METHOD removeFirst() INLINE Qt_QList_removeFirst( ::pPtr ) + METHOD removeLast() INLINE Qt_QList_removeLast( ::pPtr ) + METHOD removeOne( xValue ) INLINE Qt_QList_removeOne( ::pPtr, xValue ) + METHOD replace( nI, xValue ) INLINE Qt_QList_replace( ::pPtr, nI, xValue ) + METHOD size() INLINE Qt_QList_size( ::pPtr ) + METHOD startsWith( xValue ) INLINE Qt_QList_startsWith( ::pPtr, xValue ) + METHOD swap( nI, nJ ) INLINE Qt_QList_swap( ::pPtr, nI, nJ ) + METHOD takeAt( nI ) INLINE Qt_QList_takeAt( ::pPtr, nI ) + METHOD takeFirst() INLINE Qt_QList_takeFirst( ::pPtr ) + METHOD takeLast() INLINE Qt_QList_takeLast( ::pPtr ) + METHOD value( nI ) INLINE Qt_QList_value( ::pPtr, nI ) + METHOD value_1( nI, xDefaultValue ) INLINE Qt_QList_value_1( ::pPtr, nI, xDefaultValue ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QList + + ::pParent := pParent + + ::pPtr := Qt_QList( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QList + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQLocale.prg b/harbour/contrib/hbqt/qtcore/TQLocale.prg new file mode 100644 index 0000000000..964638ba2f --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQLocale.prg @@ -0,0 +1,147 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QLocale + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD amText() INLINE Qt_QLocale_amText( ::pPtr ) + METHOD country() INLINE Qt_QLocale_country( ::pPtr ) + METHOD dateFormat( nFormat ) INLINE Qt_QLocale_dateFormat( ::pPtr, nFormat ) + METHOD dateTimeFormat( nFormat ) INLINE Qt_QLocale_dateTimeFormat( ::pPtr, nFormat ) + METHOD dayName( nDay, nType ) INLINE Qt_QLocale_dayName( ::pPtr, nDay, nType ) + METHOD language() INLINE Qt_QLocale_language( ::pPtr ) + METHOD measurementSystem() INLINE Qt_QLocale_measurementSystem( ::pPtr ) + METHOD monthName( nMonth, nType ) INLINE Qt_QLocale_monthName( ::pPtr, nMonth, nType ) + METHOD name() INLINE Qt_QLocale_name( ::pPtr ) + METHOD numberOptions() INLINE Qt_QLocale_numberOptions( ::pPtr ) + METHOD pmText() INLINE Qt_QLocale_pmText( ::pPtr ) + METHOD setNumberOptions( nOptions ) INLINE Qt_QLocale_setNumberOptions( ::pPtr, nOptions ) + METHOD standaloneDayName( nDay, nType ) INLINE Qt_QLocale_standaloneDayName( ::pPtr, nDay, nType ) + METHOD standaloneMonthName( nMonth, nType ) INLINE Qt_QLocale_standaloneMonthName( ::pPtr, nMonth, nType ) + METHOD timeFormat( nFormat ) INLINE Qt_QLocale_timeFormat( ::pPtr, nFormat ) + METHOD toDate( cString, nFormat ) INLINE Qt_QLocale_toDate( ::pPtr, cString, nFormat ) + METHOD toDate_1( cString, cFormat ) INLINE Qt_QLocale_toDate_1( ::pPtr, cString, cFormat ) + METHOD toDateTime( cString, nFormat ) INLINE Qt_QLocale_toDateTime( ::pPtr, cString, nFormat ) + METHOD toDateTime_1( cString, cFormat ) INLINE Qt_QLocale_toDateTime_1( ::pPtr, cString, cFormat ) + METHOD toDouble( cS, lOk ) INLINE Qt_QLocale_toDouble( ::pPtr, cS, lOk ) + METHOD toFloat( cS, lOk ) INLINE Qt_QLocale_toFloat( ::pPtr, cS, lOk ) + METHOD toInt( cS, lOk, nBase ) INLINE Qt_QLocale_toInt( ::pPtr, cS, lOk, nBase ) + METHOD toLongLong( cS, lOk, nBase ) INLINE Qt_QLocale_toLongLong( ::pPtr, cS, lOk, nBase ) + METHOD toShort( cS, lOk, nBase ) INLINE Qt_QLocale_toShort( ::pPtr, cS, lOk, nBase ) + METHOD toString( nI ) INLINE Qt_QLocale_toString( ::pPtr, nI ) + METHOD toString_1( pDate, cFormat ) INLINE Qt_QLocale_toString_1( ::pPtr, pDate, cFormat ) + METHOD toString_2( pDate, nFormat ) INLINE Qt_QLocale_toString_2( ::pPtr, pDate, nFormat ) + METHOD toString_3( pTime, cFormat ) INLINE Qt_QLocale_toString_3( ::pPtr, pTime, cFormat ) + METHOD toString_4( pTime, nFormat ) INLINE Qt_QLocale_toString_4( ::pPtr, pTime, nFormat ) + METHOD toString_5( pDateTime, nFormat ) INLINE Qt_QLocale_toString_5( ::pPtr, pDateTime, nFormat ) + METHOD toString_6( pDateTime, cFormat ) INLINE Qt_QLocale_toString_6( ::pPtr, pDateTime, cFormat ) + METHOD toString_7( nI ) INLINE Qt_QLocale_toString_7( ::pPtr, nI ) + METHOD toString_8( nI, cF, nPrec ) INLINE Qt_QLocale_toString_8( ::pPtr, nI, cF, nPrec ) + METHOD toString_9( nI ) INLINE Qt_QLocale_toString_9( ::pPtr, nI ) + METHOD toString_10( nI ) INLINE Qt_QLocale_toString_10( ::pPtr, nI ) + METHOD toString_11( nI ) INLINE Qt_QLocale_toString_11( ::pPtr, nI ) + METHOD toString_12( nI ) INLINE Qt_QLocale_toString_12( ::pPtr, nI ) + METHOD toString_13( nI, cF, nPrec ) INLINE Qt_QLocale_toString_13( ::pPtr, nI, cF, nPrec ) + METHOD toTime( cString, nFormat ) INLINE Qt_QLocale_toTime( ::pPtr, cString, nFormat ) + METHOD toTime_1( cString, cFormat ) INLINE Qt_QLocale_toTime_1( ::pPtr, cString, cFormat ) + METHOD toUInt( cS, lOk, nBase ) INLINE Qt_QLocale_toUInt( ::pPtr, cS, lOk, nBase ) + METHOD toULongLong( cS, lOk, nBase ) INLINE Qt_QLocale_toULongLong( ::pPtr, cS, lOk, nBase ) + METHOD toUShort( cS, lOk, nBase ) INLINE Qt_QLocale_toUShort( ::pPtr, cS, lOk, nBase ) + METHOD c() INLINE Qt_QLocale_c( ::pPtr ) + METHOD countryToString( nCountry ) INLINE Qt_QLocale_countryToString( ::pPtr, nCountry ) + METHOD languageToString( nLanguage ) INLINE Qt_QLocale_languageToString( ::pPtr, nLanguage ) + METHOD setDefault( pLocale ) INLINE Qt_QLocale_setDefault( ::pPtr, pLocale ) + METHOD system() INLINE Qt_QLocale_system( ::pPtr ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QLocale + + ::pParent := pParent + + ::pPtr := Qt_QLocale( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QLocale + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQMimeData.prg b/harbour/contrib/hbqt/qtcore/TQMimeData.prg new file mode 100644 index 0000000000..427c94ee96 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQMimeData.prg @@ -0,0 +1,118 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QMimeData INHERIT QObject + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD clear() INLINE Qt_QMimeData_clear( ::pPtr ) + METHOD colorData() INLINE Qt_QMimeData_colorData( ::pPtr ) + METHOD data( cMimeType ) INLINE Qt_QMimeData_data( ::pPtr, cMimeType ) + METHOD formats() INLINE Qt_QMimeData_formats( ::pPtr ) + METHOD hasColor() INLINE Qt_QMimeData_hasColor( ::pPtr ) + METHOD hasFormat( cMimeType ) INLINE Qt_QMimeData_hasFormat( ::pPtr, cMimeType ) + METHOD hasHtml() INLINE Qt_QMimeData_hasHtml( ::pPtr ) + METHOD hasImage() INLINE Qt_QMimeData_hasImage( ::pPtr ) + METHOD hasText() INLINE Qt_QMimeData_hasText( ::pPtr ) + METHOD hasUrls() INLINE Qt_QMimeData_hasUrls( ::pPtr ) + METHOD html() INLINE Qt_QMimeData_html( ::pPtr ) + METHOD imageData() INLINE Qt_QMimeData_imageData( ::pPtr ) + METHOD removeFormat( cMimeType ) INLINE Qt_QMimeData_removeFormat( ::pPtr, cMimeType ) + METHOD setColorData( pColor ) INLINE Qt_QMimeData_setColorData( ::pPtr, pColor ) + METHOD setData( cMimeType, pData ) INLINE Qt_QMimeData_setData( ::pPtr, cMimeType, pData ) + METHOD setHtml( cHtml ) INLINE Qt_QMimeData_setHtml( ::pPtr, cHtml ) + METHOD setImageData( pImage ) INLINE Qt_QMimeData_setImageData( ::pPtr, pImage ) + METHOD setText( cText ) INLINE Qt_QMimeData_setText( ::pPtr, cText ) + METHOD text() INLINE Qt_QMimeData_text( ::pPtr ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QMimeData + + ::pParent := pParent + + ::pPtr := Qt_QMimeData( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QMimeData + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQModelIndex.prg b/harbour/contrib/hbqt/qtcore/TQModelIndex.prg new file mode 100644 index 0000000000..11fdaef8a4 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQModelIndex.prg @@ -0,0 +1,110 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QModelIndex + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD child( nRow, nColumn ) INLINE Qt_QModelIndex_child( ::pPtr, nRow, nColumn ) + METHOD column() INLINE Qt_QModelIndex_column( ::pPtr ) + METHOD data( nRole ) INLINE Qt_QModelIndex_data( ::pPtr, nRole ) + METHOD flags() INLINE Qt_QModelIndex_flags( ::pPtr ) + METHOD internalId() INLINE Qt_QModelIndex_internalId( ::pPtr ) + METHOD internalPointer() INLINE Qt_QModelIndex_internalPointer( ::pPtr ) + METHOD isValid() INLINE Qt_QModelIndex_isValid( ::pPtr ) + METHOD model() INLINE Qt_QModelIndex_model( ::pPtr ) + METHOD parent() INLINE Qt_QModelIndex_parent( ::pPtr ) + METHOD row() INLINE Qt_QModelIndex_row( ::pPtr ) + METHOD sibling( nRow, nColumn ) INLINE Qt_QModelIndex_sibling( ::pPtr, nRow, nColumn ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QModelIndex + + ::pParent := pParent + + ::pPtr := Qt_QModelIndex( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QModelIndex + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQObject.prg b/harbour/contrib/hbqt/qtcore/TQObject.prg new file mode 100644 index 0000000000..299ddd7d7f --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQObject.prg @@ -0,0 +1,128 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QObject + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD blockSignals( lBlock ) INLINE Qt_QObject_blockSignals( ::pPtr, lBlock ) + METHOD connect( pSender, pSignal, pMethod, nType ) INLINE Qt_QObject_connect( ::pPtr, pSender, pSignal, pMethod, nType ) + METHOD disconnect( pSignal, pReceiver, pMethod ) INLINE Qt_QObject_disconnect( ::pPtr, pSignal, pReceiver, pMethod ) + METHOD disconnect_1( pReceiver, pMethod ) INLINE Qt_QObject_disconnect_1( ::pPtr, pReceiver, pMethod ) + METHOD dumpObjectInfo() INLINE Qt_QObject_dumpObjectInfo( ::pPtr ) + METHOD dumpObjectTree() INLINE Qt_QObject_dumpObjectTree( ::pPtr ) + METHOD event( pE ) INLINE Qt_QObject_event( ::pPtr, pE ) + METHOD eventFilter( pWatched, pEvent ) INLINE Qt_QObject_eventFilter( ::pPtr, pWatched, pEvent ) + METHOD inherits( pClassName ) INLINE Qt_QObject_inherits( ::pPtr, pClassName ) + METHOD installEventFilter( pFilterObj ) INLINE Qt_QObject_installEventFilter( ::pPtr, pFilterObj ) + METHOD isWidgetType() INLINE Qt_QObject_isWidgetType( ::pPtr ) + METHOD killTimer( nId ) INLINE Qt_QObject_killTimer( ::pPtr, nId ) + METHOD metaObject() INLINE Qt_QObject_metaObject( ::pPtr ) + METHOD moveToThread( pTargetThread ) INLINE Qt_QObject_moveToThread( ::pPtr, pTargetThread ) + METHOD objectName() INLINE Qt_QObject_objectName( ::pPtr ) + METHOD parent() INLINE Qt_QObject_parent( ::pPtr ) + METHOD property( pName ) INLINE Qt_QObject_property( ::pPtr, pName ) + METHOD removeEventFilter( pObj ) INLINE Qt_QObject_removeEventFilter( ::pPtr, pObj ) + METHOD setObjectName( cName ) INLINE Qt_QObject_setObjectName( ::pPtr, cName ) + METHOD setParent( pParent ) INLINE Qt_QObject_setParent( ::pPtr, pParent ) + METHOD setProperty( pName, pValue ) INLINE Qt_QObject_setProperty( ::pPtr, pName, pValue ) + METHOD signalsBlocked() INLINE Qt_QObject_signalsBlocked( ::pPtr ) + METHOD startTimer( nInterval ) INLINE Qt_QObject_startTimer( ::pPtr, nInterval ) + METHOD thread() INLINE Qt_QObject_thread( ::pPtr ) + METHOD connect_1( pSender, pSignal, pReceiver, pMethod, nType ) INLINE Qt_QObject_connect_1( ::pPtr, pSender, pSignal, pReceiver, pMethod, nType ) + METHOD disconnect_2( pSender, pSignal, pReceiver, pMethod ) INLINE Qt_QObject_disconnect_2( ::pPtr, pSender, pSignal, pReceiver, pMethod ) + METHOD tr( pSourceText, pDisambiguation, nN ) INLINE Qt_QObject_tr( ::pPtr, pSourceText, pDisambiguation, nN ) + METHOD trUtf8( pSourceText, pDisambiguation, nN ) INLINE Qt_QObject_trUtf8( ::pPtr, pSourceText, pDisambiguation, nN ) + METHOD deleteLater() INLINE Qt_QObject_deleteLater( ::pPtr ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QObject + + ::pParent := pParent + + ::pPtr := Qt_QObject( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QObject + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQPoint.prg b/harbour/contrib/hbqt/qtcore/TQPoint.prg new file mode 100644 index 0000000000..aa38d20a9c --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQPoint.prg @@ -0,0 +1,105 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QPoint + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD isNull() INLINE Qt_QPoint_isNull( ::pPtr ) + METHOD manhattanLength() INLINE Qt_QPoint_manhattanLength( ::pPtr ) + METHOD rx() INLINE Qt_QPoint_rx( ::pPtr ) + METHOD ry() INLINE Qt_QPoint_ry( ::pPtr ) + METHOD setX( nX ) INLINE Qt_QPoint_setX( ::pPtr, nX ) + METHOD setY( nY ) INLINE Qt_QPoint_setY( ::pPtr, nY ) + METHOD x() INLINE Qt_QPoint_x( ::pPtr ) + METHOD y() INLINE Qt_QPoint_y( ::pPtr ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( ... ) CLASS QPoint + + ::pPtr := Qt_QPoint( ... ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QPoint + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQPointF.prg b/harbour/contrib/hbqt/qtcore/TQPointF.prg new file mode 100644 index 0000000000..a7018d3f36 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQPointF.prg @@ -0,0 +1,105 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QPointF + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD isNull() INLINE Qt_QPointF_isNull( ::pPtr ) + METHOD rx() INLINE Qt_QPointF_rx( ::pPtr ) + METHOD ry() INLINE Qt_QPointF_ry( ::pPtr ) + METHOD setX( nX ) INLINE Qt_QPointF_setX( ::pPtr, nX ) + METHOD setY( nY ) INLINE Qt_QPointF_setY( ::pPtr, nY ) + METHOD toPoint() INLINE Qt_QPointF_toPoint( ::pPtr ) + METHOD x() INLINE Qt_QPointF_x( ::pPtr ) + METHOD y() INLINE Qt_QPointF_y( ::pPtr ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( ... ) CLASS QPointF + + ::pPtr := Qt_QPointF( ... ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QPointF + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQProcess.prg b/harbour/contrib/hbqt/qtcore/TQProcess.prg new file mode 100644 index 0000000000..988cccb9ac --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQProcess.prg @@ -0,0 +1,132 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QProcess INHERIT QIODevice + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD close() INLINE Qt_QProcess_close( ::pPtr ) + METHOD closeReadChannel( nChannel ) INLINE Qt_QProcess_closeReadChannel( ::pPtr, nChannel ) + METHOD closeWriteChannel() INLINE Qt_QProcess_closeWriteChannel( ::pPtr ) + METHOD environment() INLINE Qt_QProcess_environment( ::pPtr ) + METHOD error() INLINE Qt_QProcess_error( ::pPtr ) + METHOD exitCode() INLINE Qt_QProcess_exitCode( ::pPtr ) + METHOD exitStatus() INLINE Qt_QProcess_exitStatus( ::pPtr ) + METHOD processChannelMode() INLINE Qt_QProcess_processChannelMode( ::pPtr ) + METHOD readAllStandardError() INLINE Qt_QProcess_readAllStandardError( ::pPtr ) + METHOD readAllStandardOutput() INLINE Qt_QProcess_readAllStandardOutput( ::pPtr ) + METHOD readChannel() INLINE Qt_QProcess_readChannel( ::pPtr ) + METHOD setEnvironment( pEnvironment ) INLINE Qt_QProcess_setEnvironment( ::pPtr, pEnvironment ) + METHOD setProcessChannelMode( nMode ) INLINE Qt_QProcess_setProcessChannelMode( ::pPtr, nMode ) + METHOD setReadChannel( nChannel ) INLINE Qt_QProcess_setReadChannel( ::pPtr, nChannel ) + METHOD setStandardErrorFile( cFileName, nMode ) INLINE Qt_QProcess_setStandardErrorFile( ::pPtr, cFileName, nMode ) + METHOD setStandardInputFile( cFileName ) INLINE Qt_QProcess_setStandardInputFile( ::pPtr, cFileName ) + METHOD setStandardOutputFile( cFileName, nMode ) INLINE Qt_QProcess_setStandardOutputFile( ::pPtr, cFileName, nMode ) + METHOD setStandardOutputProcess( pDestination ) INLINE Qt_QProcess_setStandardOutputProcess( ::pPtr, pDestination ) + METHOD setWorkingDirectory( cDir ) INLINE Qt_QProcess_setWorkingDirectory( ::pPtr, cDir ) + METHOD start( cProgram, pArguments, nMode ) INLINE Qt_QProcess_start( ::pPtr, cProgram, pArguments, nMode ) + METHOD start_1( cProgram, nMode ) INLINE Qt_QProcess_start_1( ::pPtr, cProgram, nMode ) + METHOD state() INLINE Qt_QProcess_state( ::pPtr ) + METHOD waitForFinished( nMsecs ) INLINE Qt_QProcess_waitForFinished( ::pPtr, nMsecs ) + METHOD waitForStarted( nMsecs ) INLINE Qt_QProcess_waitForStarted( ::pPtr, nMsecs ) + METHOD workingDirectory() INLINE Qt_QProcess_workingDirectory( ::pPtr ) + METHOD execute( cProgram, pArguments ) INLINE Qt_QProcess_execute( ::pPtr, cProgram, pArguments ) + METHOD execute_1( cProgram ) INLINE Qt_QProcess_execute_1( ::pPtr, cProgram ) + METHOD startDetached( cProgram, pArguments, cWorkingDirectory, nPid ) INLINE Qt_QProcess_startDetached( ::pPtr, cProgram, pArguments, cWorkingDirectory, nPid ) + METHOD startDetached_1( cProgram, pArguments ) INLINE Qt_QProcess_startDetached_1( ::pPtr, cProgram, pArguments ) + METHOD startDetached_2( cProgram ) INLINE Qt_QProcess_startDetached_2( ::pPtr, cProgram ) + METHOD systemEnvironment() INLINE Qt_QProcess_systemEnvironment( ::pPtr ) + METHOD kill() INLINE Qt_QProcess_kill( ::pPtr ) + METHOD terminate() INLINE Qt_QProcess_terminate( ::pPtr ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QProcess + + ::pParent := pParent + + ::pPtr := Qt_QProcess( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QProcess + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQRect.prg b/harbour/contrib/hbqt/qtcore/TQRect.prg new file mode 100644 index 0000000000..493029751c --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQRect.prg @@ -0,0 +1,156 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QRect + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD adjust( nDx1, nDy1, nDx2, nDy2 ) INLINE Qt_QRect_adjust( ::pPtr, nDx1, nDy1, nDx2, nDy2 ) + METHOD adjusted( nDx1, nDy1, nDx2, nDy2 ) INLINE Qt_QRect_adjusted( ::pPtr, nDx1, nDy1, nDx2, nDy2 ) + METHOD bottom() INLINE Qt_QRect_bottom( ::pPtr ) + METHOD bottomLeft() INLINE Qt_QRect_bottomLeft( ::pPtr ) + METHOD bottomRight() INLINE Qt_QRect_bottomRight( ::pPtr ) + METHOD center() INLINE Qt_QRect_center( ::pPtr ) + METHOD contains( pPoint, lProper ) INLINE Qt_QRect_contains( ::pPtr, pPoint, lProper ) + METHOD contains_1( nX, nY, lProper ) INLINE Qt_QRect_contains_1( ::pPtr, nX, nY, lProper ) + METHOD contains_2( nX, nY ) INLINE Qt_QRect_contains_2( ::pPtr, nX, nY ) + METHOD contains_3( pRectangle, lProper ) INLINE Qt_QRect_contains_3( ::pPtr, pRectangle, lProper ) + METHOD getCoords( nX1, nY1, nX2, nY2 ) INLINE Qt_QRect_getCoords( ::pPtr, nX1, nY1, nX2, nY2 ) + METHOD getRect( nX, nY, nWidth, nHeight ) INLINE Qt_QRect_getRect( ::pPtr, nX, nY, nWidth, nHeight ) + METHOD height() INLINE Qt_QRect_height( ::pPtr ) + METHOD intersected( pRectangle ) INLINE Qt_QRect_intersected( ::pPtr, pRectangle ) + METHOD intersects( pRectangle ) INLINE Qt_QRect_intersects( ::pPtr, pRectangle ) + METHOD isEmpty() INLINE Qt_QRect_isEmpty( ::pPtr ) + METHOD isNull() INLINE Qt_QRect_isNull( ::pPtr ) + METHOD isValid() INLINE Qt_QRect_isValid( ::pPtr ) + METHOD left() INLINE Qt_QRect_left( ::pPtr ) + METHOD moveBottom( nY ) INLINE Qt_QRect_moveBottom( ::pPtr, nY ) + METHOD moveBottomLeft( pPosition ) INLINE Qt_QRect_moveBottomLeft( ::pPtr, pPosition ) + METHOD moveBottomRight( pPosition ) INLINE Qt_QRect_moveBottomRight( ::pPtr, pPosition ) + METHOD moveCenter( pPosition ) INLINE Qt_QRect_moveCenter( ::pPtr, pPosition ) + METHOD moveLeft( nX ) INLINE Qt_QRect_moveLeft( ::pPtr, nX ) + METHOD moveRight( nX ) INLINE Qt_QRect_moveRight( ::pPtr, nX ) + METHOD moveTo( nX, nY ) INLINE Qt_QRect_moveTo( ::pPtr, nX, nY ) + METHOD moveTo_1( pPosition ) INLINE Qt_QRect_moveTo_1( ::pPtr, pPosition ) + METHOD moveTop( nY ) INLINE Qt_QRect_moveTop( ::pPtr, nY ) + METHOD moveTopLeft( pPosition ) INLINE Qt_QRect_moveTopLeft( ::pPtr, pPosition ) + METHOD moveTopRight( pPosition ) INLINE Qt_QRect_moveTopRight( ::pPtr, pPosition ) + METHOD normalized() INLINE Qt_QRect_normalized( ::pPtr ) + METHOD right() INLINE Qt_QRect_right( ::pPtr ) + METHOD setBottom( nY ) INLINE Qt_QRect_setBottom( ::pPtr, nY ) + METHOD setBottomLeft( pPosition ) INLINE Qt_QRect_setBottomLeft( ::pPtr, pPosition ) + METHOD setBottomRight( pPosition ) INLINE Qt_QRect_setBottomRight( ::pPtr, pPosition ) + METHOD setCoords( nX1, nY1, nX2, nY2 ) INLINE Qt_QRect_setCoords( ::pPtr, nX1, nY1, nX2, nY2 ) + METHOD setHeight( nHeight ) INLINE Qt_QRect_setHeight( ::pPtr, nHeight ) + METHOD setLeft( nX ) INLINE Qt_QRect_setLeft( ::pPtr, nX ) + METHOD setRect( nX, nY, nWidth, nHeight ) INLINE Qt_QRect_setRect( ::pPtr, nX, nY, nWidth, nHeight ) + METHOD setRight( nX ) INLINE Qt_QRect_setRight( ::pPtr, nX ) + METHOD setSize( pSize ) INLINE Qt_QRect_setSize( ::pPtr, pSize ) + METHOD setTop( nY ) INLINE Qt_QRect_setTop( ::pPtr, nY ) + METHOD setTopLeft( pPosition ) INLINE Qt_QRect_setTopLeft( ::pPtr, pPosition ) + METHOD setTopRight( pPosition ) INLINE Qt_QRect_setTopRight( ::pPtr, pPosition ) + METHOD setWidth( nWidth ) INLINE Qt_QRect_setWidth( ::pPtr, nWidth ) + METHOD setX( nX ) INLINE Qt_QRect_setX( ::pPtr, nX ) + METHOD setY( nY ) INLINE Qt_QRect_setY( ::pPtr, nY ) + METHOD size() INLINE Qt_QRect_size( ::pPtr ) + METHOD top() INLINE Qt_QRect_top( ::pPtr ) + METHOD topLeft() INLINE Qt_QRect_topLeft( ::pPtr ) + METHOD topRight() INLINE Qt_QRect_topRight( ::pPtr ) + METHOD translate( nDx, nDy ) INLINE Qt_QRect_translate( ::pPtr, nDx, nDy ) + METHOD translate_1( pOffset ) INLINE Qt_QRect_translate_1( ::pPtr, pOffset ) + METHOD translated( nDx, nDy ) INLINE Qt_QRect_translated( ::pPtr, nDx, nDy ) + METHOD translated_1( pOffset ) INLINE Qt_QRect_translated_1( ::pPtr, pOffset ) + METHOD united( pRectangle ) INLINE Qt_QRect_united( ::pPtr, pRectangle ) + METHOD width() INLINE Qt_QRect_width( ::pPtr ) + METHOD x() INLINE Qt_QRect_x( ::pPtr ) + METHOD y() INLINE Qt_QRect_y( ::pPtr ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( ... ) CLASS QRect + + ::pPtr := Qt_QRect( ... ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QRect + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQRectF.prg b/harbour/contrib/hbqt/qtcore/TQRectF.prg new file mode 100644 index 0000000000..8118743c11 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQRectF.prg @@ -0,0 +1,157 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QRectF + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD adjust( nDx1, nDy1, nDx2, nDy2 ) INLINE Qt_QRectF_adjust( ::pPtr, nDx1, nDy1, nDx2, nDy2 ) + METHOD adjusted( nDx1, nDy1, nDx2, nDy2 ) INLINE Qt_QRectF_adjusted( ::pPtr, nDx1, nDy1, nDx2, nDy2 ) + METHOD bottom() INLINE Qt_QRectF_bottom( ::pPtr ) + METHOD bottomLeft() INLINE Qt_QRectF_bottomLeft( ::pPtr ) + METHOD bottomRight() INLINE Qt_QRectF_bottomRight( ::pPtr ) + METHOD center() INLINE Qt_QRectF_center( ::pPtr ) + METHOD contains( pPoint ) INLINE Qt_QRectF_contains( ::pPtr, pPoint ) + METHOD contains_1( nX, nY ) INLINE Qt_QRectF_contains_1( ::pPtr, nX, nY ) + METHOD contains_2( pRectangle ) INLINE Qt_QRectF_contains_2( ::pPtr, pRectangle ) + METHOD getCoords( nX1, nY1, nX2, nY2 ) INLINE Qt_QRectF_getCoords( ::pPtr, nX1, nY1, nX2, nY2 ) + METHOD getRect( nX, nY, nWidth, nHeight ) INLINE Qt_QRectF_getRect( ::pPtr, nX, nY, nWidth, nHeight ) + METHOD height() INLINE Qt_QRectF_height( ::pPtr ) + METHOD intersected( pRectangle ) INLINE Qt_QRectF_intersected( ::pPtr, pRectangle ) + METHOD intersects( pRectangle ) INLINE Qt_QRectF_intersects( ::pPtr, pRectangle ) + METHOD isEmpty() INLINE Qt_QRectF_isEmpty( ::pPtr ) + METHOD isNull() INLINE Qt_QRectF_isNull( ::pPtr ) + METHOD isValid() INLINE Qt_QRectF_isValid( ::pPtr ) + METHOD left() INLINE Qt_QRectF_left( ::pPtr ) + METHOD moveBottom( nY ) INLINE Qt_QRectF_moveBottom( ::pPtr, nY ) + METHOD moveBottomLeft( pPosition ) INLINE Qt_QRectF_moveBottomLeft( ::pPtr, pPosition ) + METHOD moveBottomRight( pPosition ) INLINE Qt_QRectF_moveBottomRight( ::pPtr, pPosition ) + METHOD moveCenter( pPosition ) INLINE Qt_QRectF_moveCenter( ::pPtr, pPosition ) + METHOD moveLeft( nX ) INLINE Qt_QRectF_moveLeft( ::pPtr, nX ) + METHOD moveRight( nX ) INLINE Qt_QRectF_moveRight( ::pPtr, nX ) + METHOD moveTo( nX, nY ) INLINE Qt_QRectF_moveTo( ::pPtr, nX, nY ) + METHOD moveTo_1( pPosition ) INLINE Qt_QRectF_moveTo_1( ::pPtr, pPosition ) + METHOD moveTop( nY ) INLINE Qt_QRectF_moveTop( ::pPtr, nY ) + METHOD moveTopLeft( pPosition ) INLINE Qt_QRectF_moveTopLeft( ::pPtr, pPosition ) + METHOD moveTopRight( pPosition ) INLINE Qt_QRectF_moveTopRight( ::pPtr, pPosition ) + METHOD normalized() INLINE Qt_QRectF_normalized( ::pPtr ) + METHOD right() INLINE Qt_QRectF_right( ::pPtr ) + METHOD setBottom( nY ) INLINE Qt_QRectF_setBottom( ::pPtr, nY ) + METHOD setBottomLeft( pPosition ) INLINE Qt_QRectF_setBottomLeft( ::pPtr, pPosition ) + METHOD setBottomRight( pPosition ) INLINE Qt_QRectF_setBottomRight( ::pPtr, pPosition ) + METHOD setCoords( nX1, nY1, nX2, nY2 ) INLINE Qt_QRectF_setCoords( ::pPtr, nX1, nY1, nX2, nY2 ) + METHOD setHeight( nHeight ) INLINE Qt_QRectF_setHeight( ::pPtr, nHeight ) + METHOD setLeft( nX ) INLINE Qt_QRectF_setLeft( ::pPtr, nX ) + METHOD setRect( nX, nY, nWidth, nHeight ) INLINE Qt_QRectF_setRect( ::pPtr, nX, nY, nWidth, nHeight ) + METHOD setRight( nX ) INLINE Qt_QRectF_setRight( ::pPtr, nX ) + METHOD setSize( pSize ) INLINE Qt_QRectF_setSize( ::pPtr, pSize ) + METHOD setTop( nY ) INLINE Qt_QRectF_setTop( ::pPtr, nY ) + METHOD setTopLeft( pPosition ) INLINE Qt_QRectF_setTopLeft( ::pPtr, pPosition ) + METHOD setTopRight( pPosition ) INLINE Qt_QRectF_setTopRight( ::pPtr, pPosition ) + METHOD setWidth( nWidth ) INLINE Qt_QRectF_setWidth( ::pPtr, nWidth ) + METHOD setX( nX ) INLINE Qt_QRectF_setX( ::pPtr, nX ) + METHOD setY( nY ) INLINE Qt_QRectF_setY( ::pPtr, nY ) + METHOD size() INLINE Qt_QRectF_size( ::pPtr ) + METHOD toAlignedRect() INLINE Qt_QRectF_toAlignedRect( ::pPtr ) + METHOD toRect() INLINE Qt_QRectF_toRect( ::pPtr ) + METHOD top() INLINE Qt_QRectF_top( ::pPtr ) + METHOD topLeft() INLINE Qt_QRectF_topLeft( ::pPtr ) + METHOD topRight() INLINE Qt_QRectF_topRight( ::pPtr ) + METHOD translate( nDx, nDy ) INLINE Qt_QRectF_translate( ::pPtr, nDx, nDy ) + METHOD translate_1( pOffset ) INLINE Qt_QRectF_translate_1( ::pPtr, pOffset ) + METHOD translated( nDx, nDy ) INLINE Qt_QRectF_translated( ::pPtr, nDx, nDy ) + METHOD translated_1( pOffset ) INLINE Qt_QRectF_translated_1( ::pPtr, pOffset ) + METHOD united( pRectangle ) INLINE Qt_QRectF_united( ::pPtr, pRectangle ) + METHOD width() INLINE Qt_QRectF_width( ::pPtr ) + METHOD x() INLINE Qt_QRectF_x( ::pPtr ) + METHOD y() INLINE Qt_QRectF_y( ::pPtr ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( ... ) CLASS QRectF + + ::pPtr := Qt_QRectF( ... ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QRectF + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQRegExp.prg b/harbour/contrib/hbqt/qtcore/TQRegExp.prg new file mode 100644 index 0000000000..309b3a66a9 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQRegExp.prg @@ -0,0 +1,118 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QRegExp + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD cap( nNth ) INLINE Qt_QRegExp_cap( ::pPtr, nNth ) + METHOD capturedTexts() INLINE Qt_QRegExp_capturedTexts( ::pPtr ) + METHOD caseSensitivity() INLINE Qt_QRegExp_caseSensitivity( ::pPtr ) + METHOD errorString() INLINE Qt_QRegExp_errorString( ::pPtr ) + METHOD exactMatch( cStr ) INLINE Qt_QRegExp_exactMatch( ::pPtr, cStr ) + METHOD indexIn( cStr, nOffset, nCaretMode ) INLINE Qt_QRegExp_indexIn( ::pPtr, cStr, nOffset, nCaretMode ) + METHOD isEmpty() INLINE Qt_QRegExp_isEmpty( ::pPtr ) + METHOD isMinimal() INLINE Qt_QRegExp_isMinimal( ::pPtr ) + METHOD isValid() INLINE Qt_QRegExp_isValid( ::pPtr ) + METHOD lastIndexIn( cStr, nOffset, nCaretMode ) INLINE Qt_QRegExp_lastIndexIn( ::pPtr, cStr, nOffset, nCaretMode ) + METHOD matchedLength() INLINE Qt_QRegExp_matchedLength( ::pPtr ) + METHOD numCaptures() INLINE Qt_QRegExp_numCaptures( ::pPtr ) + METHOD pattern() INLINE Qt_QRegExp_pattern( ::pPtr ) + METHOD patternSyntax() INLINE Qt_QRegExp_patternSyntax( ::pPtr ) + METHOD pos( nNth ) INLINE Qt_QRegExp_pos( ::pPtr, nNth ) + METHOD setCaseSensitivity( nCs ) INLINE Qt_QRegExp_setCaseSensitivity( ::pPtr, nCs ) + METHOD setMinimal( lMinimal ) INLINE Qt_QRegExp_setMinimal( ::pPtr, lMinimal ) + METHOD setPattern( cPattern ) INLINE Qt_QRegExp_setPattern( ::pPtr, cPattern ) + METHOD setPatternSyntax( nSyntax ) INLINE Qt_QRegExp_setPatternSyntax( ::pPtr, nSyntax ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QRegExp + + ::pParent := pParent + + ::pPtr := Qt_QRegExp( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QRegExp + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQResource.prg b/harbour/contrib/hbqt/qtcore/TQResource.prg new file mode 100644 index 0000000000..962e521484 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQResource.prg @@ -0,0 +1,111 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QResource + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD absoluteFilePath() INLINE Qt_QResource_absoluteFilePath( ::pPtr ) + METHOD data() INLINE Qt_QResource_data( ::pPtr ) + METHOD fileName() INLINE Qt_QResource_fileName( ::pPtr ) + METHOD isCompressed() INLINE Qt_QResource_isCompressed( ::pPtr ) + METHOD isValid() INLINE Qt_QResource_isValid( ::pPtr ) + METHOD locale() INLINE Qt_QResource_locale( ::pPtr ) + METHOD setFileName( cFile ) INLINE Qt_QResource_setFileName( ::pPtr, cFile ) + METHOD setLocale( pLocale ) INLINE Qt_QResource_setLocale( ::pPtr, pLocale ) + METHOD size() INLINE Qt_QResource_size( ::pPtr ) + METHOD registerResource( cRccFileName, cMapRoot ) INLINE Qt_QResource_registerResource( ::pPtr, cRccFileName, cMapRoot ) + METHOD searchPaths() INLINE Qt_QResource_searchPaths( ::pPtr ) + METHOD unregisterResource( cRccFileName, cMapRoot ) INLINE Qt_QResource_unregisterResource( ::pPtr, cRccFileName, cMapRoot ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QResource + + ::pParent := pParent + + ::pPtr := Qt_QResource( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QResource + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQSignalMapper.prg b/harbour/contrib/hbqt/qtcore/TQSignalMapper.prg new file mode 100644 index 0000000000..8cbdcfe831 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQSignalMapper.prg @@ -0,0 +1,110 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QSignalMapper INHERIT QObject + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD mapping( nId ) INLINE Qt_QSignalMapper_mapping( ::pPtr, nId ) + METHOD mapping_1( cId ) INLINE Qt_QSignalMapper_mapping_1( ::pPtr, cId ) + METHOD mapping_2( pWidget ) INLINE Qt_QSignalMapper_mapping_2( ::pPtr, pWidget ) + METHOD mapping_3( pObject ) INLINE Qt_QSignalMapper_mapping_3( ::pPtr, pObject ) + METHOD removeMappings( pSender ) INLINE Qt_QSignalMapper_removeMappings( ::pPtr, pSender ) + METHOD setMapping( pSender, nId ) INLINE Qt_QSignalMapper_setMapping( ::pPtr, pSender, nId ) + METHOD setMapping_1( pSender, cText ) INLINE Qt_QSignalMapper_setMapping_1( ::pPtr, pSender, cText ) + METHOD setMapping_2( pSender, pWidget ) INLINE Qt_QSignalMapper_setMapping_2( ::pPtr, pSender, pWidget ) + METHOD setMapping_3( pSender, pObject ) INLINE Qt_QSignalMapper_setMapping_3( ::pPtr, pSender, pObject ) + METHOD map() INLINE Qt_QSignalMapper_map( ::pPtr ) + METHOD map_1( pSender ) INLINE Qt_QSignalMapper_map_1( ::pPtr, pSender ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QSignalMapper + + ::pParent := pParent + + ::pPtr := Qt_QSignalMapper( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QSignalMapper + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQSize.prg b/harbour/contrib/hbqt/qtcore/TQSize.prg new file mode 100644 index 0000000000..40585343ef --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQSize.prg @@ -0,0 +1,111 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QSize + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD height() INLINE Qt_QSize_height( ::pPtr ) + METHOD isEmpty() INLINE Qt_QSize_isEmpty( ::pPtr ) + METHOD isNull() INLINE Qt_QSize_isNull( ::pPtr ) + METHOD isValid() INLINE Qt_QSize_isValid( ::pPtr ) + METHOD rheight() INLINE Qt_QSize_rheight( ::pPtr ) + METHOD rwidth() INLINE Qt_QSize_rwidth( ::pPtr ) + METHOD scale( nWidth, nHeight, nMode ) INLINE Qt_QSize_scale( ::pPtr, nWidth, nHeight, nMode ) + METHOD scale_1( pSize, nMode ) INLINE Qt_QSize_scale_1( ::pPtr, pSize, nMode ) + METHOD setHeight( nHeight ) INLINE Qt_QSize_setHeight( ::pPtr, nHeight ) + METHOD setWidth( nWidth ) INLINE Qt_QSize_setWidth( ::pPtr, nWidth ) + METHOD transpose() INLINE Qt_QSize_transpose( ::pPtr ) + METHOD width() INLINE Qt_QSize_width( ::pPtr ) + METHOD boundedTo( pOtherSize ) INLINE Qt_QSize_boundedTo( ::pPtr, pOtherSize ) + METHOD expandedTo( pOtherSize ) INLINE Qt_QSize_expandedTo( ::pPtr, pOtherSize ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( ... ) CLASS QSize + + ::pPtr := Qt_QSize( ... ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QSize + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQSizeF.prg b/harbour/contrib/hbqt/qtcore/TQSizeF.prg new file mode 100644 index 0000000000..aa20aad9b9 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQSizeF.prg @@ -0,0 +1,112 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QSizeF + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD boundedTo( pOtherSize ) INLINE Qt_QSizeF_boundedTo( ::pPtr, pOtherSize ) + METHOD expandedTo( pOtherSize ) INLINE Qt_QSizeF_expandedTo( ::pPtr, pOtherSize ) + METHOD height() INLINE Qt_QSizeF_height( ::pPtr ) + METHOD isEmpty() INLINE Qt_QSizeF_isEmpty( ::pPtr ) + METHOD isNull() INLINE Qt_QSizeF_isNull( ::pPtr ) + METHOD isValid() INLINE Qt_QSizeF_isValid( ::pPtr ) + METHOD rheight() INLINE Qt_QSizeF_rheight( ::pPtr ) + METHOD rwidth() INLINE Qt_QSizeF_rwidth( ::pPtr ) + METHOD scale( nWidth, nHeight, nMode ) INLINE Qt_QSizeF_scale( ::pPtr, nWidth, nHeight, nMode ) + METHOD scale_1( pSize, nMode ) INLINE Qt_QSizeF_scale_1( ::pPtr, pSize, nMode ) + METHOD setHeight( nHeight ) INLINE Qt_QSizeF_setHeight( ::pPtr, nHeight ) + METHOD setWidth( nWidth ) INLINE Qt_QSizeF_setWidth( ::pPtr, nWidth ) + METHOD toSize() INLINE Qt_QSizeF_toSize( ::pPtr ) + METHOD transpose() INLINE Qt_QSizeF_transpose( ::pPtr ) + METHOD width() INLINE Qt_QSizeF_width( ::pPtr ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( ... ) CLASS QSizeF + + ::pPtr := Qt_QSizeF( ... ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QSizeF + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQStringList.prg b/harbour/contrib/hbqt/qtcore/TQStringList.prg new file mode 100644 index 0000000000..9e4ae8d1db --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQStringList.prg @@ -0,0 +1,134 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QStringList INHERIT QList + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD append( cValue ) INLINE Qt_QStringList_append( ::pPtr, cValue ) + METHOD filter( cStr, nCs ) INLINE Qt_QStringList_filter( ::pPtr, cStr, nCs ) + METHOD filter_1( pRx ) INLINE Qt_QStringList_filter_1( ::pPtr, pRx ) + METHOD indexOf( cValue, nFrom ) INLINE Qt_QStringList_indexOf( ::pPtr, cValue, nFrom ) + METHOD indexOf_1( pRx, nFrom ) INLINE Qt_QStringList_indexOf_1( ::pPtr, pRx, nFrom ) + METHOD indexOf_2( pRx, nFrom ) INLINE Qt_QStringList_indexOf_2( ::pPtr, pRx, nFrom ) + METHOD join( cSeparator ) INLINE Qt_QStringList_join( ::pPtr, cSeparator ) + METHOD lastIndexOf( pRx, nFrom ) INLINE Qt_QStringList_lastIndexOf( ::pPtr, pRx, nFrom ) + METHOD lastIndexOf_1( cValue, nFrom ) INLINE Qt_QStringList_lastIndexOf_1( ::pPtr, cValue, nFrom ) + METHOD lastIndexOf_2( pRx, nFrom ) INLINE Qt_QStringList_lastIndexOf_2( ::pPtr, pRx, nFrom ) + METHOD removeDuplicates() INLINE Qt_QStringList_removeDuplicates( ::pPtr ) + METHOD sort() INLINE Qt_QStringList_sort( ::pPtr ) + METHOD at( nI ) INLINE Qt_QStringList_at( ::pPtr, nI ) + METHOD back() INLINE Qt_QStringList_back( ::pPtr ) + METHOD count( cValue ) INLINE Qt_QStringList_count( ::pPtr, cValue ) + METHOD endsWith( cValue ) INLINE Qt_QStringList_endsWith( ::pPtr, cValue ) + METHOD first() INLINE Qt_QStringList_first( ::pPtr ) + METHOD first_1() INLINE Qt_QStringList_first_1( ::pPtr ) + METHOD front() INLINE Qt_QStringList_front( ::pPtr ) + METHOD front_1() INLINE Qt_QStringList_front_1( ::pPtr ) + METHOD insert( nI, cValue ) INLINE Qt_QStringList_insert( ::pPtr, nI, cValue ) + METHOD last() INLINE Qt_QStringList_last( ::pPtr ) + METHOD last_1() INLINE Qt_QStringList_last_1( ::pPtr ) + METHOD prepend( cValue ) INLINE Qt_QStringList_prepend( ::pPtr, cValue ) + METHOD push_back( cValue ) INLINE Qt_QStringList_push_back( ::pPtr, cValue ) + METHOD push_front( cValue ) INLINE Qt_QStringList_push_front( ::pPtr, cValue ) + METHOD removeAll( cValue ) INLINE Qt_QStringList_removeAll( ::pPtr, cValue ) + METHOD removeOne( cValue ) INLINE Qt_QStringList_removeOne( ::pPtr, cValue ) + METHOD replace( nI, cValue ) INLINE Qt_QStringList_replace( ::pPtr, nI, cValue ) + METHOD startsWith( cValue ) INLINE Qt_QStringList_startsWith( ::pPtr, cValue ) + METHOD takeAt( nI ) INLINE Qt_QStringList_takeAt( ::pPtr, nI ) + METHOD takeFirst() INLINE Qt_QStringList_takeFirst( ::pPtr ) + METHOD takeLast() INLINE Qt_QStringList_takeLast( ::pPtr ) + METHOD value( nI ) INLINE Qt_QStringList_value( ::pPtr, nI ) + METHOD value_1( nI, cDefaultValue ) INLINE Qt_QStringList_value_1( ::pPtr, nI, cDefaultValue ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QStringList + + ::pParent := pParent + + ::pPtr := Qt_QStringList( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QStringList + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQTextBoundaryFinder.prg b/harbour/contrib/hbqt/qtcore/TQTextBoundaryFinder.prg new file mode 100644 index 0000000000..031b720f47 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQTextBoundaryFinder.prg @@ -0,0 +1,110 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QTextBoundaryFinder + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD boundaryReasons() INLINE Qt_QTextBoundaryFinder_boundaryReasons( ::pPtr ) + METHOD isAtBoundary() INLINE Qt_QTextBoundaryFinder_isAtBoundary( ::pPtr ) + METHOD isValid() INLINE Qt_QTextBoundaryFinder_isValid( ::pPtr ) + METHOD position() INLINE Qt_QTextBoundaryFinder_position( ::pPtr ) + METHOD setPosition( nPosition ) INLINE Qt_QTextBoundaryFinder_setPosition( ::pPtr, nPosition ) + METHOD string() INLINE Qt_QTextBoundaryFinder_string( ::pPtr ) + METHOD toEnd() INLINE Qt_QTextBoundaryFinder_toEnd( ::pPtr ) + METHOD toNextBoundary() INLINE Qt_QTextBoundaryFinder_toNextBoundary( ::pPtr ) + METHOD toPreviousBoundary() INLINE Qt_QTextBoundaryFinder_toPreviousBoundary( ::pPtr ) + METHOD toStart() INLINE Qt_QTextBoundaryFinder_toStart( ::pPtr ) + METHOD type() INLINE Qt_QTextBoundaryFinder_type( ::pPtr ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QTextBoundaryFinder + + ::pParent := pParent + + ::pPtr := Qt_QTextBoundaryFinder( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QTextBoundaryFinder + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQTextCodec.prg b/harbour/contrib/hbqt/qtcore/TQTextCodec.prg new file mode 100644 index 0000000000..af8ffa56b3 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQTextCodec.prg @@ -0,0 +1,119 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QTextCodec + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD canEncode( nCh ) INLINE Qt_QTextCodec_canEncode( ::pPtr, nCh ) + METHOD canEncode_1( cS ) INLINE Qt_QTextCodec_canEncode_1( ::pPtr, cS ) + METHOD fromUnicode( cStr ) INLINE Qt_QTextCodec_fromUnicode( ::pPtr, cStr ) + METHOD makeDecoder() INLINE Qt_QTextCodec_makeDecoder( ::pPtr ) + METHOD makeEncoder() INLINE Qt_QTextCodec_makeEncoder( ::pPtr ) + METHOD mibEnum() INLINE Qt_QTextCodec_mibEnum( ::pPtr ) + METHOD name() INLINE Qt_QTextCodec_name( ::pPtr ) + METHOD toUnicode( pA ) INLINE Qt_QTextCodec_toUnicode( ::pPtr, pA ) + METHOD toUnicode_1( pChars ) INLINE Qt_QTextCodec_toUnicode_1( ::pPtr, pChars ) + METHOD codecForCStrings() INLINE Qt_QTextCodec_codecForCStrings( ::pPtr ) + METHOD codecForHtml( pBa, pDefaultCodec ) INLINE Qt_QTextCodec_codecForHtml( ::pPtr, pBa, pDefaultCodec ) + METHOD codecForHtml_1( pBa ) INLINE Qt_QTextCodec_codecForHtml_1( ::pPtr, pBa ) + METHOD codecForLocale() INLINE Qt_QTextCodec_codecForLocale( ::pPtr ) + METHOD codecForMib( nMib ) INLINE Qt_QTextCodec_codecForMib( ::pPtr, nMib ) + METHOD codecForName( pName ) INLINE Qt_QTextCodec_codecForName( ::pPtr, pName ) + METHOD codecForName_1( pName ) INLINE Qt_QTextCodec_codecForName_1( ::pPtr, pName ) + METHOD codecForTr() INLINE Qt_QTextCodec_codecForTr( ::pPtr ) + METHOD setCodecForCStrings( pCodec ) INLINE Qt_QTextCodec_setCodecForCStrings( ::pPtr, pCodec ) + METHOD setCodecForLocale( pC ) INLINE Qt_QTextCodec_setCodecForLocale( ::pPtr, pC ) + METHOD setCodecForTr( pC ) INLINE Qt_QTextCodec_setCodecForTr( ::pPtr, pC ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QTextCodec + + ::pParent := pParent + + ::pPtr := Qt_QTextCodec( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QTextCodec + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQTextDecoder.prg b/harbour/contrib/hbqt/qtcore/TQTextDecoder.prg new file mode 100644 index 0000000000..b4d89f5a97 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQTextDecoder.prg @@ -0,0 +1,100 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QTextDecoder + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD toUnicode( pChars, nLen ) INLINE Qt_QTextDecoder_toUnicode( ::pPtr, pChars, nLen ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QTextDecoder + + ::pParent := pParent + + ::pPtr := Qt_QTextDecoder( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QTextDecoder + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQTextEncoder.prg b/harbour/contrib/hbqt/qtcore/TQTextEncoder.prg new file mode 100644 index 0000000000..0179c6e623 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQTextEncoder.prg @@ -0,0 +1,100 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QTextEncoder + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD fromUnicode( cStr ) INLINE Qt_QTextEncoder_fromUnicode( ::pPtr, cStr ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QTextEncoder + + ::pParent := pParent + + ::pPtr := Qt_QTextEncoder( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QTextEncoder + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQTextStream.prg b/harbour/contrib/hbqt/qtcore/TQTextStream.prg new file mode 100644 index 0000000000..968a42aeff --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQTextStream.prg @@ -0,0 +1,135 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QTextStream + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD atEnd() INLINE Qt_QTextStream_atEnd( ::pPtr ) + METHOD autoDetectUnicode() INLINE Qt_QTextStream_autoDetectUnicode( ::pPtr ) + METHOD codec() INLINE Qt_QTextStream_codec( ::pPtr ) + METHOD device() INLINE Qt_QTextStream_device( ::pPtr ) + METHOD fieldAlignment() INLINE Qt_QTextStream_fieldAlignment( ::pPtr ) + METHOD fieldWidth() INLINE Qt_QTextStream_fieldWidth( ::pPtr ) + METHOD flush() INLINE Qt_QTextStream_flush( ::pPtr ) + METHOD generateByteOrderMark() INLINE Qt_QTextStream_generateByteOrderMark( ::pPtr ) + METHOD integerBase() INLINE Qt_QTextStream_integerBase( ::pPtr ) + METHOD locale() INLINE Qt_QTextStream_locale( ::pPtr ) + METHOD numberFlags() INLINE Qt_QTextStream_numberFlags( ::pPtr ) + METHOD pos() INLINE Qt_QTextStream_pos( ::pPtr ) + METHOD read( nMaxlen ) INLINE Qt_QTextStream_read( ::pPtr, nMaxlen ) + METHOD readAll() INLINE Qt_QTextStream_readAll( ::pPtr ) + METHOD readLine( nMaxlen ) INLINE Qt_QTextStream_readLine( ::pPtr, nMaxlen ) + METHOD realNumberNotation() INLINE Qt_QTextStream_realNumberNotation( ::pPtr ) + METHOD realNumberPrecision() INLINE Qt_QTextStream_realNumberPrecision( ::pPtr ) + METHOD reset() INLINE Qt_QTextStream_reset( ::pPtr ) + METHOD resetStatus() INLINE Qt_QTextStream_resetStatus( ::pPtr ) + METHOD seek( nPos ) INLINE Qt_QTextStream_seek( ::pPtr, nPos ) + METHOD setAutoDetectUnicode( lEnabled ) INLINE Qt_QTextStream_setAutoDetectUnicode( ::pPtr, lEnabled ) + METHOD setCodec( pCodec ) INLINE Qt_QTextStream_setCodec( ::pPtr, pCodec ) + METHOD setCodec_1( pCodecName ) INLINE Qt_QTextStream_setCodec_1( ::pPtr, pCodecName ) + METHOD setDevice( pDevice ) INLINE Qt_QTextStream_setDevice( ::pPtr, pDevice ) + METHOD setFieldAlignment( nMode ) INLINE Qt_QTextStream_setFieldAlignment( ::pPtr, nMode ) + METHOD setFieldWidth( nWidth ) INLINE Qt_QTextStream_setFieldWidth( ::pPtr, nWidth ) + METHOD setGenerateByteOrderMark( lGenerate ) INLINE Qt_QTextStream_setGenerateByteOrderMark( ::pPtr, lGenerate ) + METHOD setIntegerBase( nBase ) INLINE Qt_QTextStream_setIntegerBase( ::pPtr, nBase ) + METHOD setLocale( pLocale ) INLINE Qt_QTextStream_setLocale( ::pPtr, pLocale ) + METHOD setNumberFlags( nFlags ) INLINE Qt_QTextStream_setNumberFlags( ::pPtr, nFlags ) + METHOD setPadChar( nCh ) INLINE Qt_QTextStream_setPadChar( ::pPtr, nCh ) + METHOD setRealNumberNotation( nNotation ) INLINE Qt_QTextStream_setRealNumberNotation( ::pPtr, nNotation ) + METHOD setRealNumberPrecision( nPrecision ) INLINE Qt_QTextStream_setRealNumberPrecision( ::pPtr, nPrecision ) + METHOD setStatus( nStatus ) INLINE Qt_QTextStream_setStatus( ::pPtr, nStatus ) + METHOD skipWhiteSpace() INLINE Qt_QTextStream_skipWhiteSpace( ::pPtr ) + METHOD status() INLINE Qt_QTextStream_status( ::pPtr ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QTextStream + + ::pParent := pParent + + ::pPtr := Qt_QTextStream( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QTextStream + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQThread.prg b/harbour/contrib/hbqt/qtcore/TQThread.prg new file mode 100644 index 0000000000..f52e6e52ef --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQThread.prg @@ -0,0 +1,113 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QThread INHERIT QObject + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD exit( nReturnCode ) INLINE Qt_QThread_exit( ::pPtr, nReturnCode ) + METHOD isFinished() INLINE Qt_QThread_isFinished( ::pPtr ) + METHOD isRunning() INLINE Qt_QThread_isRunning( ::pPtr ) + METHOD priority() INLINE Qt_QThread_priority( ::pPtr ) + METHOD setPriority( nPriority ) INLINE Qt_QThread_setPriority( ::pPtr, nPriority ) + METHOD setStackSize( nStackSize ) INLINE Qt_QThread_setStackSize( ::pPtr, nStackSize ) + METHOD stackSize() INLINE Qt_QThread_stackSize( ::pPtr ) + METHOD wait() INLINE Qt_QThread_wait( ::pPtr ) + METHOD currentThread() INLINE Qt_QThread_currentThread( ::pPtr ) + METHOD idealThreadCount() INLINE Qt_QThread_idealThreadCount( ::pPtr ) + METHOD yieldCurrentThread() INLINE Qt_QThread_yieldCurrentThread( ::pPtr ) + METHOD quit() INLINE Qt_QThread_quit( ::pPtr ) + METHOD start( nPriority ) INLINE Qt_QThread_start( ::pPtr, nPriority ) + METHOD terminate() INLINE Qt_QThread_terminate( ::pPtr ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QThread + + ::pParent := pParent + + ::pPtr := Qt_QThread( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QThread + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQTime.prg b/harbour/contrib/hbqt/qtcore/TQTime.prg new file mode 100644 index 0000000000..9b5c74efe1 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQTime.prg @@ -0,0 +1,119 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QTime + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD addMSecs( nMs ) INLINE Qt_QTime_addMSecs( ::pPtr, nMs ) + METHOD addSecs( nS ) INLINE Qt_QTime_addSecs( ::pPtr, nS ) + METHOD elapsed() INLINE Qt_QTime_elapsed( ::pPtr ) + METHOD hour() INLINE Qt_QTime_hour( ::pPtr ) + METHOD isNull() INLINE Qt_QTime_isNull( ::pPtr ) + METHOD isValid() INLINE Qt_QTime_isValid( ::pPtr ) + METHOD minute() INLINE Qt_QTime_minute( ::pPtr ) + METHOD msec() INLINE Qt_QTime_msec( ::pPtr ) + METHOD msecsTo( pT ) INLINE Qt_QTime_msecsTo( ::pPtr, pT ) + METHOD restart() INLINE Qt_QTime_restart( ::pPtr ) + METHOD second() INLINE Qt_QTime_second( ::pPtr ) + METHOD secsTo( pT ) INLINE Qt_QTime_secsTo( ::pPtr, pT ) + METHOD setHMS( nH, nM, nS, nMs ) INLINE Qt_QTime_setHMS( ::pPtr, nH, nM, nS, nMs ) + METHOD start() INLINE Qt_QTime_start( ::pPtr ) + METHOD toString( cFormat ) INLINE Qt_QTime_toString( ::pPtr, cFormat ) + METHOD toString_1( nFormat ) INLINE Qt_QTime_toString_1( ::pPtr, nFormat ) + METHOD currentTime() INLINE Qt_QTime_currentTime( ::pPtr ) + METHOD fromString( cString, nFormat ) INLINE Qt_QTime_fromString( ::pPtr, cString, nFormat ) + METHOD fromString_1( cString, cFormat ) INLINE Qt_QTime_fromString_1( ::pPtr, cString, cFormat ) + METHOD isValid_1( nH, nM, nS, nMs ) INLINE Qt_QTime_isValid_1( ::pPtr, nH, nM, nS, nMs ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QTime + + ::pParent := pParent + + ::pPtr := Qt_QTime( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QTime + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQTimer.prg b/harbour/contrib/hbqt/qtcore/TQTimer.prg new file mode 100644 index 0000000000..28dbbf5c81 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQTimer.prg @@ -0,0 +1,109 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QTimer INHERIT QObject + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD interval() INLINE Qt_QTimer_interval( ::pPtr ) + METHOD isActive() INLINE Qt_QTimer_isActive( ::pPtr ) + METHOD isSingleShot() INLINE Qt_QTimer_isSingleShot( ::pPtr ) + METHOD setInterval( nMsec ) INLINE Qt_QTimer_setInterval( ::pPtr, nMsec ) + METHOD setSingleShot( lSingleShot ) INLINE Qt_QTimer_setSingleShot( ::pPtr, lSingleShot ) + METHOD timerId() INLINE Qt_QTimer_timerId( ::pPtr ) + METHOD singleShot( nMsec, pReceiver, pMember ) INLINE Qt_QTimer_singleShot( ::pPtr, nMsec, pReceiver, pMember ) + METHOD start() INLINE Qt_QTimer_start( ::pPtr ) + METHOD stop() INLINE Qt_QTimer_stop( ::pPtr ) + METHOD start_1( nMsec ) INLINE Qt_QTimer_start_1( ::pPtr, nMsec ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QTimer + + ::pParent := pParent + + ::pPtr := Qt_QTimer( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QTimer + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQTranslator.prg b/harbour/contrib/hbqt/qtcore/TQTranslator.prg new file mode 100644 index 0000000000..65316f9ee8 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQTranslator.prg @@ -0,0 +1,103 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QTranslator INHERIT QObject + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD isEmpty() INLINE Qt_QTranslator_isEmpty( ::pPtr ) + METHOD load( cFilename, cDirectory, cSearch_delimiters, cSuffix ) INLINE Qt_QTranslator_load( ::pPtr, cFilename, cDirectory, cSearch_delimiters, cSuffix ) + METHOD translate( pContext, pSourceText, pDisambiguation ) INLINE Qt_QTranslator_translate( ::pPtr, pContext, pSourceText, pDisambiguation ) + METHOD translate_1( pContext, pSourceText, pDisambiguation, nN ) INLINE Qt_QTranslator_translate_1( ::pPtr, pContext, pSourceText, pDisambiguation, nN ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QTranslator + + ::pParent := pParent + + ::pPtr := Qt_QTranslator( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QTranslator + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQUrl.prg b/harbour/contrib/hbqt/qtcore/TQUrl.prg new file mode 100644 index 0000000000..af22d95421 --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQUrl.prg @@ -0,0 +1,168 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QUrl INHERIT QWidget + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD addEncodedQueryItem( pKey, pValue ) INLINE Qt_QUrl_addEncodedQueryItem( ::pPtr, pKey, pValue ) + METHOD addQueryItem( cKey, cValue ) INLINE Qt_QUrl_addQueryItem( ::pPtr, cKey, cValue ) + METHOD allQueryItemValues( cKey ) INLINE Qt_QUrl_allQueryItemValues( ::pPtr, cKey ) + METHOD authority() INLINE Qt_QUrl_authority( ::pPtr ) + METHOD clear() INLINE Qt_QUrl_clear( ::pPtr ) + METHOD encodedFragment() INLINE Qt_QUrl_encodedFragment( ::pPtr ) + METHOD encodedHost() INLINE Qt_QUrl_encodedHost( ::pPtr ) + METHOD encodedPassword() INLINE Qt_QUrl_encodedPassword( ::pPtr ) + METHOD encodedPath() INLINE Qt_QUrl_encodedPath( ::pPtr ) + METHOD encodedQuery() INLINE Qt_QUrl_encodedQuery( ::pPtr ) + METHOD encodedQueryItemValue( pKey ) INLINE Qt_QUrl_encodedQueryItemValue( ::pPtr, pKey ) + METHOD encodedUserName() INLINE Qt_QUrl_encodedUserName( ::pPtr ) + METHOD errorString() INLINE Qt_QUrl_errorString( ::pPtr ) + METHOD fragment() INLINE Qt_QUrl_fragment( ::pPtr ) + METHOD hasEncodedQueryItem( pKey ) INLINE Qt_QUrl_hasEncodedQueryItem( ::pPtr, pKey ) + METHOD hasFragment() INLINE Qt_QUrl_hasFragment( ::pPtr ) + METHOD hasQuery() INLINE Qt_QUrl_hasQuery( ::pPtr ) + METHOD hasQueryItem( cKey ) INLINE Qt_QUrl_hasQueryItem( ::pPtr, cKey ) + METHOD host() INLINE Qt_QUrl_host( ::pPtr ) + METHOD isEmpty() INLINE Qt_QUrl_isEmpty( ::pPtr ) + METHOD isParentOf( pChildUrl ) INLINE Qt_QUrl_isParentOf( ::pPtr, pChildUrl ) + METHOD isRelative() INLINE Qt_QUrl_isRelative( ::pPtr ) + METHOD isValid() INLINE Qt_QUrl_isValid( ::pPtr ) + METHOD password() INLINE Qt_QUrl_password( ::pPtr ) + METHOD path() INLINE Qt_QUrl_path( ::pPtr ) + METHOD port() INLINE Qt_QUrl_port( ::pPtr ) + METHOD port_1( nDefaultPort ) INLINE Qt_QUrl_port_1( ::pPtr, nDefaultPort ) + METHOD queryItemValue( cKey ) INLINE Qt_QUrl_queryItemValue( ::pPtr, cKey ) + METHOD queryPairDelimiter() INLINE Qt_QUrl_queryPairDelimiter( ::pPtr ) + METHOD queryValueDelimiter() INLINE Qt_QUrl_queryValueDelimiter( ::pPtr ) + METHOD removeAllEncodedQueryItems( pKey ) INLINE Qt_QUrl_removeAllEncodedQueryItems( ::pPtr, pKey ) + METHOD removeAllQueryItems( cKey ) INLINE Qt_QUrl_removeAllQueryItems( ::pPtr, cKey ) + METHOD removeEncodedQueryItem( pKey ) INLINE Qt_QUrl_removeEncodedQueryItem( ::pPtr, pKey ) + METHOD removeQueryItem( cKey ) INLINE Qt_QUrl_removeQueryItem( ::pPtr, cKey ) + METHOD resolved( pRelative ) INLINE Qt_QUrl_resolved( ::pPtr, pRelative ) + METHOD scheme() INLINE Qt_QUrl_scheme( ::pPtr ) + METHOD setAuthority( cAuthority ) INLINE Qt_QUrl_setAuthority( ::pPtr, cAuthority ) + METHOD setEncodedFragment( pFragment ) INLINE Qt_QUrl_setEncodedFragment( ::pPtr, pFragment ) + METHOD setEncodedHost( pHost ) INLINE Qt_QUrl_setEncodedHost( ::pPtr, pHost ) + METHOD setEncodedPassword( pPassword ) INLINE Qt_QUrl_setEncodedPassword( ::pPtr, pPassword ) + METHOD setEncodedPath( pPath ) INLINE Qt_QUrl_setEncodedPath( ::pPtr, pPath ) + METHOD setEncodedQuery( pQuery ) INLINE Qt_QUrl_setEncodedQuery( ::pPtr, pQuery ) + METHOD setEncodedUrl( pEncodedUrl ) INLINE Qt_QUrl_setEncodedUrl( ::pPtr, pEncodedUrl ) + METHOD setEncodedUrl_1( pEncodedUrl, nParsingMode ) INLINE Qt_QUrl_setEncodedUrl_1( ::pPtr, pEncodedUrl, nParsingMode ) + METHOD setEncodedUserName( pUserName ) INLINE Qt_QUrl_setEncodedUserName( ::pPtr, pUserName ) + METHOD setFragment( cFragment ) INLINE Qt_QUrl_setFragment( ::pPtr, cFragment ) + METHOD setHost( cHost ) INLINE Qt_QUrl_setHost( ::pPtr, cHost ) + METHOD setPassword( cPassword ) INLINE Qt_QUrl_setPassword( ::pPtr, cPassword ) + METHOD setPath( cPath ) INLINE Qt_QUrl_setPath( ::pPtr, cPath ) + METHOD setPort( nPort ) INLINE Qt_QUrl_setPort( ::pPtr, nPort ) + METHOD setScheme( cScheme ) INLINE Qt_QUrl_setScheme( ::pPtr, cScheme ) + METHOD setUrl( cUrl ) INLINE Qt_QUrl_setUrl( ::pPtr, cUrl ) + METHOD setUrl_1( cUrl, nParsingMode ) INLINE Qt_QUrl_setUrl_1( ::pPtr, cUrl, nParsingMode ) + METHOD setUserInfo( cUserInfo ) INLINE Qt_QUrl_setUserInfo( ::pPtr, cUserInfo ) + METHOD setUserName( cUserName ) INLINE Qt_QUrl_setUserName( ::pPtr, cUserName ) + METHOD toEncoded( nOptions ) INLINE Qt_QUrl_toEncoded( ::pPtr, nOptions ) + METHOD toLocalFile() INLINE Qt_QUrl_toLocalFile( ::pPtr ) + METHOD toString( nOptions ) INLINE Qt_QUrl_toString( ::pPtr, nOptions ) + METHOD userInfo() INLINE Qt_QUrl_userInfo( ::pPtr ) + METHOD userName() INLINE Qt_QUrl_userName( ::pPtr ) + METHOD fromAce( pDomain ) INLINE Qt_QUrl_fromAce( ::pPtr, pDomain ) + METHOD fromEncoded( pInput ) INLINE Qt_QUrl_fromEncoded( ::pPtr, pInput ) + METHOD fromEncoded_1( pInput, nParsingMode ) INLINE Qt_QUrl_fromEncoded_1( ::pPtr, pInput, nParsingMode ) + METHOD fromLocalFile( cLocalFile ) INLINE Qt_QUrl_fromLocalFile( ::pPtr, cLocalFile ) + METHOD fromPercentEncoding( pInput ) INLINE Qt_QUrl_fromPercentEncoding( ::pPtr, pInput ) + METHOD idnWhitelist() INLINE Qt_QUrl_idnWhitelist( ::pPtr ) + METHOD setIdnWhitelist( pList ) INLINE Qt_QUrl_setIdnWhitelist( ::pPtr, pList ) + METHOD toAce( cDomain ) INLINE Qt_QUrl_toAce( ::pPtr, cDomain ) + METHOD toPercentEncoding( cInput, pExclude, pInclude ) INLINE Qt_QUrl_toPercentEncoding( ::pPtr, cInput, pExclude, pInclude ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QUrl + + ::pParent := pParent + + ::pPtr := Qt_QUrl( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QUrl + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/TQVariant.prg b/harbour/contrib/hbqt/qtcore/TQVariant.prg new file mode 100644 index 0000000000..c163dff92c --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/TQVariant.prg @@ -0,0 +1,135 @@ +/* + * $Id$ + */ + +/* -------------------------------------------------------------------- */ +/* WARNING: Automatically generated source file. DO NOT EDIT! */ +/* Instead, edit corresponding .qth file, */ +/* or the generator tool itself, and run regenarate. */ +/* -------------------------------------------------------------------- */ + +/* + * Harbour Project source code: + * QT wrapper main header + * + * Copyright 2009 Pritpal Bedi + * + * Copyright 2009 Marcos Antonio Gambeta + * www - http://www.harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ + + +#include "hbclass.ch" + + +CREATE CLASS QVariant + + VAR pParent + VAR pPtr + + METHOD New() + METHOD Configure( xObject ) + + METHOD canConvert( nT ) INLINE Qt_QVariant_canConvert( ::pPtr, nT ) + METHOD canConvert_1( nT ) INLINE Qt_QVariant_canConvert_1( ::pPtr, nT ) + METHOD clear() INLINE Qt_QVariant_clear( ::pPtr ) + METHOD convert( nT ) INLINE Qt_QVariant_convert( ::pPtr, nT ) + METHOD isNull() INLINE Qt_QVariant_isNull( ::pPtr ) + METHOD isValid() INLINE Qt_QVariant_isValid( ::pPtr ) + METHOD setValue( xValue ) INLINE Qt_QVariant_setValue( ::pPtr, xValue ) + METHOD toBitArray() INLINE Qt_QVariant_toBitArray( ::pPtr ) + METHOD toBool() INLINE Qt_QVariant_toBool( ::pPtr ) + METHOD toByteArray() INLINE Qt_QVariant_toByteArray( ::pPtr ) + METHOD toDate() INLINE Qt_QVariant_toDate( ::pPtr ) + METHOD toDateTime() INLINE Qt_QVariant_toDateTime( ::pPtr ) + METHOD toDouble( lOk ) INLINE Qt_QVariant_toDouble( ::pPtr, lOk ) + METHOD toInt( lOk ) INLINE Qt_QVariant_toInt( ::pPtr, lOk ) + METHOD toLine() INLINE Qt_QVariant_toLine( ::pPtr ) + METHOD toLineF() INLINE Qt_QVariant_toLineF( ::pPtr ) + METHOD toLocale() INLINE Qt_QVariant_toLocale( ::pPtr ) + METHOD toLongLong( lOk ) INLINE Qt_QVariant_toLongLong( ::pPtr, lOk ) + METHOD toPoint() INLINE Qt_QVariant_toPoint( ::pPtr ) + METHOD toPointF() INLINE Qt_QVariant_toPointF( ::pPtr ) + METHOD toRect() INLINE Qt_QVariant_toRect( ::pPtr ) + METHOD toRectF() INLINE Qt_QVariant_toRectF( ::pPtr ) + METHOD toRegExp() INLINE Qt_QVariant_toRegExp( ::pPtr ) + METHOD toSize() INLINE Qt_QVariant_toSize( ::pPtr ) + METHOD toSizeF() INLINE Qt_QVariant_toSizeF( ::pPtr ) + METHOD toString() INLINE Qt_QVariant_toString( ::pPtr ) + METHOD toStringList() INLINE Qt_QVariant_toStringList( ::pPtr ) + METHOD toTime() INLINE Qt_QVariant_toTime( ::pPtr ) + METHOD toUInt( lOk ) INLINE Qt_QVariant_toUInt( ::pPtr, lOk ) + METHOD toULongLong( lOk ) INLINE Qt_QVariant_toULongLong( ::pPtr, lOk ) + METHOD toUrl() INLINE Qt_QVariant_toUrl( ::pPtr ) + METHOD type() INLINE Qt_QVariant_type( ::pPtr ) + METHOD userType() INLINE Qt_QVariant_userType( ::pPtr ) + METHOD fromValue( xValue ) INLINE Qt_QVariant_fromValue( ::pPtr, xValue ) + METHOD nameToType( pName ) INLINE Qt_QVariant_nameToType( ::pPtr, pName ) + METHOD typeToName( nTyp ) INLINE Qt_QVariant_typeToName( ::pPtr, nTyp ) + + ENDCLASS + +/*----------------------------------------------------------------------*/ + +METHOD New( pParent ) CLASS QVariant + + ::pParent := pParent + + ::pPtr := Qt_QVariant( pParent ) + + RETURN Self + +/*----------------------------------------------------------------------*/ + +METHOD Configure( xObject ) CLASS QVariant + + IF hb_isObject( xObject ) + ::pPtr := xObject:pPtr + ELSEIF hb_isPointer( xObject ) + ::pPtr := xObject + ENDIF + + RETURN Self + +/*----------------------------------------------------------------------*/ diff --git a/harbour/contrib/hbqt/qtcore/filelist.mk b/harbour/contrib/hbqt/qtcore/filelist.mk new file mode 100644 index 0000000000..b72550862f --- /dev/null +++ b/harbour/contrib/hbqt/qtcore/filelist.mk @@ -0,0 +1,110 @@ +# +# $Id$ +# + +# -------------------------------------------------------------------- +# WARNING: Automatically generated source file. DO NOT EDIT! +# Instead, edit corresponding .qth file, +# or the generator tool itself, and run regenarate. +# -------------------------------------------------------------------- + +CPP_SOURCES := \ + QAbstractItemModel.cpp \ + QAbstractListModel.cpp \ + QAbstractTableModel.cpp \ + QBitArray.cpp \ + QByteArray.cpp \ + QCoreApplication.cpp \ + QDataStream.cpp \ + QDate.cpp \ + QDateTime.cpp \ + QDir.cpp \ + QEvent.cpp \ + QEventLoop.cpp \ + QFile.cpp \ + QFileInfo.cpp \ + QIODevice.cpp \ + QLatin1Char.cpp \ + QLatin1String.cpp \ + QLine.cpp \ + QLineF.cpp \ + QList.cpp \ + QLocale.cpp \ + QMimeData.cpp \ + QModelIndex.cpp \ + QObject.cpp \ + QPoint.cpp \ + QPointF.cpp \ + QProcess.cpp \ + QRect.cpp \ + QRectF.cpp \ + QRegExp.cpp \ + QResource.cpp \ + QSignalMapper.cpp \ + QSize.cpp \ + QSizeF.cpp \ + QStringList.cpp \ + QTextBoundaryFinder.cpp \ + QTextCodec.cpp \ + QTextDecoder.cpp \ + QTextEncoder.cpp \ + QTextStream.cpp \ + QThread.cpp \ + QTime.cpp \ + QTimer.cpp \ + QTranslator.cpp \ + QUrl.cpp \ + QVariant.cpp \ + + + +PRG_SOURCES := \ + TQAbstractItemModel.prg \ + TQAbstractListModel.prg \ + TQAbstractTableModel.prg \ + TQBitArray.prg \ + TQByteArray.prg \ + TQCoreApplication.prg \ + TQDataStream.prg \ + TQDate.prg \ + TQDateTime.prg \ + TQDir.prg \ + TQEvent.prg \ + TQEventLoop.prg \ + TQFile.prg \ + TQFileInfo.prg \ + TQIODevice.prg \ + TQLatin1Char.prg \ + TQLatin1String.prg \ + TQLine.prg \ + TQLineF.prg \ + TQList.prg \ + TQLocale.prg \ + TQMimeData.prg \ + TQModelIndex.prg \ + TQObject.prg \ + TQPoint.prg \ + TQPointF.prg \ + TQProcess.prg \ + TQRect.prg \ + TQRectF.prg \ + TQRegExp.prg \ + TQResource.prg \ + TQSignalMapper.prg \ + TQSize.prg \ + TQSizeF.prg \ + TQStringList.prg \ + TQTextBoundaryFinder.prg \ + TQTextCodec.prg \ + TQTextDecoder.prg \ + TQTextEncoder.prg \ + TQTextStream.prg \ + TQThread.prg \ + TQTime.prg \ + TQTimer.prg \ + TQTranslator.prg \ + TQUrl.prg \ + TQVariant.prg \ + +# Don't delete this comment, it's here to ensure empty +# line above is kept intact.