fivedev/harbour-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

! Changes will be documented in last Changelog commit.

Browse Source
This commit is contained in:
Pritpal Bedi
2009-10-22 16:41:57 +00:00
parent 5d5d1e23ec
commit 1b916e4872
94 changed files with 20337 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

64
harbour/contrib/hbqt/qtcore/Makefile Normal file
View File

@@ -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

403
harbour/contrib/hbqt/qtcore/QAbstractItemModel.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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<int, QVariant> itemData ( const QModelIndex & index ) const
* virtual bool setItemData ( const QModelIndex & index, const QMap<int, QVariant> & 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 <QtCore/QPointer>
#include <QSize>
#include <QStringList>
#include <QtCore/QAbstractItemModel>
#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 */
/*----------------------------------------------------------------------*/

116
harbour/contrib/hbqt/qtcore/QAbstractListModel.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QAbstractListModel>
/*
* 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 */
/*----------------------------------------------------------------------*/

116
harbour/contrib/hbqt/qtcore/QAbstractTableModel.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QAbstractTableModel>
/*
* 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 */
/*----------------------------------------------------------------------*/

235
harbour/contrib/hbqt/qtcore/QBitArray.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QBitArray>
/* 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 */
/*----------------------------------------------------------------------*/

941
harbour/contrib/hbqt/qtcore/QByteArray.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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<QByteArray> 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 <QtCore/QPointer>
#include <QtCore/QByteArray>
/* 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 */
/*----------------------------------------------------------------------*/

447
harbour/contrib/hbqt/qtcore/QCoreApplication.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QStringList>
#include <QtCore/QCoreApplication>
/*
* 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 */
/*----------------------------------------------------------------------*/

215
harbour/contrib/hbqt/qtcore/QDataStream.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QDataStream>
/* 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 */
/*----------------------------------------------------------------------*/

274
harbour/contrib/hbqt/qtcore/QDate.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QDate>
/* 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 */
/*----------------------------------------------------------------------*/

318
harbour/contrib/hbqt/qtcore/QDateTime.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QDateTime>
/*
* 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 */
/*----------------------------------------------------------------------*/

532
harbour/contrib/hbqt/qtcore/QDir.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QDir>
/*
* 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 */
/*----------------------------------------------------------------------*/

163
harbour/contrib/hbqt/qtcore/QEvent.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QEvent>
/*
* 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 */
/*----------------------------------------------------------------------*/

170
harbour/contrib/hbqt/qtcore/QEventLoop.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QEventLoop>
#include <QtCore/QEvent>
/*
* 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 */
/*----------------------------------------------------------------------*/

402
harbour/contrib/hbqt/qtcore/QFile.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QFile>
/* 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 */
/*----------------------------------------------------------------------*/

464
harbour/contrib/hbqt/qtcore/QFileInfo.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QFileInfo>
#include <QtCore/QDir>
#include <QtCore/QDateTime>
/* 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 */
/*----------------------------------------------------------------------*/

378
harbour/contrib/hbqt/qtcore/QIODevice.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QIODevice>
/*
* 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 */
/*----------------------------------------------------------------------*/

118
harbour/contrib/hbqt/qtcore/QLatin1Char.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QLatin1Char>
/*
* 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 */
/*----------------------------------------------------------------------*/

110
harbour/contrib/hbqt/qtcore/QLatin1String.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QLatin1String>
/*
* 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 */
/*----------------------------------------------------------------------*/

259
harbour/contrib/hbqt/qtcore/QLine.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QLine>
/*
* 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 */
/*----------------------------------------------------------------------*/

328
harbour/contrib/hbqt/qtcore/QLineF.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QLineF>
/* 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 */
/*----------------------------------------------------------------------*/

451
harbour/contrib/hbqt/qtcore/QList.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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<T> & value )
* iterator begin ()
* iterator erase ( iterator pos )
* iterator erase ( iterator begin, iterator end )
* iterator insert ( iterator before, const T & value )
* QList<T> mid ( int pos, int length = -1 ) const
* QSet<T> toSet () const
* std::list<T> toStdList () const
* QVector<T> 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 <QtCore/QPointer>
#include <QtCore/QList>
/*
* QList ()
* QList ( const QList<T> & 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<void*>* list = NULL;
pObj = ( QList<void*>* ) 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 */
/*----------------------------------------------------------------------*/

552
harbour/contrib/hbqt/qtcore/QLocale.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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<Country> 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 <QtCore/QPointer>
#include <QtCore/QLocale>
#include <QtCore/QDate>
/* 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 */
/*----------------------------------------------------------------------*/

279
harbour/contrib/hbqt/qtcore/QMimeData.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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<QUrl> & urls )
* QList<QUrl> urls () const
*/
#include <QtCore/QPointer>
#include <QtCore/QMimeData>
#include <QtCore/QStringList>
/* 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 */
/*----------------------------------------------------------------------*/

196
harbour/contrib/hbqt/qtcore/QModelIndex.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QModelIndex>
/*
* 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 */
/*----------------------------------------------------------------------*/

367
harbour/contrib/hbqt/qtcore/QObject.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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<QByteArray> dynamicPropertyNames () const
* QList<T> findChildren ( const QString & name = QString() ) const
* QList<T> 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 <QtCore/QPointer>
#include <QWidget>
#include <QtCore/QObject>
#include <QtCore/QVariant>
/*
* 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 */
/*----------------------------------------------------------------------*/

179
harbour/contrib/hbqt/qtcore/QPoint.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QPoint>
/*
* 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 */
/*----------------------------------------------------------------------*/

183
harbour/contrib/hbqt/qtcore/QPointF.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QPointF>
/*
* 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 */
/*----------------------------------------------------------------------*/

403
harbour/contrib/hbqt/qtcore/QProcess.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QProcess>
/*
* 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 */
/*----------------------------------------------------------------------*/

617
harbour/contrib/hbqt/qtcore/QRect.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QRect>
/*
* 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 */
/*----------------------------------------------------------------------*/

626
harbour/contrib/hbqt/qtcore/QRectF.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QRectF>
/*
* 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 */
/*----------------------------------------------------------------------*/

265
harbour/contrib/hbqt/qtcore/QRegExp.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QRegExp>
#include <QtCore/QStringList>
/* 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 */
/*----------------------------------------------------------------------*/

199
harbour/contrib/hbqt/qtcore/QResource.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QResource>
/*
* 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 */
/*----------------------------------------------------------------------*/

205
harbour/contrib/hbqt/qtcore/QSignalMapper.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QSignalMapper>
/*
* 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 */
/*----------------------------------------------------------------------*/

231
harbour/contrib/hbqt/qtcore/QSize.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QSize>
/*
* 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 */
/*----------------------------------------------------------------------*/

236
harbour/contrib/hbqt/qtcore/QSizeF.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QSizeF>
/*
* 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 */
/*----------------------------------------------------------------------*/

407
harbour/contrib/hbqt/qtcore/QStringList.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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<QString> mid ( int pos, int length = -1 ) const
* QSet<QString> toSet () const
* std::list<QString> toStdList () const
* QVector<QString> 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 <QtCore/QPointer>
#include <QtCore/QStringList>
/*
* QStringList ()
* QStringList ( const QString & str )
* QStringList ( const QStringList & other )
* QStringList ( const QList<QString> & 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 */
/*----------------------------------------------------------------------*/

200
harbour/contrib/hbqt/qtcore/QTextBoundaryFinder.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QTextBoundaryFinder>
/*
* 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 */
/*----------------------------------------------------------------------*/

268
harbour/contrib/hbqt/qtcore/QTextCodec.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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<QByteArray> 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 <QtCore/QPointer>
#include <QtCore/QTextCodec>
/*
*
*
*/
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 */
/*----------------------------------------------------------------------*/

111
harbour/contrib/hbqt/qtcore/QTextDecoder.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QTextDecoder>
/*
* 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 */
/*----------------------------------------------------------------------*/

111
harbour/contrib/hbqt/qtcore/QTextEncoder.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QTextEncoder>
/*
* 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 */
/*----------------------------------------------------------------------*/

411
harbour/contrib/hbqt/qtcore/QTextStream.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QTextStream>
/*
* 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 */
/*----------------------------------------------------------------------*/

232
harbour/contrib/hbqt/qtcore/QThread.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QThread>
/* 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 */
/*----------------------------------------------------------------------*/

266
harbour/contrib/hbqt/qtcore/QTime.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QTime>
/* 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 */
/*----------------------------------------------------------------------*/

197
harbour/contrib/hbqt/qtcore/QTimer.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QTimer>
/*
* 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 */
/*----------------------------------------------------------------------*/

148
harbour/contrib/hbqt/qtcore/QTranslator.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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 <QtCore/QPointer>
#include <QtCore/QTranslator>
/* 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 */
/*----------------------------------------------------------------------*/

693
harbour/contrib/hbqt/qtcore/QUrl.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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<QByteArray> allEncodedQueryItemValues ( const QByteArray & key ) const
* QList<QPair<QByteArray, QByteArray> > encodedQueryItems () const
* QList<QPair<QString, QString> > queryItems () const
* void setEncodedQueryItems ( const QList<QPair<QByteArray, QByteArray> > & query )
* void setQueryItems ( const QList<QPair<QString, QString> > & query )
*
* *** Commented out protos which construct fine but do not compile ***
*
* //void setQueryDelimiters ( char valueDelimiter, char pairDelimiter )
*/
#include <QtCore/QPointer>
#include <QStringList>
#include <QtCore/QUrl>
/*
* 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 */
/*----------------------------------------------------------------------*/

478
harbour/contrib/hbqt/qtcore/QVariant.cpp Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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<QString, QVariant> toHash () const
* QList<QVariant> toList () const
* QMap<QString, QVariant> toMap () const
*
* *** Commented out protos which construct fine but do not compile ***
*
* //QChar toChar () const
* //const char * typeName () const
* //T value () const
*/
#include <QtCore/QPointer>
#include <QLine>
#include <QRect>
#include <QStringList>
#include <QtCore/QVariant>
#include <QtCore/QBitArray>
#include <QtCore/QTime>
#include <QtCore/QUrl>
#include <QtCore/QLocale>
/*
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<QVariant> & val )
QVariant ( const QMap<QString, QVariant> & val )
QVariant ( const QHash<QString, QVariant> & 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 */
/*----------------------------------------------------------------------*/

143
harbour/contrib/hbqt/qtcore/TQAbstractItemModel.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

100
harbour/contrib/hbqt/qtcore/TQAbstractListModel.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

100
harbour/contrib/hbqt/qtcore/TQAbstractTableModel.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

115
harbour/contrib/hbqt/qtcore/TQBitArray.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

196
harbour/contrib/hbqt/qtcore/TQByteArray.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

139
harbour/contrib/hbqt/qtcore/TQCoreApplication.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

112
harbour/contrib/hbqt/qtcore/TQDataStream.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

118
harbour/contrib/hbqt/qtcore/TQDate.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

125
harbour/contrib/hbqt/qtcore/TQDateTime.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

151
harbour/contrib/hbqt/qtcore/TQDir.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

106
harbour/contrib/hbqt/qtcore/TQEvent.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

105
harbour/contrib/hbqt/qtcore/TQEventLoop.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

133
harbour/contrib/hbqt/qtcore/TQFile.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

143
harbour/contrib/hbqt/qtcore/TQFileInfo.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

132
harbour/contrib/hbqt/qtcore/TQIODevice.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

101
harbour/contrib/hbqt/qtcore/TQLatin1Char.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

100
harbour/contrib/hbqt/qtcore/TQLatin1String.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

114
harbour/contrib/hbqt/qtcore/TQLine.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

126
harbour/contrib/hbqt/qtcore/TQLineF.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

139
harbour/contrib/hbqt/qtcore/TQList.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

147
harbour/contrib/hbqt/qtcore/TQLocale.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

118
harbour/contrib/hbqt/qtcore/TQMimeData.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

110
harbour/contrib/hbqt/qtcore/TQModelIndex.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

128
harbour/contrib/hbqt/qtcore/TQObject.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

105
harbour/contrib/hbqt/qtcore/TQPoint.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

105
harbour/contrib/hbqt/qtcore/TQPointF.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

132
harbour/contrib/hbqt/qtcore/TQProcess.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

156
harbour/contrib/hbqt/qtcore/TQRect.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

157
harbour/contrib/hbqt/qtcore/TQRectF.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

118
harbour/contrib/hbqt/qtcore/TQRegExp.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

111
harbour/contrib/hbqt/qtcore/TQResource.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

110
harbour/contrib/hbqt/qtcore/TQSignalMapper.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

111
harbour/contrib/hbqt/qtcore/TQSize.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

112
harbour/contrib/hbqt/qtcore/TQSizeF.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

134
harbour/contrib/hbqt/qtcore/TQStringList.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

110
harbour/contrib/hbqt/qtcore/TQTextBoundaryFinder.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

119
harbour/contrib/hbqt/qtcore/TQTextCodec.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

100
harbour/contrib/hbqt/qtcore/TQTextDecoder.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

100
harbour/contrib/hbqt/qtcore/TQTextEncoder.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

135
harbour/contrib/hbqt/qtcore/TQTextStream.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

113
harbour/contrib/hbqt/qtcore/TQThread.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

119
harbour/contrib/hbqt/qtcore/TQTime.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

109
harbour/contrib/hbqt/qtcore/TQTimer.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

103
harbour/contrib/hbqt/qtcore/TQTranslator.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

168
harbour/contrib/hbqt/qtcore/TQUrl.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

135
harbour/contrib/hbqt/qtcore/TQVariant.prg Normal file
View File

@@ -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 <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* 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
/*----------------------------------------------------------------------*/

110
harbour/contrib/hbqt/qtcore/filelist.mk Normal file
View File

@@ -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.