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

2010-06-26 13:53 UTC-0800 Pritpal Bedi (bedipritpal@hotmail.com)

Browse Source 
* contrib/hbqt/qtdesigner
  * contrib/hbqt/qtdesigner/doc
  * contrib/hbqt/qtdesigner/doc/en
  * contrib/hbqt/qtdesigner/doc/en/class_qdesigneractioneditorinterface.txt
  * contrib/hbqt/qtdesigner/doc/en/class_qdesignerformeditorinterface.txt
  * contrib/hbqt/qtdesigner/doc/en/class_qdesignerformwindowcursorinterface.txt
  * contrib/hbqt/qtdesigner/doc/en/class_qdesignerformwindowinterface.txt
  * contrib/hbqt/qtdesigner/doc/en/class_qdesignerformwindowmanagerinterface.txt
  * contrib/hbqt/qtdesigner/doc/en/class_qdesignerobjectinspectorinterface.txt
  * contrib/hbqt/qtdesigner/doc/en/class_qdesignerpropertyeditorinterface.txt
  * contrib/hbqt/qtdesigner/doc/en/class_qdesignerwidgetboxinterface.txt
  * contrib/hbqt/qtdesigner/hbqt_garbage.h
  * contrib/hbqt/qtdesigner/hbqt_local.h
  * contrib/hbqt/qtdesigner/hbqtdesigner.hbp
  * contrib/hbqt/qtdesigner/hbqtdesigner.qtp
  * contrib/hbqt/qtdesigner/QDesignerActionEditorInterface.cpp
  * contrib/hbqt/qtdesigner/QDesignerFormEditorInterface.cpp
  * contrib/hbqt/qtdesigner/QDesignerFormWindowCursorInterface.cpp
  * contrib/hbqt/qtdesigner/QDesignerFormWindowInterface.cpp
  * contrib/hbqt/qtdesigner/QDesignerFormWindowManagerInterface.cpp
  * contrib/hbqt/qtdesigner/QDesignerObjectInspectorInterface.cpp
  * contrib/hbqt/qtdesigner/QDesignerPropertyEditorInterface.cpp
  * contrib/hbqt/qtdesigner/QDesignerWidgetBoxInterface.cpp
  * contrib/hbqt/qtdesigner/qth
  * contrib/hbqt/qtdesigner/qth/QDesignerActionEditorInterface.qth
  * contrib/hbqt/qtdesigner/qth/QDesignerFormEditorInterface.qth
  * contrib/hbqt/qtdesigner/qth/QDesignerFormWindowCursorInterface.qth
  * contrib/hbqt/qtdesigner/qth/QDesignerFormWindowInterface.qth
  * contrib/hbqt/qtdesigner/qth/QDesignerFormWindowManagerInterface.qth
  * contrib/hbqt/qtdesigner/qth/QDesignerObjectInspectorInterface.qth
  * contrib/hbqt/qtdesigner/qth/QDesignerPropertyEditorInterface.qth
  * contrib/hbqt/qtdesigner/qth/QDesignerWidgetBoxInterface.qth
  * contrib/hbqt/qtdesigner/TQDesignerActionEditorInterface.prg
  * contrib/hbqt/qtdesigner/TQDesignerFormEditorInterface.prg
  * contrib/hbqt/qtdesigner/TQDesignerFormWindowCursorInterface.prg
  * contrib/hbqt/qtdesigner/TQDesignerFormWindowInterface.prg
  * contrib/hbqt/qtdesigner/TQDesignerFormWindowManagerInterface.prg
  * contrib/hbqt/qtdesigner/TQDesignerObjectInspectorInterface.prg
  * contrib/hbqt/qtdesigner/TQDesignerPropertyEditorInterface.prg
  * contrib/hbqt/qtdesigner/TQDesignerWidgetBoxInterface.prg

  - contrib/hbqt/qth/QItemEditorCreator.qth

    + Added: QtDesigner access specif library.
             Just in case someone wants to play with it.
This commit is contained in:
Pritpal Bedi
2010-06-26 20:59:31 +00:00
parent 23c0e11f8a
commit 6230bdcd29
37 changed files with 5298 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files

47
harbour/ChangeLog
View File

@@ -16,6 +16,53 @@
The license applies to all entries newer than 2009-04-28.
*/
2010-06-26 13:53 UTC-0800 Pritpal Bedi (bedipritpal@hotmail.com)
* contrib/hbqt/qtdesigner
* contrib/hbqt/qtdesigner/doc
* contrib/hbqt/qtdesigner/doc/en
* contrib/hbqt/qtdesigner/doc/en/class_qdesigneractioneditorinterface.txt
* contrib/hbqt/qtdesigner/doc/en/class_qdesignerformeditorinterface.txt
* contrib/hbqt/qtdesigner/doc/en/class_qdesignerformwindowcursorinterface.txt
* contrib/hbqt/qtdesigner/doc/en/class_qdesignerformwindowinterface.txt
* contrib/hbqt/qtdesigner/doc/en/class_qdesignerformwindowmanagerinterface.txt
* contrib/hbqt/qtdesigner/doc/en/class_qdesignerobjectinspectorinterface.txt
* contrib/hbqt/qtdesigner/doc/en/class_qdesignerpropertyeditorinterface.txt
* contrib/hbqt/qtdesigner/doc/en/class_qdesignerwidgetboxinterface.txt
* contrib/hbqt/qtdesigner/hbqt_garbage.h
* contrib/hbqt/qtdesigner/hbqt_local.h
* contrib/hbqt/qtdesigner/hbqtdesigner.hbp
* contrib/hbqt/qtdesigner/hbqtdesigner.qtp
* contrib/hbqt/qtdesigner/QDesignerActionEditorInterface.cpp
* contrib/hbqt/qtdesigner/QDesignerFormEditorInterface.cpp
* contrib/hbqt/qtdesigner/QDesignerFormWindowCursorInterface.cpp
* contrib/hbqt/qtdesigner/QDesignerFormWindowInterface.cpp
* contrib/hbqt/qtdesigner/QDesignerFormWindowManagerInterface.cpp
* contrib/hbqt/qtdesigner/QDesignerObjectInspectorInterface.cpp
* contrib/hbqt/qtdesigner/QDesignerPropertyEditorInterface.cpp
* contrib/hbqt/qtdesigner/QDesignerWidgetBoxInterface.cpp
* contrib/hbqt/qtdesigner/qth
* contrib/hbqt/qtdesigner/qth/QDesignerActionEditorInterface.qth
* contrib/hbqt/qtdesigner/qth/QDesignerFormEditorInterface.qth
* contrib/hbqt/qtdesigner/qth/QDesignerFormWindowCursorInterface.qth
* contrib/hbqt/qtdesigner/qth/QDesignerFormWindowInterface.qth
* contrib/hbqt/qtdesigner/qth/QDesignerFormWindowManagerInterface.qth
* contrib/hbqt/qtdesigner/qth/QDesignerObjectInspectorInterface.qth
* contrib/hbqt/qtdesigner/qth/QDesignerPropertyEditorInterface.qth
* contrib/hbqt/qtdesigner/qth/QDesignerWidgetBoxInterface.qth
* contrib/hbqt/qtdesigner/TQDesignerActionEditorInterface.prg
* contrib/hbqt/qtdesigner/TQDesignerFormEditorInterface.prg
* contrib/hbqt/qtdesigner/TQDesignerFormWindowCursorInterface.prg
* contrib/hbqt/qtdesigner/TQDesignerFormWindowInterface.prg
* contrib/hbqt/qtdesigner/TQDesignerFormWindowManagerInterface.prg
* contrib/hbqt/qtdesigner/TQDesignerObjectInspectorInterface.prg
* contrib/hbqt/qtdesigner/TQDesignerPropertyEditorInterface.prg
* contrib/hbqt/qtdesigner/TQDesignerWidgetBoxInterface.prg
- contrib/hbqt/qth/QItemEditorCreator.qth
+ Added: QtDesigner access specif library.
Just in case someone wants to play with it.
2010-06-26 22:09 UTC+0200 Viktor Szakats (harbour.01 syenar.hu)
* contrib/hbide/resources/hbmk2_plugin_uip.prg
! Fixed typo causing "'.uip.prg' assumed external"

182
harbour/contrib/hbqt/qtdesigner/QDesignerActionEditorInterface.cpp Normal file
View File

@@ -0,0 +1,182 @@
/*
* $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-2010 Pritpal Bedi <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* www - http://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 "../hbqt.h"
/*----------------------------------------------------------------------*/
#if QT_VERSION >= 0x040500
/*----------------------------------------------------------------------*/
#include <QtCore/QPointer>
#include <QtDesigner/QDesignerActionEditorInterface>
#include "hbqt_garbage.h"
#include "hbqt_local.h"
/*
* QDesignerActionEditorInterface ( QWidget * parent, Qt::WindowFlags flags = 0 )
* ~QDesignerActionEditorInterface ()
*
*/
typedef struct
{
QPointer< QDesignerActionEditorInterface > ph;
bool bNew;
QT_G_FUNC_PTR func;
} QGC_POINTER_QDesignerActionEditorInterface;
QT_G_FUNC( hbqt_gcRelease_QDesignerActionEditorInterface )
{
HB_SYMBOL_UNUSED( Cargo );
QGC_POINTER * p = ( QGC_POINTER * ) Cargo;
if( p && p->bNew )
{
p->ph = NULL;
}
}
void * hbqt_gcAllocate_QDesignerActionEditorInterface( void * pObj, bool bNew )
{
QGC_POINTER_QDesignerActionEditorInterface * p = ( QGC_POINTER_QDesignerActionEditorInterface * ) hb_gcAllocate( sizeof( QGC_POINTER_QDesignerActionEditorInterface ), hbqt_gcFuncs() );
new( & p->ph ) QPointer< QDesignerActionEditorInterface >( ( QDesignerActionEditorInterface * ) pObj );
p->bNew = bNew;
p->func = hbqt_gcRelease_QDesignerActionEditorInterface;
if( bNew )
{
HB_TRACE( HB_TR_DEBUG, ( "ph=%p _new_QDesignerActionEditorInterface under p->pq", pObj ) );
}
else
{
HB_TRACE( HB_TR_DEBUG, ( "ph=%p NOT_new_QDesignerActionEditorInterface", pObj ) );
}
return p;
}
HB_FUNC( QT_QDESIGNERACTIONEDITORINTERFACE )
{
//hb_retptr( new QDesignerActionEditorInterface() );
}
/*
* virtual QDesignerFormEditorInterface * core () const
*/
HB_FUNC( QT_QDESIGNERACTIONEDITORINTERFACE_CORE )
{
QDesignerActionEditorInterface * p = hbqt_par_QDesignerActionEditorInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QDesignerFormEditorInterface( ( p )->core(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERACTIONEDITORINTERFACE_CORE FP=hb_retptrGC( hbqt_gcAllocate_QDesignerFormEditorInterface( ( p )->core(), false ) ); p is NULL" ) );
}
}
/*
* virtual void manageAction ( QAction * action ) = 0
*/
HB_FUNC( QT_QDESIGNERACTIONEDITORINTERFACE_MANAGEACTION )
{
QDesignerActionEditorInterface * p = hbqt_par_QDesignerActionEditorInterface( 1 );
if( p )
( p )->manageAction( hbqt_par_QAction( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERACTIONEDITORINTERFACE_MANAGEACTION FP=( p )->manageAction( hbqt_par_QAction( 2 ) ); p is NULL" ) );
}
}
/*
* virtual void unmanageAction ( QAction * action ) = 0
*/
HB_FUNC( QT_QDESIGNERACTIONEDITORINTERFACE_UNMANAGEACTION )
{
QDesignerActionEditorInterface * p = hbqt_par_QDesignerActionEditorInterface( 1 );
if( p )
( p )->unmanageAction( hbqt_par_QAction( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERACTIONEDITORINTERFACE_UNMANAGEACTION FP=( p )->unmanageAction( hbqt_par_QAction( 2 ) ); p is NULL" ) );
}
}
/*
* virtual void setFormWindow ( QDesignerFormWindowInterface * formWindow ) = 0
*/
HB_FUNC( QT_QDESIGNERACTIONEDITORINTERFACE_SETFORMWINDOW )
{
QDesignerActionEditorInterface * p = hbqt_par_QDesignerActionEditorInterface( 1 );
if( p )
( p )->setFormWindow( hbqt_par_QDesignerFormWindowInterface( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERACTIONEDITORINTERFACE_SETFORMWINDOW FP=( p )->setFormWindow( hbqt_par_QDesignerFormWindowInterface( 2 ) ); p is NULL" ) );
}
}
/*----------------------------------------------------------------------*/
#endif /* #if QT_VERSION >= 0x040500 */
/*----------------------------------------------------------------------*/

303
harbour/contrib/hbqt/qtdesigner/QDesignerFormEditorInterface.cpp Normal file
View File

@@ -0,0 +1,303 @@
/*
* $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-2010 Pritpal Bedi <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* www - http://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 "../hbqt.h"
/*----------------------------------------------------------------------*/
#if QT_VERSION >= 0x040500
/*----------------------------------------------------------------------*/
#include <QtCore/QPointer>
#include <QtDesigner/QDesignerFormEditorInterface>
#include "hbqt_garbage.h"
#include "hbqt_local.h"
/*
* QDesignerFormEditorInterface ( QObject * parent = 0 )
* virtual ~QDesignerFormEditorInterface ()
*
*/
typedef struct
{
QPointer< QDesignerFormEditorInterface > ph;
bool bNew;
QT_G_FUNC_PTR func;
} QGC_POINTER_QDesignerFormEditorInterface;
QT_G_FUNC( hbqt_gcRelease_QDesignerFormEditorInterface )
{
QDesignerFormEditorInterface * ph = NULL ;
QGC_POINTER_QDesignerFormEditorInterface * p = ( QGC_POINTER_QDesignerFormEditorInterface * ) Cargo;
if( p && p->bNew && p->ph )
{
ph = p->ph;
if( ph )
{
const QMetaObject * m = ( ph )->metaObject();
if( ( QString ) m->className() != ( QString ) "QObject" )
{
HB_TRACE( HB_TR_DEBUG, ( "ph=%p %p YES_rel_QDesignerFormEditorInterface /.\\ ", (void*) ph, (void*) p->ph ) );
delete ( p->ph );
HB_TRACE( HB_TR_DEBUG, ( "ph=%p %p YES_rel_QDesignerFormEditorInterface \\./ ", (void*) ph, (void*) p->ph ) );
p->ph = NULL;
}
else
{
HB_TRACE( HB_TR_DEBUG, ( "ph=%p NO__rel_QDesignerFormEditorInterface ", ph ) );
p->ph = NULL;
}
}
else
{
HB_TRACE( HB_TR_DEBUG, ( "ph=%p DEL_rel_QDesignerFormEditorInterface : Object already deleted!", ph ) );
p->ph = NULL;
}
}
else
{
HB_TRACE( HB_TR_DEBUG, ( "ph=%p PTR_rel_QDesignerFormEditorInterface : Object not created with new=true", ph ) );
p->ph = NULL;
}
}
void * hbqt_gcAllocate_QDesignerFormEditorInterface( void * pObj, bool bNew )
{
QGC_POINTER_QDesignerFormEditorInterface * p = ( QGC_POINTER_QDesignerFormEditorInterface * ) hb_gcAllocate( sizeof( QGC_POINTER_QDesignerFormEditorInterface ), hbqt_gcFuncs() );
new( & p->ph ) QPointer< QDesignerFormEditorInterface >( ( QDesignerFormEditorInterface * ) pObj );
p->bNew = bNew;
p->func = hbqt_gcRelease_QDesignerFormEditorInterface;
if( bNew )
{
HB_TRACE( HB_TR_DEBUG, ( "ph=%p _new_QDesignerFormEditorInterface under p->pq", pObj ) );
}
else
{
HB_TRACE( HB_TR_DEBUG, ( "ph=%p NOT_new_QDesignerFormEditorInterface", pObj ) );
}
return p;
}
HB_FUNC( QT_QDESIGNERFORMEDITORINTERFACE )
{
QDesignerFormEditorInterface * pObj = NULL;
if( HB_ISPOINTER( 1 ) )
{
pObj = new QDesignerFormEditorInterface( hbqt_par_QObject( 1 ) ) ;
}
else
{
pObj = new QDesignerFormEditorInterface() ;
}
hb_retptrGC( hbqt_gcAllocate_QDesignerFormEditorInterface( ( void * ) pObj, true ) );
}
/*
* QDesignerActionEditorInterface * actionEditor () const
*/
HB_FUNC( QT_QDESIGNERFORMEDITORINTERFACE_ACTIONEDITOR )
{
QDesignerFormEditorInterface * p = hbqt_par_QDesignerFormEditorInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QDesignerActionEditorInterface( ( p )->actionEditor(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMEDITORINTERFACE_ACTIONEDITOR FP=hb_retptrGC( hbqt_gcAllocate_QDesignerActionEditorInterface( ( p )->actionEditor(), false ) ); p is NULL" ) );
}
}
/*
* QDesignerFormWindowManagerInterface * formWindowManager () const
*/
HB_FUNC( QT_QDESIGNERFORMEDITORINTERFACE_FORMWINDOWMANAGER )
{
QDesignerFormEditorInterface * p = hbqt_par_QDesignerFormEditorInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QDesignerFormWindowManagerInterface( ( p )->formWindowManager(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMEDITORINTERFACE_FORMWINDOWMANAGER FP=hb_retptrGC( hbqt_gcAllocate_QDesignerFormWindowManagerInterface( ( p )->formWindowManager(), false ) ); p is NULL" ) );
}
}
/*
* QDesignerObjectInspectorInterface * objectInspector () const
*/
HB_FUNC( QT_QDESIGNERFORMEDITORINTERFACE_OBJECTINSPECTOR )
{
QDesignerFormEditorInterface * p = hbqt_par_QDesignerFormEditorInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QDesignerObjectInspectorInterface( ( p )->objectInspector(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMEDITORINTERFACE_OBJECTINSPECTOR FP=hb_retptrGC( hbqt_gcAllocate_QDesignerObjectInspectorInterface( ( p )->objectInspector(), false ) ); p is NULL" ) );
}
}
/*
* QDesignerPropertyEditorInterface * propertyEditor () const
*/
HB_FUNC( QT_QDESIGNERFORMEDITORINTERFACE_PROPERTYEDITOR )
{
QDesignerFormEditorInterface * p = hbqt_par_QDesignerFormEditorInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QDesignerPropertyEditorInterface( ( p )->propertyEditor(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMEDITORINTERFACE_PROPERTYEDITOR FP=hb_retptrGC( hbqt_gcAllocate_QDesignerPropertyEditorInterface( ( p )->propertyEditor(), false ) ); p is NULL" ) );
}
}
/*
* void setActionEditor ( QDesignerActionEditorInterface * actionEditor )
*/
HB_FUNC( QT_QDESIGNERFORMEDITORINTERFACE_SETACTIONEDITOR )
{
QDesignerFormEditorInterface * p = hbqt_par_QDesignerFormEditorInterface( 1 );
if( p )
( p )->setActionEditor( hbqt_par_QDesignerActionEditorInterface( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMEDITORINTERFACE_SETACTIONEDITOR FP=( p )->setActionEditor( hbqt_par_QDesignerActionEditorInterface( 2 ) ); p is NULL" ) );
}
}
/*
* void setObjectInspector ( QDesignerObjectInspectorInterface * objectInspector )
*/
HB_FUNC( QT_QDESIGNERFORMEDITORINTERFACE_SETOBJECTINSPECTOR )
{
QDesignerFormEditorInterface * p = hbqt_par_QDesignerFormEditorInterface( 1 );
if( p )
( p )->setObjectInspector( hbqt_par_QDesignerObjectInspectorInterface( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMEDITORINTERFACE_SETOBJECTINSPECTOR FP=( p )->setObjectInspector( hbqt_par_QDesignerObjectInspectorInterface( 2 ) ); p is NULL" ) );
}
}
/*
* void setPropertyEditor ( QDesignerPropertyEditorInterface * propertyEditor )
*/
HB_FUNC( QT_QDESIGNERFORMEDITORINTERFACE_SETPROPERTYEDITOR )
{
QDesignerFormEditorInterface * p = hbqt_par_QDesignerFormEditorInterface( 1 );
if( p )
( p )->setPropertyEditor( hbqt_par_QDesignerPropertyEditorInterface( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMEDITORINTERFACE_SETPROPERTYEDITOR FP=( p )->setPropertyEditor( hbqt_par_QDesignerPropertyEditorInterface( 2 ) ); p is NULL" ) );
}
}
/*
* void setWidgetBox ( QDesignerWidgetBoxInterface * widgetBox )
*/
HB_FUNC( QT_QDESIGNERFORMEDITORINTERFACE_SETWIDGETBOX )
{
QDesignerFormEditorInterface * p = hbqt_par_QDesignerFormEditorInterface( 1 );
if( p )
( p )->setWidgetBox( hbqt_par_QDesignerWidgetBoxInterface( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMEDITORINTERFACE_SETWIDGETBOX FP=( p )->setWidgetBox( hbqt_par_QDesignerWidgetBoxInterface( 2 ) ); p is NULL" ) );
}
}
/*
* QWidget * topLevel () const
*/
HB_FUNC( QT_QDESIGNERFORMEDITORINTERFACE_TOPLEVEL )
{
QDesignerFormEditorInterface * p = hbqt_par_QDesignerFormEditorInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QWidget( ( p )->topLevel(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMEDITORINTERFACE_TOPLEVEL FP=hb_retptrGC( hbqt_gcAllocate_QWidget( ( p )->topLevel(), false ) ); p is NULL" ) );
}
}
/*
* QDesignerWidgetBoxInterface * widgetBox () const
*/
HB_FUNC( QT_QDESIGNERFORMEDITORINTERFACE_WIDGETBOX )
{
QDesignerFormEditorInterface * p = hbqt_par_QDesignerFormEditorInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QDesignerWidgetBoxInterface( ( p )->widgetBox(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMEDITORINTERFACE_WIDGETBOX FP=hb_retptrGC( hbqt_gcAllocate_QDesignerWidgetBoxInterface( ( p )->widgetBox(), false ) ); p is NULL" ) );
}
}
/*----------------------------------------------------------------------*/
#endif /* #if QT_VERSION >= 0x040500 */
/*----------------------------------------------------------------------*/

326
harbour/contrib/hbqt/qtdesigner/QDesignerFormWindowCursorInterface.cpp Normal file
View File

@@ -0,0 +1,326 @@
/*
* $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-2010 Pritpal Bedi <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* www - http://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 "../hbqt.h"
/*----------------------------------------------------------------------*/
#if QT_VERSION >= 0x040500
/*----------------------------------------------------------------------*/
/*
* enum MoveMode { MoveAnchor, KeepAnchor }
* enum MoveOperation { NoMove, Start, End, Next, ..., Down }
*/
#include <QtCore/QPointer>
#include <QtDesigner/QDesignerFormWindowCursorInterface>
#include "hbqt_garbage.h"
#include "hbqt_local.h"
/*
* ~QDesignerFormWindowCursorInterface ()
*
*/
typedef struct
{
QDesignerFormWindowCursorInterface * ph;
bool bNew;
QT_G_FUNC_PTR func;
} QGC_POINTER_QDesignerFormWindowCursorInterface;
QT_G_FUNC( hbqt_gcRelease_QDesignerFormWindowCursorInterface )
{
HB_SYMBOL_UNUSED( Cargo );
QGC_POINTER * p = ( QGC_POINTER * ) Cargo;
if( p && p->bNew )
{
p->ph = NULL;
}
}
void * hbqt_gcAllocate_QDesignerFormWindowCursorInterface( void * pObj, bool bNew )
{
QGC_POINTER * p = ( QGC_POINTER * ) hb_gcAllocate( sizeof( QGC_POINTER ), hbqt_gcFuncs() );
p->ph = ( QDesignerFormWindowCursorInterface * ) pObj;
p->bNew = bNew;
p->func = hbqt_gcRelease_QDesignerFormWindowCursorInterface;
if( bNew )
{
HB_TRACE( HB_TR_DEBUG, ( "ph=%p _new_QDesignerFormWindowCursorInterface", pObj ) );
}
else
{
HB_TRACE( HB_TR_DEBUG, ( "ph=%p NOT_new_QDesignerFormWindowCursorInterface", pObj ) );
}
return p;
}
HB_FUNC( QT_QDESIGNERFORMWINDOWCURSORINTERFACE )
{
//hb_retptr( new QDesignerFormWindowCursorInterface() );
}
/*
* virtual QWidget * current () const = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWCURSORINTERFACE_CURRENT )
{
QDesignerFormWindowCursorInterface * p = hbqt_par_QDesignerFormWindowCursorInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QWidget( ( p )->current(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWCURSORINTERFACE_CURRENT FP=hb_retptrGC( hbqt_gcAllocate_QWidget( ( p )->current(), false ) ); p is NULL" ) );
}
}
/*
* virtual QDesignerFormWindowInterface * formWindow () const = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWCURSORINTERFACE_FORMWINDOW )
{
QDesignerFormWindowCursorInterface * p = hbqt_par_QDesignerFormWindowCursorInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QDesignerFormWindowInterface( ( p )->formWindow(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWCURSORINTERFACE_FORMWINDOW FP=hb_retptrGC( hbqt_gcAllocate_QDesignerFormWindowInterface( ( p )->formWindow(), false ) ); p is NULL" ) );
}
}
/*
* virtual bool hasSelection () const = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWCURSORINTERFACE_HASSELECTION )
{
QDesignerFormWindowCursorInterface * p = hbqt_par_QDesignerFormWindowCursorInterface( 1 );
if( p )
hb_retl( ( p )->hasSelection() );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWCURSORINTERFACE_HASSELECTION FP=hb_retl( ( p )->hasSelection() ); p is NULL" ) );
}
}
/*
* bool isWidgetSelected ( QWidget * widget ) const
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWCURSORINTERFACE_ISWIDGETSELECTED )
{
QDesignerFormWindowCursorInterface * p = hbqt_par_QDesignerFormWindowCursorInterface( 1 );
if( p )
hb_retl( ( p )->isWidgetSelected( hbqt_par_QWidget( 2 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWCURSORINTERFACE_ISWIDGETSELECTED FP=hb_retl( ( p )->isWidgetSelected( hbqt_par_QWidget( 2 ) ) ); p is NULL" ) );
}
}
/*
* virtual bool movePosition ( MoveOperation operation, MoveMode mode = MoveAnchor ) = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWCURSORINTERFACE_MOVEPOSITION )
{
QDesignerFormWindowCursorInterface * p = hbqt_par_QDesignerFormWindowCursorInterface( 1 );
if( p )
hb_retl( ( p )->movePosition( ( QDesignerFormWindowCursorInterface::MoveOperation ) hb_parni( 2 ), ( HB_ISNUM( 3 ) ? ( QDesignerFormWindowCursorInterface::MoveMode ) hb_parni( 3 ) : ( QDesignerFormWindowCursorInterface::MoveMode ) QDesignerFormWindowCursorInterface::MoveAnchor ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWCURSORINTERFACE_MOVEPOSITION FP=hb_retl( ( p )->movePosition( ( QDesignerFormWindowCursorInterface::MoveOperation ) hb_parni( 2 ), ( HB_ISNUM( 3 ) ? ( QDesignerFormWindowCursorInterface::MoveMode ) hb_parni( 3 ) : ( QDesignerFormWindowCursorInterface::MoveMode ) QDesignerFormWindowCursorInterface::MoveAnchor ) ) ); p is NULL" ) );
}
}
/*
* virtual int position () const = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWCURSORINTERFACE_POSITION )
{
QDesignerFormWindowCursorInterface * p = hbqt_par_QDesignerFormWindowCursorInterface( 1 );
if( p )
hb_retni( ( p )->position() );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWCURSORINTERFACE_POSITION FP=hb_retni( ( p )->position() ); p is NULL" ) );
}
}
/*
* virtual void resetWidgetProperty ( QWidget * widget, const QString & name ) = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWCURSORINTERFACE_RESETWIDGETPROPERTY )
{
QDesignerFormWindowCursorInterface * p = hbqt_par_QDesignerFormWindowCursorInterface( 1 );
if( p )
( p )->resetWidgetProperty( hbqt_par_QWidget( 2 ), hbqt_par_QString( 3 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWCURSORINTERFACE_RESETWIDGETPROPERTY FP=( p )->resetWidgetProperty( hbqt_par_QWidget( 2 ), hbqt_par_QString( 3 ) ); p is NULL" ) );
}
}
/*
* virtual QWidget * selectedWidget ( int index ) const = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWCURSORINTERFACE_SELECTEDWIDGET )
{
QDesignerFormWindowCursorInterface * p = hbqt_par_QDesignerFormWindowCursorInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QWidget( ( p )->selectedWidget( hb_parni( 2 ) ), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWCURSORINTERFACE_SELECTEDWIDGET FP=hb_retptrGC( hbqt_gcAllocate_QWidget( ( p )->selectedWidget( hb_parni( 2 ) ), false ) ); p is NULL" ) );
}
}
/*
* virtual int selectedWidgetCount () const = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWCURSORINTERFACE_SELECTEDWIDGETCOUNT )
{
QDesignerFormWindowCursorInterface * p = hbqt_par_QDesignerFormWindowCursorInterface( 1 );
if( p )
hb_retni( ( p )->selectedWidgetCount() );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWCURSORINTERFACE_SELECTEDWIDGETCOUNT FP=hb_retni( ( p )->selectedWidgetCount() ); p is NULL" ) );
}
}
/*
* virtual void setPosition ( int position, MoveMode mode = MoveAnchor ) = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWCURSORINTERFACE_SETPOSITION )
{
QDesignerFormWindowCursorInterface * p = hbqt_par_QDesignerFormWindowCursorInterface( 1 );
if( p )
( p )->setPosition( hb_parni( 2 ), ( HB_ISNUM( 3 ) ? ( QDesignerFormWindowCursorInterface::MoveMode ) hb_parni( 3 ) : ( QDesignerFormWindowCursorInterface::MoveMode ) QDesignerFormWindowCursorInterface::MoveAnchor ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWCURSORINTERFACE_SETPOSITION FP=( p )->setPosition( hb_parni( 2 ), ( HB_ISNUM( 3 ) ? ( QDesignerFormWindowCursorInterface::MoveMode ) hb_parni( 3 ) : ( QDesignerFormWindowCursorInterface::MoveMode ) QDesignerFormWindowCursorInterface::MoveAnchor ) ); p is NULL" ) );
}
}
/*
* virtual void setProperty ( const QString & name, const QVariant & value ) = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWCURSORINTERFACE_SETPROPERTY )
{
QDesignerFormWindowCursorInterface * p = hbqt_par_QDesignerFormWindowCursorInterface( 1 );
if( p )
( p )->setProperty( hbqt_par_QString( 2 ), *hbqt_par_QVariant( 3 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWCURSORINTERFACE_SETPROPERTY FP=( p )->setProperty( hbqt_par_QString( 2 ), *hbqt_par_QVariant( 3 ) ); p is NULL" ) );
}
}
/*
* virtual void setWidgetProperty ( QWidget * widget, const QString & name, const QVariant & value ) = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWCURSORINTERFACE_SETWIDGETPROPERTY )
{
QDesignerFormWindowCursorInterface * p = hbqt_par_QDesignerFormWindowCursorInterface( 1 );
if( p )
( p )->setWidgetProperty( hbqt_par_QWidget( 2 ), hbqt_par_QString( 3 ), *hbqt_par_QVariant( 4 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWCURSORINTERFACE_SETWIDGETPROPERTY FP=( p )->setWidgetProperty( hbqt_par_QWidget( 2 ), hbqt_par_QString( 3 ), *hbqt_par_QVariant( 4 ) ); p is NULL" ) );
}
}
/*
* virtual QWidget * widget ( int index ) const = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWCURSORINTERFACE_WIDGET )
{
QDesignerFormWindowCursorInterface * p = hbqt_par_QDesignerFormWindowCursorInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QWidget( ( p )->widget( hb_parni( 2 ) ), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWCURSORINTERFACE_WIDGET FP=hb_retptrGC( hbqt_gcAllocate_QWidget( ( p )->widget( hb_parni( 2 ) ), false ) ); p is NULL" ) );
}
}
/*
* virtual int widgetCount () const = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWCURSORINTERFACE_WIDGETCOUNT )
{
QDesignerFormWindowCursorInterface * p = hbqt_par_QDesignerFormWindowCursorInterface( 1 );
if( p )
hb_retni( ( p )->widgetCount() );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWCURSORINTERFACE_WIDGETCOUNT FP=hb_retni( ( p )->widgetCount() ); p is NULL" ) );
}
}
/*----------------------------------------------------------------------*/
#endif /* #if QT_VERSION >= 0x040500 */
/*----------------------------------------------------------------------*/

683
harbour/contrib/hbqt/qtdesigner/QDesignerFormWindowInterface.cpp Normal file
View File

@@ -0,0 +1,683 @@
/*
* $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-2010 Pritpal Bedi <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* www - http://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 "../hbqt.h"
/*----------------------------------------------------------------------*/
#if QT_VERSION >= 0x040500
/*----------------------------------------------------------------------*/
/*
* flags Feature
* enum FeatureFlag { EditFeature, GridFeature, TabOrderFeature, DefaultFeature }
*/
#include <QtCore/QPointer>
#include <QtDesigner/QDesignerFormWindowInterface>
#include "hbqt_garbage.h"
#include "hbqt_local.h"
/*
* QDesignerFormWindowInterface ( QWidget * parent = 0, Qt::WindowFlags flags = 0 )
* ~QDesignerFormWindowInterface ()
*
*/
typedef struct
{
QPointer< QDesignerFormWindowInterface > ph;
bool bNew;
QT_G_FUNC_PTR func;
} QGC_POINTER_QDesignerFormWindowInterface;
QT_G_FUNC( hbqt_gcRelease_QDesignerFormWindowInterface )
{
HB_SYMBOL_UNUSED( Cargo );
QGC_POINTER * p = ( QGC_POINTER * ) Cargo;
if( p && p->bNew )
{
p->ph = NULL;
}
}
void * hbqt_gcAllocate_QDesignerFormWindowInterface( void * pObj, bool bNew )
{
QGC_POINTER_QDesignerFormWindowInterface * p = ( QGC_POINTER_QDesignerFormWindowInterface * ) hb_gcAllocate( sizeof( QGC_POINTER_QDesignerFormWindowInterface ), hbqt_gcFuncs() );
new( & p->ph ) QPointer< QDesignerFormWindowInterface >( ( QDesignerFormWindowInterface * ) pObj );
p->bNew = bNew;
p->func = hbqt_gcRelease_QDesignerFormWindowInterface;
if( bNew )
{
HB_TRACE( HB_TR_DEBUG, ( "ph=%p _new_QDesignerFormWindowInterface under p->pq", pObj ) );
}
else
{
HB_TRACE( HB_TR_DEBUG, ( "ph=%p NOT_new_QDesignerFormWindowInterface", pObj ) );
}
return p;
}
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE )
{
//hb_retptr( new QDesignerFormWindowInterface() );
}
/*
* virtual void addResourceFile ( const QString & path ) = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_ADDRESOURCEFILE )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
( p )->addResourceFile( QDesignerFormWindowInterface::tr( hb_parc( 2 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_ADDRESOURCEFILE FP=( p )->addResourceFile( QDesignerFormWindowInterface::tr( hb_parc( 2 ) ) ); p is NULL" ) );
}
}
/*
* virtual QString author () const = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_AUTHOR )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
hb_retc( ( p )->author().toAscii().data() );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_AUTHOR FP=hb_retc( ( p )->author().toAscii().data() ); p is NULL" ) );
}
}
/*
* virtual QString comment () const = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_COMMENT )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
hb_retc( ( p )->comment().toAscii().data() );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_COMMENT FP=hb_retc( ( p )->comment().toAscii().data() ); p is NULL" ) );
}
}
/*
* virtual QString contents () const = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_CONTENTS )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
hb_retc( ( p )->contents().toAscii().data() );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_CONTENTS FP=hb_retc( ( p )->contents().toAscii().data() ); p is NULL" ) );
}
}
/*
* virtual QDesignerFormEditorInterface * core () const
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_CORE )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QDesignerFormEditorInterface( ( p )->core(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_CORE FP=hb_retptrGC( hbqt_gcAllocate_QDesignerFormEditorInterface( ( p )->core(), false ) ); p is NULL" ) );
}
}
/*
* virtual QDesignerFormWindowCursorInterface * cursor () const = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_CURSOR )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QDesignerFormWindowCursorInterface( ( p )->cursor(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_CURSOR FP=hb_retptrGC( hbqt_gcAllocate_QDesignerFormWindowCursorInterface( ( p )->cursor(), false ) ); p is NULL" ) );
}
}
/*
* virtual void emitSelectionChanged () = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_EMITSELECTIONCHANGED )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
( p )->emitSelectionChanged();
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_EMITSELECTIONCHANGED FP=( p )->emitSelectionChanged(); p is NULL" ) );
}
}
/*
* virtual QString exportMacro () const = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_EXPORTMACRO )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
hb_retc( ( p )->exportMacro().toAscii().data() );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_EXPORTMACRO FP=hb_retc( ( p )->exportMacro().toAscii().data() ); p is NULL" ) );
}
}
/*
* virtual Feature features () const = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_FEATURES )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
hb_retni( ( QDesignerFormWindowInterface::Feature ) ( p )->features() );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_FEATURES FP=hb_retni( ( QDesignerFormWindowInterface::Feature ) ( p )->features() ); p is NULL" ) );
}
}
/*
* virtual QString fileName () const = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_FILENAME )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
hb_retc( ( p )->fileName().toAscii().data() );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_FILENAME FP=hb_retc( ( p )->fileName().toAscii().data() ); p is NULL" ) );
}
}
/*
* virtual QPoint grid () const = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_GRID )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QPoint( new QPoint( ( p )->grid() ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_GRID FP=hb_retptrGC( hbqt_gcAllocate_QPoint( new QPoint( ( p )->grid() ), true ) ); p is NULL" ) );
}
}
/*
* virtual bool hasFeature ( Feature feature ) const = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_HASFEATURE )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
hb_retl( ( p )->hasFeature( ( QDesignerFormWindowInterface::Feature ) hb_parni( 2 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_HASFEATURE FP=hb_retl( ( p )->hasFeature( ( QDesignerFormWindowInterface::Feature ) hb_parni( 2 ) ) ); p is NULL" ) );
}
}
/*
* virtual QStringList includeHints () const = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_INCLUDEHINTS )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QStringList( new QStringList( ( p )->includeHints() ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_INCLUDEHINTS FP=hb_retptrGC( hbqt_gcAllocate_QStringList( new QStringList( ( p )->includeHints() ), true ) ); p is NULL" ) );
}
}
/*
* virtual bool isDirty () const = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_ISDIRTY )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
hb_retl( ( p )->isDirty() );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_ISDIRTY FP=hb_retl( ( p )->isDirty() ); p is NULL" ) );
}
}
/*
* virtual bool isManaged ( QWidget * widget ) const = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_ISMANAGED )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
hb_retl( ( p )->isManaged( hbqt_par_QWidget( 2 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_ISMANAGED FP=hb_retl( ( p )->isManaged( hbqt_par_QWidget( 2 ) ) ); p is NULL" ) );
}
}
/*
* virtual void layoutDefault ( int * margin, int * spacing ) = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_LAYOUTDEFAULT )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
int iMargin = 0;
int iSpacing = 0;
if( p )
( p )->layoutDefault( &iMargin, &iSpacing );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_LAYOUTDEFAULT FP=( p )->layoutDefault( &iMargin, &iSpacing ); p is NULL" ) );
}
hb_storni( iMargin, 2 );
hb_storni( iSpacing, 3 );
}
/*
* virtual QWidget * mainContainer () const = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_MAINCONTAINER )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QWidget( ( p )->mainContainer(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_MAINCONTAINER FP=hb_retptrGC( hbqt_gcAllocate_QWidget( ( p )->mainContainer(), false ) ); p is NULL" ) );
}
}
/*
* virtual QString pixmapFunction () const = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_PIXMAPFUNCTION )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
hb_retc( ( p )->pixmapFunction().toAscii().data() );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_PIXMAPFUNCTION FP=hb_retc( ( p )->pixmapFunction().toAscii().data() ); p is NULL" ) );
}
}
/*
* virtual void removeResourceFile ( const QString & path ) = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_REMOVERESOURCEFILE )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
( p )->removeResourceFile( QDesignerFormWindowInterface::tr( hb_parc( 2 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_REMOVERESOURCEFILE FP=( p )->removeResourceFile( QDesignerFormWindowInterface::tr( hb_parc( 2 ) ) ); p is NULL" ) );
}
}
/*
* virtual QStringList resourceFiles () const = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_RESOURCEFILES )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QStringList( new QStringList( ( p )->resourceFiles() ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_RESOURCEFILES FP=hb_retptrGC( hbqt_gcAllocate_QStringList( new QStringList( ( p )->resourceFiles() ), true ) ); p is NULL" ) );
}
}
/*
* virtual void setAuthor ( const QString & author ) = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_SETAUTHOR )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
( p )->setAuthor( QDesignerFormWindowInterface::tr( hb_parc( 2 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_SETAUTHOR FP=( p )->setAuthor( QDesignerFormWindowInterface::tr( hb_parc( 2 ) ) ); p is NULL" ) );
}
}
/*
* virtual void setComment ( const QString & comment ) = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_SETCOMMENT )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
( p )->setComment( QDesignerFormWindowInterface::tr( hb_parc( 2 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_SETCOMMENT FP=( p )->setComment( QDesignerFormWindowInterface::tr( hb_parc( 2 ) ) ); p is NULL" ) );
}
}
/*
* virtual void setContents ( QIODevice * device ) = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_SETCONTENTS )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
( p )->setContents( hbqt_par_QIODevice( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_SETCONTENTS FP=( p )->setContents( hbqt_par_QIODevice( 2 ) ); p is NULL" ) );
}
}
/*
* virtual void setExportMacro ( const QString & exportMacro ) = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_SETEXPORTMACRO )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
( p )->setExportMacro( QDesignerFormWindowInterface::tr( hb_parc( 2 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_SETEXPORTMACRO FP=( p )->setExportMacro( QDesignerFormWindowInterface::tr( hb_parc( 2 ) ) ); p is NULL" ) );
}
}
/*
* virtual void setIncludeHints ( const QStringList & includeHints ) = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_SETINCLUDEHINTS )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
( p )->setIncludeHints( *hbqt_par_QStringList( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_SETINCLUDEHINTS FP=( p )->setIncludeHints( *hbqt_par_QStringList( 2 ) ); p is NULL" ) );
}
}
/*
* virtual void setLayoutDefault ( int margin, int spacing ) = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_SETLAYOUTDEFAULT )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
( p )->setLayoutDefault( hb_parni( 2 ), hb_parni( 3 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_SETLAYOUTDEFAULT FP=( p )->setLayoutDefault( hb_parni( 2 ), hb_parni( 3 ) ); p is NULL" ) );
}
}
/*
* virtual void setMainContainer ( QWidget * mainContainer ) = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_SETMAINCONTAINER )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
( p )->setMainContainer( hbqt_par_QWidget( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_SETMAINCONTAINER FP=( p )->setMainContainer( hbqt_par_QWidget( 2 ) ); p is NULL" ) );
}
}
/*
* virtual void setPixmapFunction ( const QString & pixmapFunction ) = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_SETPIXMAPFUNCTION )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
( p )->setPixmapFunction( QDesignerFormWindowInterface::tr( hb_parc( 2 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_SETPIXMAPFUNCTION FP=( p )->setPixmapFunction( QDesignerFormWindowInterface::tr( hb_parc( 2 ) ) ); p is NULL" ) );
}
}
/*
* QDesignerFormWindowInterface * findFormWindow ( QWidget * widget )
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_FINDFORMWINDOW )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QDesignerFormWindowInterface( ( p )->findFormWindow( hbqt_par_QWidget( 2 ) ), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_FINDFORMWINDOW FP=hb_retptrGC( hbqt_gcAllocate_QDesignerFormWindowInterface( ( p )->findFormWindow( hbqt_par_QWidget( 2 ) ), false ) ); p is NULL" ) );
}
}
/*
* QDesignerFormWindowInterface * findFormWindow ( QObject * object )
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_FINDFORMWINDOW_1 )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QDesignerFormWindowInterface( ( p )->findFormWindow( hbqt_par_QObject( 2 ) ), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_FINDFORMWINDOW_1 FP=hb_retptrGC( hbqt_gcAllocate_QDesignerFormWindowInterface( ( p )->findFormWindow( hbqt_par_QObject( 2 ) ), false ) ); p is NULL" ) );
}
}
/*
* virtual void clearSelection ( bool update = true ) = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_CLEARSELECTION )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
( p )->clearSelection( hb_parl( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_CLEARSELECTION FP=( p )->clearSelection( hb_parl( 2 ) ); p is NULL" ) );
}
}
/*
* virtual void manageWidget ( QWidget * widget ) = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_MANAGEWIDGET )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
( p )->manageWidget( hbqt_par_QWidget( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_MANAGEWIDGET FP=( p )->manageWidget( hbqt_par_QWidget( 2 ) ); p is NULL" ) );
}
}
/*
* virtual void selectWidget ( QWidget * widget, bool select = true ) = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_SELECTWIDGET )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
( p )->selectWidget( hbqt_par_QWidget( 2 ), hb_parl( 3 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_SELECTWIDGET FP=( p )->selectWidget( hbqt_par_QWidget( 2 ), hb_parl( 3 ) ); p is NULL" ) );
}
}
/*
* virtual void setContents ( const QString & contents ) = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_SETCONTENTS_1 )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
( p )->setContents( QDesignerFormWindowInterface::tr( hb_parc( 2 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_SETCONTENTS_1 FP=( p )->setContents( QDesignerFormWindowInterface::tr( hb_parc( 2 ) ) ); p is NULL" ) );
}
}
/*
* virtual void setDirty ( bool dirty ) = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_SETDIRTY )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
( p )->setDirty( hb_parl( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_SETDIRTY FP=( p )->setDirty( hb_parl( 2 ) ); p is NULL" ) );
}
}
/*
* virtual void setFeatures ( Feature features ) = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_SETFEATURES )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
( p )->setFeatures( ( QDesignerFormWindowInterface::Feature ) hb_parni( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_SETFEATURES FP=( p )->setFeatures( ( QDesignerFormWindowInterface::Feature ) hb_parni( 2 ) ); p is NULL" ) );
}
}
/*
* virtual void setFileName ( const QString & fileName ) = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_SETFILENAME )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
( p )->setFileName( QDesignerFormWindowInterface::tr( hb_parc( 2 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_SETFILENAME FP=( p )->setFileName( QDesignerFormWindowInterface::tr( hb_parc( 2 ) ) ); p is NULL" ) );
}
}
/*
* virtual void setGrid ( const QPoint & grid ) = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_SETGRID )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
( p )->setGrid( *hbqt_par_QPoint( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_SETGRID FP=( p )->setGrid( *hbqt_par_QPoint( 2 ) ); p is NULL" ) );
}
}
/*
* virtual void unmanageWidget ( QWidget * widget ) = 0
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE_UNMANAGEWIDGET )
{
QDesignerFormWindowInterface * p = hbqt_par_QDesignerFormWindowInterface( 1 );
if( p )
( p )->unmanageWidget( hbqt_par_QWidget( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWINTERFACE_UNMANAGEWIDGET FP=( p )->unmanageWidget( hbqt_par_QWidget( 2 ) ); p is NULL" ) );
}
}
/*----------------------------------------------------------------------*/
#endif /* #if QT_VERSION >= 0x040500 */
/*----------------------------------------------------------------------*/

490
harbour/contrib/hbqt/qtdesigner/QDesignerFormWindowManagerInterface.cpp Normal file
View File

@@ -0,0 +1,490 @@
/*
* $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-2010 Pritpal Bedi <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* www - http://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 "../hbqt.h"
/*----------------------------------------------------------------------*/
#if QT_VERSION >= 0x040500
/*----------------------------------------------------------------------*/
#include <QtCore/QPointer>
#include <QtDesigner/QDesignerFormWindowManagerInterface>
#include "hbqt_garbage.h"
#include "hbqt_local.h"
/*
* QDesignerFormWindowManagerInterface ( QObject * parent = 0 )
* ~QDesignerFormWindowManagerInterface ()
*
*/
typedef struct
{
QPointer< QDesignerFormWindowManagerInterface > ph;
bool bNew;
QT_G_FUNC_PTR func;
} QGC_POINTER_QDesignerFormWindowManagerInterface;
QT_G_FUNC( hbqt_gcRelease_QDesignerFormWindowManagerInterface )
{
HB_SYMBOL_UNUSED( Cargo );
QGC_POINTER * p = ( QGC_POINTER * ) Cargo;
if( p && p->bNew )
{
p->ph = NULL;
}
}
void * hbqt_gcAllocate_QDesignerFormWindowManagerInterface( void * pObj, bool bNew )
{
QGC_POINTER_QDesignerFormWindowManagerInterface * p = ( QGC_POINTER_QDesignerFormWindowManagerInterface * ) hb_gcAllocate( sizeof( QGC_POINTER_QDesignerFormWindowManagerInterface ), hbqt_gcFuncs() );
new( & p->ph ) QPointer< QDesignerFormWindowManagerInterface >( ( QDesignerFormWindowManagerInterface * ) pObj );
p->bNew = bNew;
p->func = hbqt_gcRelease_QDesignerFormWindowManagerInterface;
if( bNew )
{
HB_TRACE( HB_TR_DEBUG, ( "ph=%p _new_QDesignerFormWindowManagerInterface under p->pq", pObj ) );
}
else
{
HB_TRACE( HB_TR_DEBUG, ( "ph=%p NOT_new_QDesignerFormWindowManagerInterface", pObj ) );
}
return p;
}
HB_FUNC( QT_QDESIGNERFORMWINDOWMANAGERINTERFACE )
{
//hb_retptr( new QDesignerFormWindowManagerInterface() );
}
/*
* virtual QAction * actionAdjustSize () const
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONADJUSTSIZE )
{
QDesignerFormWindowManagerInterface * p = hbqt_par_QDesignerFormWindowManagerInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionAdjustSize(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONADJUSTSIZE FP=hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionAdjustSize(), false ) ); p is NULL" ) );
}
}
/*
* virtual QAction * actionBreakLayout () const
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONBREAKLAYOUT )
{
QDesignerFormWindowManagerInterface * p = hbqt_par_QDesignerFormWindowManagerInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionBreakLayout(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONBREAKLAYOUT FP=hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionBreakLayout(), false ) ); p is NULL" ) );
}
}
/*
* virtual QAction * actionCopy () const
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONCOPY )
{
QDesignerFormWindowManagerInterface * p = hbqt_par_QDesignerFormWindowManagerInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionCopy(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONCOPY FP=hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionCopy(), false ) ); p is NULL" ) );
}
}
/*
* virtual QAction * actionCut () const
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONCUT )
{
QDesignerFormWindowManagerInterface * p = hbqt_par_QDesignerFormWindowManagerInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionCut(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONCUT FP=hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionCut(), false ) ); p is NULL" ) );
}
}
/*
* virtual QAction * actionDelete () const
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONDELETE )
{
QDesignerFormWindowManagerInterface * p = hbqt_par_QDesignerFormWindowManagerInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionDelete(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONDELETE FP=hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionDelete(), false ) ); p is NULL" ) );
}
}
/*
* QAction * actionFormLayout () const
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONFORMLAYOUT )
{
QDesignerFormWindowManagerInterface * p = hbqt_par_QDesignerFormWindowManagerInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionFormLayout(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONFORMLAYOUT FP=hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionFormLayout(), false ) ); p is NULL" ) );
}
}
/*
* virtual QAction * actionGridLayout () const
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONGRIDLAYOUT )
{
QDesignerFormWindowManagerInterface * p = hbqt_par_QDesignerFormWindowManagerInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionGridLayout(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONGRIDLAYOUT FP=hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionGridLayout(), false ) ); p is NULL" ) );
}
}
/*
* virtual QAction * actionHorizontalLayout () const
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONHORIZONTALLAYOUT )
{
QDesignerFormWindowManagerInterface * p = hbqt_par_QDesignerFormWindowManagerInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionHorizontalLayout(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONHORIZONTALLAYOUT FP=hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionHorizontalLayout(), false ) ); p is NULL" ) );
}
}
/*
* virtual QAction * actionLower () const
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONLOWER )
{
QDesignerFormWindowManagerInterface * p = hbqt_par_QDesignerFormWindowManagerInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionLower(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONLOWER FP=hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionLower(), false ) ); p is NULL" ) );
}
}
/*
* virtual QAction * actionPaste () const
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONPASTE )
{
QDesignerFormWindowManagerInterface * p = hbqt_par_QDesignerFormWindowManagerInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionPaste(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONPASTE FP=hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionPaste(), false ) ); p is NULL" ) );
}
}
/*
* virtual QAction * actionRaise () const
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONRAISE )
{
QDesignerFormWindowManagerInterface * p = hbqt_par_QDesignerFormWindowManagerInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionRaise(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONRAISE FP=hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionRaise(), false ) ); p is NULL" ) );
}
}
/*
* virtual QAction * actionRedo () const
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONREDO )
{
QDesignerFormWindowManagerInterface * p = hbqt_par_QDesignerFormWindowManagerInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionRedo(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONREDO FP=hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionRedo(), false ) ); p is NULL" ) );
}
}
/*
* virtual QAction * actionSelectAll () const
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONSELECTALL )
{
QDesignerFormWindowManagerInterface * p = hbqt_par_QDesignerFormWindowManagerInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionSelectAll(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONSELECTALL FP=hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionSelectAll(), false ) ); p is NULL" ) );
}
}
/*
* QAction * actionSimplifyLayout () const
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONSIMPLIFYLAYOUT )
{
QDesignerFormWindowManagerInterface * p = hbqt_par_QDesignerFormWindowManagerInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionSimplifyLayout(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONSIMPLIFYLAYOUT FP=hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionSimplifyLayout(), false ) ); p is NULL" ) );
}
}
/*
* virtual QAction * actionSplitHorizontal () const
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONSPLITHORIZONTAL )
{
QDesignerFormWindowManagerInterface * p = hbqt_par_QDesignerFormWindowManagerInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionSplitHorizontal(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONSPLITHORIZONTAL FP=hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionSplitHorizontal(), false ) ); p is NULL" ) );
}
}
/*
* virtual QAction * actionSplitVertical () const
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONSPLITVERTICAL )
{
QDesignerFormWindowManagerInterface * p = hbqt_par_QDesignerFormWindowManagerInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionSplitVertical(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONSPLITVERTICAL FP=hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionSplitVertical(), false ) ); p is NULL" ) );
}
}
/*
* virtual QAction * actionUndo () const
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONUNDO )
{
QDesignerFormWindowManagerInterface * p = hbqt_par_QDesignerFormWindowManagerInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionUndo(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONUNDO FP=hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionUndo(), false ) ); p is NULL" ) );
}
}
/*
* virtual QAction * actionVerticalLayout () const
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONVERTICALLAYOUT )
{
QDesignerFormWindowManagerInterface * p = hbqt_par_QDesignerFormWindowManagerInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionVerticalLayout(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIONVERTICALLAYOUT FP=hb_retptrGC( hbqt_gcAllocate_QAction( ( p )->actionVerticalLayout(), false ) ); p is NULL" ) );
}
}
/*
* virtual QDesignerFormWindowInterface * activeFormWindow () const
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIVEFORMWINDOW )
{
QDesignerFormWindowManagerInterface * p = hbqt_par_QDesignerFormWindowManagerInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QDesignerFormWindowInterface( ( p )->activeFormWindow(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ACTIVEFORMWINDOW FP=hb_retptrGC( hbqt_gcAllocate_QDesignerFormWindowInterface( ( p )->activeFormWindow(), false ) ); p is NULL" ) );
}
}
/*
* virtual QDesignerFormEditorInterface * core () const
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_CORE )
{
QDesignerFormWindowManagerInterface * p = hbqt_par_QDesignerFormWindowManagerInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QDesignerFormEditorInterface( ( p )->core(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_CORE FP=hb_retptrGC( hbqt_gcAllocate_QDesignerFormEditorInterface( ( p )->core(), false ) ); p is NULL" ) );
}
}
/*
* virtual QDesignerFormWindowInterface * createFormWindow ( QWidget * parent = 0, Qt::WindowFlags flags = 0 )
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_CREATEFORMWINDOW )
{
QDesignerFormWindowManagerInterface * p = hbqt_par_QDesignerFormWindowManagerInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QDesignerFormWindowInterface( ( p )->createFormWindow( hbqt_par_QWidget( 2 ), ( Qt::WindowFlags ) hb_parni( 3 ) ), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_CREATEFORMWINDOW FP=hb_retptrGC( hbqt_gcAllocate_QDesignerFormWindowInterface( ( p )->createFormWindow( hbqt_par_QWidget( 2 ), ( Qt::WindowFlags ) hb_parni( 3 ) ), false ) ); p is NULL" ) );
}
}
/*
* virtual QDesignerFormWindowInterface * formWindow ( int index ) const
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_FORMWINDOW )
{
QDesignerFormWindowManagerInterface * p = hbqt_par_QDesignerFormWindowManagerInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QDesignerFormWindowInterface( ( p )->formWindow( hb_parni( 2 ) ), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_FORMWINDOW FP=hb_retptrGC( hbqt_gcAllocate_QDesignerFormWindowInterface( ( p )->formWindow( hb_parni( 2 ) ), false ) ); p is NULL" ) );
}
}
/*
* virtual int formWindowCount () const
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_FORMWINDOWCOUNT )
{
QDesignerFormWindowManagerInterface * p = hbqt_par_QDesignerFormWindowManagerInterface( 1 );
if( p )
hb_retni( ( p )->formWindowCount() );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_FORMWINDOWCOUNT FP=hb_retni( ( p )->formWindowCount() ); p is NULL" ) );
}
}
/*
* virtual void addFormWindow ( QDesignerFormWindowInterface * formWindow )
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ADDFORMWINDOW )
{
QDesignerFormWindowManagerInterface * p = hbqt_par_QDesignerFormWindowManagerInterface( 1 );
if( p )
( p )->addFormWindow( hbqt_par_QDesignerFormWindowInterface( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_ADDFORMWINDOW FP=( p )->addFormWindow( hbqt_par_QDesignerFormWindowInterface( 2 ) ); p is NULL" ) );
}
}
/*
* virtual void removeFormWindow ( QDesignerFormWindowInterface * formWindow )
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_REMOVEFORMWINDOW )
{
QDesignerFormWindowManagerInterface * p = hbqt_par_QDesignerFormWindowManagerInterface( 1 );
if( p )
( p )->removeFormWindow( hbqt_par_QDesignerFormWindowInterface( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_REMOVEFORMWINDOW FP=( p )->removeFormWindow( hbqt_par_QDesignerFormWindowInterface( 2 ) ); p is NULL" ) );
}
}
/*
* virtual void setActiveFormWindow ( QDesignerFormWindowInterface * formWindow )
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_SETACTIVEFORMWINDOW )
{
QDesignerFormWindowManagerInterface * p = hbqt_par_QDesignerFormWindowManagerInterface( 1 );
if( p )
( p )->setActiveFormWindow( hbqt_par_QDesignerFormWindowInterface( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERFORMWINDOWMANAGERINTERFACE_SETACTIVEFORMWINDOW FP=( p )->setActiveFormWindow( hbqt_par_QDesignerFormWindowInterface( 2 ) ); p is NULL" ) );
}
}
/*----------------------------------------------------------------------*/
#endif /* #if QT_VERSION >= 0x040500 */
/*----------------------------------------------------------------------*/

154
harbour/contrib/hbqt/qtdesigner/QDesignerObjectInspectorInterface.cpp Normal file
View File

@@ -0,0 +1,154 @@
/*
* $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-2010 Pritpal Bedi <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* www - http://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 "../hbqt.h"
/*----------------------------------------------------------------------*/
#if QT_VERSION >= 0x040500
/*----------------------------------------------------------------------*/
#include <QtCore/QPointer>
#include <QtDesigner/QDesignerObjectInspectorInterface>
#include "hbqt_garbage.h"
#include "hbqt_local.h"
/*
* QDesignerObjectInspectorInterface ( QWidget * parent, Qt::WindowFlags flags = 0 )
* ~QDesignerObjectInspectorInterface ()
*
*/
typedef struct
{
QPointer< QDesignerObjectInspectorInterface > ph;
bool bNew;
QT_G_FUNC_PTR func;
} QGC_POINTER_QDesignerObjectInspectorInterface;
QT_G_FUNC( hbqt_gcRelease_QDesignerObjectInspectorInterface )
{
HB_SYMBOL_UNUSED( Cargo );
QGC_POINTER * p = ( QGC_POINTER * ) Cargo;
if( p && p->bNew )
{
p->ph = NULL;
}
}
void * hbqt_gcAllocate_QDesignerObjectInspectorInterface( void * pObj, bool bNew )
{
QGC_POINTER_QDesignerObjectInspectorInterface * p = ( QGC_POINTER_QDesignerObjectInspectorInterface * ) hb_gcAllocate( sizeof( QGC_POINTER_QDesignerObjectInspectorInterface ), hbqt_gcFuncs() );
new( & p->ph ) QPointer< QDesignerObjectInspectorInterface >( ( QDesignerObjectInspectorInterface * ) pObj );
p->bNew = bNew;
p->func = hbqt_gcRelease_QDesignerObjectInspectorInterface;
if( bNew )
{
HB_TRACE( HB_TR_DEBUG, ( "ph=%p _new_QDesignerObjectInspectorInterface under p->pq", pObj ) );
}
else
{
HB_TRACE( HB_TR_DEBUG, ( "ph=%p NOT_new_QDesignerObjectInspectorInterface", pObj ) );
}
return p;
}
HB_FUNC( QT_QDESIGNEROBJECTINSPECTORINTERFACE )
{
//hb_retptr( new QDesignerObjectInspectorInterface() );
}
/*
* virtual QDesignerFormEditorInterface * core () const
*/
HB_FUNC( QT_QDESIGNEROBJECTINSPECTORINTERFACE_CORE )
{
QDesignerObjectInspectorInterface * p = hbqt_par_QDesignerObjectInspectorInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QDesignerFormEditorInterface( ( p )->core(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNEROBJECTINSPECTORINTERFACE_CORE FP=hb_retptrGC( hbqt_gcAllocate_QDesignerFormEditorInterface( ( p )->core(), false ) ); p is NULL" ) );
}
}
/*
* virtual void setFormWindow ( QDesignerFormWindowInterface * formWindow ) = 0
*/
HB_FUNC( QT_QDESIGNEROBJECTINSPECTORINTERFACE_SETFORMWINDOW )
{
QDesignerObjectInspectorInterface * p = hbqt_par_QDesignerObjectInspectorInterface( 1 );
if( p )
( p )->setFormWindow( hbqt_par_QDesignerFormWindowInterface( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNEROBJECTINSPECTORINTERFACE_SETFORMWINDOW FP=( p )->setFormWindow( hbqt_par_QDesignerFormWindowInterface( 2 ) ); p is NULL" ) );
}
}
/*----------------------------------------------------------------------*/
#endif /* #if QT_VERSION >= 0x040500 */
/*----------------------------------------------------------------------*/

224
harbour/contrib/hbqt/qtdesigner/QDesignerPropertyEditorInterface.cpp Normal file
View File

@@ -0,0 +1,224 @@
/*
* $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-2010 Pritpal Bedi <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* www - http://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 "../hbqt.h"
/*----------------------------------------------------------------------*/
#if QT_VERSION >= 0x040500
/*----------------------------------------------------------------------*/
#include <QtCore/QPointer>
#include <QtDesigner/QDesignerPropertyEditorInterface>
#include "hbqt_garbage.h"
#include "hbqt_local.h"
/*
* QDesignerPropertyEditorInterface ( QWidget * parent, Qt::WindowFlags flags = 0 )
* ~QDesignerPropertyEditorInterface ()
*
*/
typedef struct
{
QPointer< QDesignerPropertyEditorInterface > ph;
bool bNew;
QT_G_FUNC_PTR func;
} QGC_POINTER_QDesignerPropertyEditorInterface;
QT_G_FUNC( hbqt_gcRelease_QDesignerPropertyEditorInterface )
{
HB_SYMBOL_UNUSED( Cargo );
QGC_POINTER * p = ( QGC_POINTER * ) Cargo;
if( p && p->bNew )
{
p->ph = NULL;
}
}
void * hbqt_gcAllocate_QDesignerPropertyEditorInterface( void * pObj, bool bNew )
{
QGC_POINTER_QDesignerPropertyEditorInterface * p = ( QGC_POINTER_QDesignerPropertyEditorInterface * ) hb_gcAllocate( sizeof( QGC_POINTER_QDesignerPropertyEditorInterface ), hbqt_gcFuncs() );
new( & p->ph ) QPointer< QDesignerPropertyEditorInterface >( ( QDesignerPropertyEditorInterface * ) pObj );
p->bNew = bNew;
p->func = hbqt_gcRelease_QDesignerPropertyEditorInterface;
if( bNew )
{
HB_TRACE( HB_TR_DEBUG, ( "ph=%p _new_QDesignerPropertyEditorInterface under p->pq", pObj ) );
}
else
{
HB_TRACE( HB_TR_DEBUG, ( "ph=%p NOT_new_QDesignerPropertyEditorInterface", pObj ) );
}
return p;
}
HB_FUNC( QT_QDESIGNERPROPERTYEDITORINTERFACE )
{
//hb_retptr( new QDesignerPropertyEditorInterface() );
}
/*
* virtual QDesignerFormEditorInterface * core () const
*/
HB_FUNC( QT_QDESIGNERPROPERTYEDITORINTERFACE_CORE )
{
QDesignerPropertyEditorInterface * p = hbqt_par_QDesignerPropertyEditorInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QDesignerFormEditorInterface( ( p )->core(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERPROPERTYEDITORINTERFACE_CORE FP=hb_retptrGC( hbqt_gcAllocate_QDesignerFormEditorInterface( ( p )->core(), false ) ); p is NULL" ) );
}
}
/*
* virtual QString currentPropertyName () const = 0
*/
HB_FUNC( QT_QDESIGNERPROPERTYEDITORINTERFACE_CURRENTPROPERTYNAME )
{
QDesignerPropertyEditorInterface * p = hbqt_par_QDesignerPropertyEditorInterface( 1 );
if( p )
hb_retc( ( p )->currentPropertyName().toAscii().data() );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERPROPERTYEDITORINTERFACE_CURRENTPROPERTYNAME FP=hb_retc( ( p )->currentPropertyName().toAscii().data() ); p is NULL" ) );
}
}
/*
* virtual bool isReadOnly () const = 0
*/
HB_FUNC( QT_QDESIGNERPROPERTYEDITORINTERFACE_ISREADONLY )
{
QDesignerPropertyEditorInterface * p = hbqt_par_QDesignerPropertyEditorInterface( 1 );
if( p )
hb_retl( ( p )->isReadOnly() );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERPROPERTYEDITORINTERFACE_ISREADONLY FP=hb_retl( ( p )->isReadOnly() ); p is NULL" ) );
}
}
/*
* virtual QObject * object () const = 0
*/
HB_FUNC( QT_QDESIGNERPROPERTYEDITORINTERFACE_OBJECT )
{
QDesignerPropertyEditorInterface * p = hbqt_par_QDesignerPropertyEditorInterface( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QObject( ( p )->object(), false ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERPROPERTYEDITORINTERFACE_OBJECT FP=hb_retptrGC( hbqt_gcAllocate_QObject( ( p )->object(), false ) ); p is NULL" ) );
}
}
/*
* virtual void setObject ( QObject * object ) = 0
*/
HB_FUNC( QT_QDESIGNERPROPERTYEDITORINTERFACE_SETOBJECT )
{
QDesignerPropertyEditorInterface * p = hbqt_par_QDesignerPropertyEditorInterface( 1 );
if( p )
( p )->setObject( hbqt_par_QObject( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERPROPERTYEDITORINTERFACE_SETOBJECT FP=( p )->setObject( hbqt_par_QObject( 2 ) ); p is NULL" ) );
}
}
/*
* virtual void setPropertyValue ( const QString & name, const QVariant & value, bool changed = true ) = 0
*/
HB_FUNC( QT_QDESIGNERPROPERTYEDITORINTERFACE_SETPROPERTYVALUE )
{
QDesignerPropertyEditorInterface * p = hbqt_par_QDesignerPropertyEditorInterface( 1 );
if( p )
( p )->setPropertyValue( QDesignerPropertyEditorInterface::tr( hb_parc( 2 ) ), *hbqt_par_QVariant( 3 ), hb_parl( 4 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERPROPERTYEDITORINTERFACE_SETPROPERTYVALUE FP=( p )->setPropertyValue( QDesignerPropertyEditorInterface::tr( hb_parc( 2 ) ), *hbqt_par_QVariant( 3 ), hb_parl( 4 ) ); p is NULL" ) );
}
}
/*
* virtual void setReadOnly ( bool readOnly ) = 0
*/
HB_FUNC( QT_QDESIGNERPROPERTYEDITORINTERFACE_SETREADONLY )
{
QDesignerPropertyEditorInterface * p = hbqt_par_QDesignerPropertyEditorInterface( 1 );
if( p )
( p )->setReadOnly( hb_parl( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERPROPERTYEDITORINTERFACE_SETREADONLY FP=( p )->setReadOnly( hb_parl( 2 ) ); p is NULL" ) );
}
}
/*----------------------------------------------------------------------*/
#endif /* #if QT_VERSION >= 0x040500 */
/*----------------------------------------------------------------------*/

182
harbour/contrib/hbqt/qtdesigner/QDesignerWidgetBoxInterface.cpp Normal file
View File

@@ -0,0 +1,182 @@
/*
* $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-2010 Pritpal Bedi <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* www - http://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 "../hbqt.h"
/*----------------------------------------------------------------------*/
#if QT_VERSION >= 0x040500
/*----------------------------------------------------------------------*/
#include <QtCore/QPointer>
#include <QtDesigner/QDesignerWidgetBoxInterface>
#include "hbqt_garbage.h"
#include "hbqt_local.h"
/*
* QDesignerWidgetBoxInterface ( QWidget * parent = 0, Qt::WindowFlags flags = 0 )
* ~QDesignerWidgetBoxInterface ()
*
*/
typedef struct
{
QPointer< QDesignerWidgetBoxInterface > ph;
bool bNew;
QT_G_FUNC_PTR func;
} QGC_POINTER_QDesignerWidgetBoxInterface;
QT_G_FUNC( hbqt_gcRelease_QDesignerWidgetBoxInterface )
{
HB_SYMBOL_UNUSED( Cargo );
QGC_POINTER * p = ( QGC_POINTER * ) Cargo;
if( p && p->bNew )
{
p->ph = NULL;
}
}
void * hbqt_gcAllocate_QDesignerWidgetBoxInterface( void * pObj, bool bNew )
{
QGC_POINTER_QDesignerWidgetBoxInterface * p = ( QGC_POINTER_QDesignerWidgetBoxInterface * ) hb_gcAllocate( sizeof( QGC_POINTER_QDesignerWidgetBoxInterface ), hbqt_gcFuncs() );
new( & p->ph ) QPointer< QDesignerWidgetBoxInterface >( ( QDesignerWidgetBoxInterface * ) pObj );
p->bNew = bNew;
p->func = hbqt_gcRelease_QDesignerWidgetBoxInterface;
if( bNew )
{
HB_TRACE( HB_TR_DEBUG, ( "ph=%p _new_QDesignerWidgetBoxInterface under p->pq", pObj ) );
}
else
{
HB_TRACE( HB_TR_DEBUG, ( "ph=%p NOT_new_QDesignerWidgetBoxInterface", pObj ) );
}
return p;
}
HB_FUNC( QT_QDESIGNERWIDGETBOXINTERFACE )
{
//hb_retptr( new QDesignerWidgetBoxInterface() );
}
/*
* virtual QString fileName () const = 0
*/
HB_FUNC( QT_QDESIGNERWIDGETBOXINTERFACE_FILENAME )
{
QDesignerWidgetBoxInterface * p = hbqt_par_QDesignerWidgetBoxInterface( 1 );
if( p )
hb_retc( ( p )->fileName().toAscii().data() );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERWIDGETBOXINTERFACE_FILENAME FP=hb_retc( ( p )->fileName().toAscii().data() ); p is NULL" ) );
}
}
/*
* virtual bool load () = 0
*/
HB_FUNC( QT_QDESIGNERWIDGETBOXINTERFACE_LOAD )
{
QDesignerWidgetBoxInterface * p = hbqt_par_QDesignerWidgetBoxInterface( 1 );
if( p )
hb_retl( ( p )->load() );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERWIDGETBOXINTERFACE_LOAD FP=hb_retl( ( p )->load() ); p is NULL" ) );
}
}
/*
* virtual bool save () = 0
*/
HB_FUNC( QT_QDESIGNERWIDGETBOXINTERFACE_SAVE )
{
QDesignerWidgetBoxInterface * p = hbqt_par_QDesignerWidgetBoxInterface( 1 );
if( p )
hb_retl( ( p )->save() );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERWIDGETBOXINTERFACE_SAVE FP=hb_retl( ( p )->save() ); p is NULL" ) );
}
}
/*
* virtual void setFileName ( const QString & fileName ) = 0
*/
HB_FUNC( QT_QDESIGNERWIDGETBOXINTERFACE_SETFILENAME )
{
QDesignerWidgetBoxInterface * p = hbqt_par_QDesignerWidgetBoxInterface( 1 );
if( p )
( p )->setFileName( QDesignerWidgetBoxInterface::tr( hb_parc( 2 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QDESIGNERWIDGETBOXINTERFACE_SETFILENAME FP=( p )->setFileName( QDesignerWidgetBoxInterface::tr( hb_parc( 2 ) ) ); p is NULL" ) );
}
}
/*----------------------------------------------------------------------*/
#endif /* #if QT_VERSION >= 0x040500 */
/*----------------------------------------------------------------------*/

101
harbour/contrib/hbqt/qtdesigner/TQDesignerActionEditorInterface.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-2010 Pritpal Bedi <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* www - http://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 QDesignerActionEditorInterface INHERIT HbQtObjectHandler, QWidget
METHOD new( ... )
METHOD core()
METHOD manageAction( pAction )
METHOD unmanageAction( pAction )
METHOD setFormWindow( pFormWindow )
ENDCLASS
METHOD QDesignerActionEditorInterface:new( ... )
LOCAL p
FOR EACH p IN { ... }
hb_pvalue( p:__enumIndex(), hbqt_ptr( p ) )
NEXT
::pPtr := Qt_QDesignerActionEditorInterface( ... )
RETURN Self
METHOD QDesignerActionEditorInterface:core()
RETURN Qt_QDesignerActionEditorInterface_core( ::pPtr )
METHOD QDesignerActionEditorInterface:manageAction( pAction )
RETURN Qt_QDesignerActionEditorInterface_manageAction( ::pPtr, hbqt_ptr( pAction ) )
METHOD QDesignerActionEditorInterface:unmanageAction( pAction )
RETURN Qt_QDesignerActionEditorInterface_unmanageAction( ::pPtr, hbqt_ptr( pAction ) )
METHOD QDesignerActionEditorInterface:setFormWindow( pFormWindow )
RETURN Qt_QDesignerActionEditorInterface_setFormWindow( ::pPtr, hbqt_ptr( pFormWindow ) )

131
harbour/contrib/hbqt/qtdesigner/TQDesignerFormEditorInterface.prg Normal file
View File

@@ -0,0 +1,131 @@
/*
* $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-2010 Pritpal Bedi <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* www - http://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 QDesignerFormEditorInterface INHERIT HbQtObjectHandler, QObject
METHOD new( ... )
METHOD actionEditor()
METHOD formWindowManager()
METHOD objectInspector()
METHOD propertyEditor()
METHOD setActionEditor( pActionEditor )
METHOD setObjectInspector( pObjectInspector )
METHOD setPropertyEditor( pPropertyEditor )
METHOD setWidgetBox( pWidgetBox )
METHOD topLevel()
METHOD widgetBox()
ENDCLASS
METHOD QDesignerFormEditorInterface:new( ... )
LOCAL p
FOR EACH p IN { ... }
hb_pvalue( p:__enumIndex(), hbqt_ptr( p ) )
NEXT
::pPtr := Qt_QDesignerFormEditorInterface( ... )
RETURN Self
METHOD QDesignerFormEditorInterface:actionEditor()
RETURN Qt_QDesignerFormEditorInterface_actionEditor( ::pPtr )
METHOD QDesignerFormEditorInterface:formWindowManager()
RETURN Qt_QDesignerFormEditorInterface_formWindowManager( ::pPtr )
METHOD QDesignerFormEditorInterface:objectInspector()
RETURN Qt_QDesignerFormEditorInterface_objectInspector( ::pPtr )
METHOD QDesignerFormEditorInterface:propertyEditor()
RETURN Qt_QDesignerFormEditorInterface_propertyEditor( ::pPtr )
METHOD QDesignerFormEditorInterface:setActionEditor( pActionEditor )
RETURN Qt_QDesignerFormEditorInterface_setActionEditor( ::pPtr, hbqt_ptr( pActionEditor ) )
METHOD QDesignerFormEditorInterface:setObjectInspector( pObjectInspector )
RETURN Qt_QDesignerFormEditorInterface_setObjectInspector( ::pPtr, hbqt_ptr( pObjectInspector ) )
METHOD QDesignerFormEditorInterface:setPropertyEditor( pPropertyEditor )
RETURN Qt_QDesignerFormEditorInterface_setPropertyEditor( ::pPtr, hbqt_ptr( pPropertyEditor ) )
METHOD QDesignerFormEditorInterface:setWidgetBox( pWidgetBox )
RETURN Qt_QDesignerFormEditorInterface_setWidgetBox( ::pPtr, hbqt_ptr( pWidgetBox ) )
METHOD QDesignerFormEditorInterface:topLevel()
RETURN Qt_QDesignerFormEditorInterface_topLevel( ::pPtr )
METHOD QDesignerFormEditorInterface:widgetBox()
RETURN Qt_QDesignerFormEditorInterface_widgetBox( ::pPtr )

151
harbour/contrib/hbqt/qtdesigner/TQDesignerFormWindowCursorInterface.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-2010 Pritpal Bedi <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* www - http://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 QDesignerFormWindowCursorInterface INHERIT HbQtObjectHandler
METHOD new( ... )
METHOD current()
METHOD formWindow()
METHOD hasSelection()
METHOD isWidgetSelected( pWidget )
METHOD movePosition( nOperation, nMode )
METHOD position()
METHOD resetWidgetProperty( pWidget, cName )
METHOD selectedWidget( nIndex )
METHOD selectedWidgetCount()
METHOD setPosition( nPosition, nMode )
METHOD setProperty( cName, pValue )
METHOD setWidgetProperty( pWidget, cName, pValue )
METHOD widget( nIndex )
METHOD widgetCount()
ENDCLASS
METHOD QDesignerFormWindowCursorInterface:new( ... )
LOCAL p
FOR EACH p IN { ... }
hb_pvalue( p:__enumIndex(), hbqt_ptr( p ) )
NEXT
::pPtr := Qt_QDesignerFormWindowCursorInterface( ... )
RETURN Self
METHOD QDesignerFormWindowCursorInterface:current()
RETURN Qt_QDesignerFormWindowCursorInterface_current( ::pPtr )
METHOD QDesignerFormWindowCursorInterface:formWindow()
RETURN Qt_QDesignerFormWindowCursorInterface_formWindow( ::pPtr )
METHOD QDesignerFormWindowCursorInterface:hasSelection()
RETURN Qt_QDesignerFormWindowCursorInterface_hasSelection( ::pPtr )
METHOD QDesignerFormWindowCursorInterface:isWidgetSelected( pWidget )
RETURN Qt_QDesignerFormWindowCursorInterface_isWidgetSelected( ::pPtr, hbqt_ptr( pWidget ) )
METHOD QDesignerFormWindowCursorInterface:movePosition( nOperation, nMode )
RETURN Qt_QDesignerFormWindowCursorInterface_movePosition( ::pPtr, nOperation, nMode )
METHOD QDesignerFormWindowCursorInterface:position()
RETURN Qt_QDesignerFormWindowCursorInterface_position( ::pPtr )
METHOD QDesignerFormWindowCursorInterface:resetWidgetProperty( pWidget, cName )
RETURN Qt_QDesignerFormWindowCursorInterface_resetWidgetProperty( ::pPtr, hbqt_ptr( pWidget ), cName )
METHOD QDesignerFormWindowCursorInterface:selectedWidget( nIndex )
RETURN Qt_QDesignerFormWindowCursorInterface_selectedWidget( ::pPtr, nIndex )
METHOD QDesignerFormWindowCursorInterface:selectedWidgetCount()
RETURN Qt_QDesignerFormWindowCursorInterface_selectedWidgetCount( ::pPtr )
METHOD QDesignerFormWindowCursorInterface:setPosition( nPosition, nMode )
RETURN Qt_QDesignerFormWindowCursorInterface_setPosition( ::pPtr, nPosition, nMode )
METHOD QDesignerFormWindowCursorInterface:setProperty( cName, pValue )
RETURN Qt_QDesignerFormWindowCursorInterface_setProperty( ::pPtr, cName, hbqt_ptr( pValue ) )
METHOD QDesignerFormWindowCursorInterface:setWidgetProperty( pWidget, cName, pValue )
RETURN Qt_QDesignerFormWindowCursorInterface_setWidgetProperty( ::pPtr, hbqt_ptr( pWidget ), cName, hbqt_ptr( pValue ) )
METHOD QDesignerFormWindowCursorInterface:widget( nIndex )
RETURN Qt_QDesignerFormWindowCursorInterface_widget( ::pPtr, nIndex )
METHOD QDesignerFormWindowCursorInterface:widgetCount()
RETURN Qt_QDesignerFormWindowCursorInterface_widgetCount( ::pPtr )

276
harbour/contrib/hbqt/qtdesigner/TQDesignerFormWindowInterface.prg Normal file
View File

@@ -0,0 +1,276 @@
/*
* $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-2010 Pritpal Bedi <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* www - http://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 QDesignerFormWindowInterface INHERIT HbQtObjectHandler, QWidget
METHOD new( ... )
METHOD addResourceFile( cPath )
METHOD author()
METHOD comment()
METHOD contents()
METHOD core()
METHOD cursor()
METHOD emitSelectionChanged()
METHOD exportMacro()
METHOD features()
METHOD fileName()
METHOD grid()
METHOD hasFeature( nFeature )
METHOD includeHints()
METHOD isDirty()
METHOD isManaged( pWidget )
METHOD layoutDefault( nMargin, nSpacing )
METHOD mainContainer()
METHOD pixmapFunction()
METHOD removeResourceFile( cPath )
METHOD resourceFiles()
METHOD setAuthor( cAuthor )
METHOD setComment( cComment )
METHOD setContents( pDevice )
METHOD setExportMacro( cExportMacro )
METHOD setIncludeHints( pIncludeHints )
METHOD setLayoutDefault( nMargin, nSpacing )
METHOD setMainContainer( pMainContainer )
METHOD setPixmapFunction( cPixmapFunction )
METHOD findFormWindow( pWidget )
METHOD findFormWindow_1( pObject )
METHOD clearSelection( lUpdate )
METHOD manageWidget( pWidget )
METHOD selectWidget( pWidget, lSelect )
METHOD setContents_1( cContents )
METHOD setDirty( lDirty )
METHOD setFeatures( nFeatures )
METHOD setFileName( cFileName )
METHOD setGrid( pGrid )
METHOD unmanageWidget( pWidget )
ENDCLASS
METHOD QDesignerFormWindowInterface:new( ... )
LOCAL p
FOR EACH p IN { ... }
hb_pvalue( p:__enumIndex(), hbqt_ptr( p ) )
NEXT
::pPtr := Qt_QDesignerFormWindowInterface( ... )
RETURN Self
METHOD QDesignerFormWindowInterface:addResourceFile( cPath )
RETURN Qt_QDesignerFormWindowInterface_addResourceFile( ::pPtr, cPath )
METHOD QDesignerFormWindowInterface:author()
RETURN Qt_QDesignerFormWindowInterface_author( ::pPtr )
METHOD QDesignerFormWindowInterface:comment()
RETURN Qt_QDesignerFormWindowInterface_comment( ::pPtr )
METHOD QDesignerFormWindowInterface:contents()
RETURN Qt_QDesignerFormWindowInterface_contents( ::pPtr )
METHOD QDesignerFormWindowInterface:core()
RETURN Qt_QDesignerFormWindowInterface_core( ::pPtr )
METHOD QDesignerFormWindowInterface:cursor()
RETURN Qt_QDesignerFormWindowInterface_cursor( ::pPtr )
METHOD QDesignerFormWindowInterface:emitSelectionChanged()
RETURN Qt_QDesignerFormWindowInterface_emitSelectionChanged( ::pPtr )
METHOD QDesignerFormWindowInterface:exportMacro()
RETURN Qt_QDesignerFormWindowInterface_exportMacro( ::pPtr )
METHOD QDesignerFormWindowInterface:features()
RETURN Qt_QDesignerFormWindowInterface_features( ::pPtr )
METHOD QDesignerFormWindowInterface:fileName()
RETURN Qt_QDesignerFormWindowInterface_fileName( ::pPtr )
METHOD QDesignerFormWindowInterface:grid()
RETURN Qt_QDesignerFormWindowInterface_grid( ::pPtr )
METHOD QDesignerFormWindowInterface:hasFeature( nFeature )
RETURN Qt_QDesignerFormWindowInterface_hasFeature( ::pPtr, nFeature )
METHOD QDesignerFormWindowInterface:includeHints()
RETURN Qt_QDesignerFormWindowInterface_includeHints( ::pPtr )
METHOD QDesignerFormWindowInterface:isDirty()
RETURN Qt_QDesignerFormWindowInterface_isDirty( ::pPtr )
METHOD QDesignerFormWindowInterface:isManaged( pWidget )
RETURN Qt_QDesignerFormWindowInterface_isManaged( ::pPtr, hbqt_ptr( pWidget ) )
METHOD QDesignerFormWindowInterface:layoutDefault( nMargin, nSpacing )
RETURN Qt_QDesignerFormWindowInterface_layoutDefault( ::pPtr, nMargin, nSpacing )
METHOD QDesignerFormWindowInterface:mainContainer()
RETURN Qt_QDesignerFormWindowInterface_mainContainer( ::pPtr )
METHOD QDesignerFormWindowInterface:pixmapFunction()
RETURN Qt_QDesignerFormWindowInterface_pixmapFunction( ::pPtr )
METHOD QDesignerFormWindowInterface:removeResourceFile( cPath )
RETURN Qt_QDesignerFormWindowInterface_removeResourceFile( ::pPtr, cPath )
METHOD QDesignerFormWindowInterface:resourceFiles()
RETURN Qt_QDesignerFormWindowInterface_resourceFiles( ::pPtr )
METHOD QDesignerFormWindowInterface:setAuthor( cAuthor )
RETURN Qt_QDesignerFormWindowInterface_setAuthor( ::pPtr, cAuthor )
METHOD QDesignerFormWindowInterface:setComment( cComment )
RETURN Qt_QDesignerFormWindowInterface_setComment( ::pPtr, cComment )
METHOD QDesignerFormWindowInterface:setContents( pDevice )
RETURN Qt_QDesignerFormWindowInterface_setContents( ::pPtr, hbqt_ptr( pDevice ) )
METHOD QDesignerFormWindowInterface:setExportMacro( cExportMacro )
RETURN Qt_QDesignerFormWindowInterface_setExportMacro( ::pPtr, cExportMacro )
METHOD QDesignerFormWindowInterface:setIncludeHints( pIncludeHints )
RETURN Qt_QDesignerFormWindowInterface_setIncludeHints( ::pPtr, hbqt_ptr( pIncludeHints ) )
METHOD QDesignerFormWindowInterface:setLayoutDefault( nMargin, nSpacing )
RETURN Qt_QDesignerFormWindowInterface_setLayoutDefault( ::pPtr, nMargin, nSpacing )
METHOD QDesignerFormWindowInterface:setMainContainer( pMainContainer )
RETURN Qt_QDesignerFormWindowInterface_setMainContainer( ::pPtr, hbqt_ptr( pMainContainer ) )
METHOD QDesignerFormWindowInterface:setPixmapFunction( cPixmapFunction )
RETURN Qt_QDesignerFormWindowInterface_setPixmapFunction( ::pPtr, cPixmapFunction )
METHOD QDesignerFormWindowInterface:findFormWindow( pWidget )
RETURN Qt_QDesignerFormWindowInterface_findFormWindow( ::pPtr, hbqt_ptr( pWidget ) )
METHOD QDesignerFormWindowInterface:findFormWindow_1( pObject )
RETURN Qt_QDesignerFormWindowInterface_findFormWindow_1( ::pPtr, hbqt_ptr( pObject ) )
METHOD QDesignerFormWindowInterface:clearSelection( lUpdate )
RETURN Qt_QDesignerFormWindowInterface_clearSelection( ::pPtr, lUpdate )
METHOD QDesignerFormWindowInterface:manageWidget( pWidget )
RETURN Qt_QDesignerFormWindowInterface_manageWidget( ::pPtr, hbqt_ptr( pWidget ) )
METHOD QDesignerFormWindowInterface:selectWidget( pWidget, lSelect )
RETURN Qt_QDesignerFormWindowInterface_selectWidget( ::pPtr, hbqt_ptr( pWidget ), lSelect )
METHOD QDesignerFormWindowInterface:setContents_1( cContents )
RETURN Qt_QDesignerFormWindowInterface_setContents_1( ::pPtr, cContents )
METHOD QDesignerFormWindowInterface:setDirty( lDirty )
RETURN Qt_QDesignerFormWindowInterface_setDirty( ::pPtr, lDirty )
METHOD QDesignerFormWindowInterface:setFeatures( nFeatures )
RETURN Qt_QDesignerFormWindowInterface_setFeatures( ::pPtr, nFeatures )
METHOD QDesignerFormWindowInterface:setFileName( cFileName )
RETURN Qt_QDesignerFormWindowInterface_setFileName( ::pPtr, cFileName )
METHOD QDesignerFormWindowInterface:setGrid( pGrid )
RETURN Qt_QDesignerFormWindowInterface_setGrid( ::pPtr, hbqt_ptr( pGrid ) )
METHOD QDesignerFormWindowInterface:unmanageWidget( pWidget )
RETURN Qt_QDesignerFormWindowInterface_unmanageWidget( ::pPtr, hbqt_ptr( pWidget ) )

211
harbour/contrib/hbqt/qtdesigner/TQDesignerFormWindowManagerInterface.prg Normal file
View File

@@ -0,0 +1,211 @@
/*
* $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-2010 Pritpal Bedi <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* www - http://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 QDesignerFormWindowManagerInterface INHERIT HbQtObjectHandler, QObject
METHOD new( ... )
METHOD actionAdjustSize()
METHOD actionBreakLayout()
METHOD actionCopy()
METHOD actionCut()
METHOD actionDelete()
METHOD actionFormLayout()
METHOD actionGridLayout()
METHOD actionHorizontalLayout()
METHOD actionLower()
METHOD actionPaste()
METHOD actionRaise()
METHOD actionRedo()
METHOD actionSelectAll()
METHOD actionSimplifyLayout()
METHOD actionSplitHorizontal()
METHOD actionSplitVertical()
METHOD actionUndo()
METHOD actionVerticalLayout()
METHOD activeFormWindow()
METHOD core()
METHOD createFormWindow( pParent, nFlags )
METHOD formWindow( nIndex )
METHOD formWindowCount()
METHOD addFormWindow( pFormWindow )
METHOD removeFormWindow( pFormWindow )
METHOD setActiveFormWindow( pFormWindow )
ENDCLASS
METHOD QDesignerFormWindowManagerInterface:new( ... )
LOCAL p
FOR EACH p IN { ... }
hb_pvalue( p:__enumIndex(), hbqt_ptr( p ) )
NEXT
::pPtr := Qt_QDesignerFormWindowManagerInterface( ... )
RETURN Self
METHOD QDesignerFormWindowManagerInterface:actionAdjustSize()
RETURN Qt_QDesignerFormWindowManagerInterface_actionAdjustSize( ::pPtr )
METHOD QDesignerFormWindowManagerInterface:actionBreakLayout()
RETURN Qt_QDesignerFormWindowManagerInterface_actionBreakLayout( ::pPtr )
METHOD QDesignerFormWindowManagerInterface:actionCopy()
RETURN Qt_QDesignerFormWindowManagerInterface_actionCopy( ::pPtr )
METHOD QDesignerFormWindowManagerInterface:actionCut()
RETURN Qt_QDesignerFormWindowManagerInterface_actionCut( ::pPtr )
METHOD QDesignerFormWindowManagerInterface:actionDelete()
RETURN Qt_QDesignerFormWindowManagerInterface_actionDelete( ::pPtr )
METHOD QDesignerFormWindowManagerInterface:actionFormLayout()
RETURN Qt_QDesignerFormWindowManagerInterface_actionFormLayout( ::pPtr )
METHOD QDesignerFormWindowManagerInterface:actionGridLayout()
RETURN Qt_QDesignerFormWindowManagerInterface_actionGridLayout( ::pPtr )
METHOD QDesignerFormWindowManagerInterface:actionHorizontalLayout()
RETURN Qt_QDesignerFormWindowManagerInterface_actionHorizontalLayout( ::pPtr )
METHOD QDesignerFormWindowManagerInterface:actionLower()
RETURN Qt_QDesignerFormWindowManagerInterface_actionLower( ::pPtr )
METHOD QDesignerFormWindowManagerInterface:actionPaste()
RETURN Qt_QDesignerFormWindowManagerInterface_actionPaste( ::pPtr )
METHOD QDesignerFormWindowManagerInterface:actionRaise()
RETURN Qt_QDesignerFormWindowManagerInterface_actionRaise( ::pPtr )
METHOD QDesignerFormWindowManagerInterface:actionRedo()
RETURN Qt_QDesignerFormWindowManagerInterface_actionRedo( ::pPtr )
METHOD QDesignerFormWindowManagerInterface:actionSelectAll()
RETURN Qt_QDesignerFormWindowManagerInterface_actionSelectAll( ::pPtr )
METHOD QDesignerFormWindowManagerInterface:actionSimplifyLayout()
RETURN Qt_QDesignerFormWindowManagerInterface_actionSimplifyLayout( ::pPtr )
METHOD QDesignerFormWindowManagerInterface:actionSplitHorizontal()
RETURN Qt_QDesignerFormWindowManagerInterface_actionSplitHorizontal( ::pPtr )
METHOD QDesignerFormWindowManagerInterface:actionSplitVertical()
RETURN Qt_QDesignerFormWindowManagerInterface_actionSplitVertical( ::pPtr )
METHOD QDesignerFormWindowManagerInterface:actionUndo()
RETURN Qt_QDesignerFormWindowManagerInterface_actionUndo( ::pPtr )
METHOD QDesignerFormWindowManagerInterface:actionVerticalLayout()
RETURN Qt_QDesignerFormWindowManagerInterface_actionVerticalLayout( ::pPtr )
METHOD QDesignerFormWindowManagerInterface:activeFormWindow()
RETURN Qt_QDesignerFormWindowManagerInterface_activeFormWindow( ::pPtr )
METHOD QDesignerFormWindowManagerInterface:core()
RETURN Qt_QDesignerFormWindowManagerInterface_core( ::pPtr )
METHOD QDesignerFormWindowManagerInterface:createFormWindow( pParent, nFlags )
RETURN Qt_QDesignerFormWindowManagerInterface_createFormWindow( ::pPtr, hbqt_ptr( pParent ), nFlags )
METHOD QDesignerFormWindowManagerInterface:formWindow( nIndex )
RETURN Qt_QDesignerFormWindowManagerInterface_formWindow( ::pPtr, nIndex )
METHOD QDesignerFormWindowManagerInterface:formWindowCount()
RETURN Qt_QDesignerFormWindowManagerInterface_formWindowCount( ::pPtr )
METHOD QDesignerFormWindowManagerInterface:addFormWindow( pFormWindow )
RETURN Qt_QDesignerFormWindowManagerInterface_addFormWindow( ::pPtr, hbqt_ptr( pFormWindow ) )
METHOD QDesignerFormWindowManagerInterface:removeFormWindow( pFormWindow )
RETURN Qt_QDesignerFormWindowManagerInterface_removeFormWindow( ::pPtr, hbqt_ptr( pFormWindow ) )
METHOD QDesignerFormWindowManagerInterface:setActiveFormWindow( pFormWindow )
RETURN Qt_QDesignerFormWindowManagerInterface_setActiveFormWindow( ::pPtr, hbqt_ptr( pFormWindow ) )

91
harbour/contrib/hbqt/qtdesigner/TQDesignerObjectInspectorInterface.prg Normal file
View File

@@ -0,0 +1,91 @@
/*
* $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-2010 Pritpal Bedi <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* www - http://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 QDesignerObjectInspectorInterface INHERIT HbQtObjectHandler, QWidget
METHOD new( ... )
METHOD core()
METHOD setFormWindow( pFormWindow )
ENDCLASS
METHOD QDesignerObjectInspectorInterface:new( ... )
LOCAL p
FOR EACH p IN { ... }
hb_pvalue( p:__enumIndex(), hbqt_ptr( p ) )
NEXT
::pPtr := Qt_QDesignerObjectInspectorInterface( ... )
RETURN Self
METHOD QDesignerObjectInspectorInterface:core()
RETURN Qt_QDesignerObjectInspectorInterface_core( ::pPtr )
METHOD QDesignerObjectInspectorInterface:setFormWindow( pFormWindow )
RETURN Qt_QDesignerObjectInspectorInterface_setFormWindow( ::pPtr, hbqt_ptr( pFormWindow ) )

116
harbour/contrib/hbqt/qtdesigner/TQDesignerPropertyEditorInterface.prg 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-2010 Pritpal Bedi <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* www - http://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 QDesignerPropertyEditorInterface INHERIT HbQtObjectHandler, QWidget
METHOD new( ... )
METHOD core()
METHOD currentPropertyName()
METHOD isReadOnly()
METHOD object()
METHOD setObject( pObject )
METHOD setPropertyValue( cName, pValue, lChanged )
METHOD setReadOnly( lReadOnly )
ENDCLASS
METHOD QDesignerPropertyEditorInterface:new( ... )
LOCAL p
FOR EACH p IN { ... }
hb_pvalue( p:__enumIndex(), hbqt_ptr( p ) )
NEXT
::pPtr := Qt_QDesignerPropertyEditorInterface( ... )
RETURN Self
METHOD QDesignerPropertyEditorInterface:core()
RETURN Qt_QDesignerPropertyEditorInterface_core( ::pPtr )
METHOD QDesignerPropertyEditorInterface:currentPropertyName()
RETURN Qt_QDesignerPropertyEditorInterface_currentPropertyName( ::pPtr )
METHOD QDesignerPropertyEditorInterface:isReadOnly()
RETURN Qt_QDesignerPropertyEditorInterface_isReadOnly( ::pPtr )
METHOD QDesignerPropertyEditorInterface:object()
RETURN Qt_QDesignerPropertyEditorInterface_object( ::pPtr )
METHOD QDesignerPropertyEditorInterface:setObject( pObject )
RETURN Qt_QDesignerPropertyEditorInterface_setObject( ::pPtr, hbqt_ptr( pObject ) )
METHOD QDesignerPropertyEditorInterface:setPropertyValue( cName, pValue, lChanged )
RETURN Qt_QDesignerPropertyEditorInterface_setPropertyValue( ::pPtr, cName, hbqt_ptr( pValue ), lChanged )
METHOD QDesignerPropertyEditorInterface:setReadOnly( lReadOnly )
RETURN Qt_QDesignerPropertyEditorInterface_setReadOnly( ::pPtr, lReadOnly )

101
harbour/contrib/hbqt/qtdesigner/TQDesignerWidgetBoxInterface.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-2010 Pritpal Bedi <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* www - http://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 QDesignerWidgetBoxInterface INHERIT HbQtObjectHandler, QWidget
METHOD new( ... )
METHOD fileName()
METHOD load()
METHOD save()
METHOD setFileName( cFileName )
ENDCLASS
METHOD QDesignerWidgetBoxInterface:new( ... )
LOCAL p
FOR EACH p IN { ... }
hb_pvalue( p:__enumIndex(), hbqt_ptr( p ) )
NEXT
::pPtr := Qt_QDesignerWidgetBoxInterface( ... )
RETURN Self
METHOD QDesignerWidgetBoxInterface:fileName()
RETURN Qt_QDesignerWidgetBoxInterface_fileName( ::pPtr )
METHOD QDesignerWidgetBoxInterface:load()
RETURN Qt_QDesignerWidgetBoxInterface_load( ::pPtr )
METHOD QDesignerWidgetBoxInterface:save()
RETURN Qt_QDesignerWidgetBoxInterface_save( ::pPtr )
METHOD QDesignerWidgetBoxInterface:setFileName( cFileName )
RETURN Qt_QDesignerWidgetBoxInterface_setFileName( ::pPtr, cFileName )

57
harbour/contrib/hbqt/qtdesigner/doc/en/class_qdesigneractioneditorinterface.txt Normal file
View File

@@ -0,0 +1,57 @@
/*
* hbQTgen v1.0 - Harbour Callable Wrappers Generator for Qt v4.5.3+
* Please do not modify this document as it is subject to change in future.
* Pritpal Bedi <bedipritpal@hotmail.com>
*/
/* $DOC$
$TEMPLATE$
Class
$NAME$
QDesignerActionEditorInterface()
$CATEGORY$
Harbour Bindings for Qt
$SUBCATEGORY$
GUI
$EXTERNALLINK$
http://doc.trolltech.com/4.5/qdesigneractioneditorinterface.html
$ONELINER$
Creates a new QDesignerActionEditorInterface object.
$INHERITS$
QWidget
$SYNTAX$
QDesignerActionEditorInterface():new( ... )
QDesignerActionEditorInterface():from( pPtr_OR_oObj_of_type_QDesignerActionEditorInterface )
QDesignerActionEditorInterface():configure( pPtr_OR_oObj_of_type_QDesignerActionEditorInterface )
$ARGUMENTS$
$RETURNS$
An instance of the object of type QDesignerActionEditorInterface
$METHODS$
:core() -> pQDesignerFormEditorInterface
:manageAction( pAction ) -> NIL
:unmanageAction( pAction ) -> NIL
:setFormWindow( pFormWindow ) -> NIL
$DESCRIPTION$
$EXAMPLES$
$TESTS$
$STATUS$
R
$COMPLIANCE$
Not Clipper Compatible
$PLATFORMS$
Windows, Linux, MacOS, OS2
$VERSION$
4.5.3
$FILES$
Prg Source : contrib/hbqt/TQDesignerActionEditorInterface.prg
C++ Wrappers : contrib/hbqt/QDesignerActionEditorInterface.cpp
Library : hb
$SEEALSO$
QWidget
$END$
*/

63
harbour/contrib/hbqt/qtdesigner/doc/en/class_qdesignerformeditorinterface.txt Normal file
View File

@@ -0,0 +1,63 @@
/*
* hbQTgen v1.0 - Harbour Callable Wrappers Generator for Qt v4.5.3+
* Please do not modify this document as it is subject to change in future.
* Pritpal Bedi <bedipritpal@hotmail.com>
*/
/* $DOC$
$TEMPLATE$
Class
$NAME$
QDesignerFormEditorInterface()
$CATEGORY$
Harbour Bindings for Qt
$SUBCATEGORY$
GUI
$EXTERNALLINK$
http://doc.trolltech.com/4.5/qdesignerformeditorinterface.html
$ONELINER$
Creates a new QDesignerFormEditorInterface object.
$INHERITS$
QObject
$SYNTAX$
QDesignerFormEditorInterface():new( ... )
QDesignerFormEditorInterface():from( pPtr_OR_oObj_of_type_QDesignerFormEditorInterface )
QDesignerFormEditorInterface():configure( pPtr_OR_oObj_of_type_QDesignerFormEditorInterface )
$ARGUMENTS$
$RETURNS$
An instance of the object of type QDesignerFormEditorInterface
$METHODS$
:actionEditor() -> pQDesignerActionEditorInterface
:formWindowManager() -> pQDesignerFormWindowManagerInterface
:objectInspector() -> pQDesignerObjectInspectorInterface
:propertyEditor() -> pQDesignerPropertyEditorInterface
:setActionEditor( pActionEditor ) -> NIL
:setObjectInspector( pObjectInspector ) -> NIL
:setPropertyEditor( pPropertyEditor ) -> NIL
:setWidgetBox( pWidgetBox ) -> NIL
:topLevel() -> pQWidget
:widgetBox() -> pQDesignerWidgetBoxInterface
$DESCRIPTION$
$EXAMPLES$
$TESTS$
$STATUS$
R
$COMPLIANCE$
Not Clipper Compatible
$PLATFORMS$
Windows, Linux, MacOS, OS2
$VERSION$
4.5.3
$FILES$
Prg Source : contrib/hbqt/TQDesignerFormEditorInterface.prg
C++ Wrappers : contrib/hbqt/QDesignerFormEditorInterface.cpp
Library : hb
$SEEALSO$
QObject
$END$
*/

67
harbour/contrib/hbqt/qtdesigner/doc/en/class_qdesignerformwindowcursorinterface.txt Normal file
View File

@@ -0,0 +1,67 @@
/*
* hbQTgen v1.0 - Harbour Callable Wrappers Generator for Qt v4.5.3+
* Please do not modify this document as it is subject to change in future.
* Pritpal Bedi <bedipritpal@hotmail.com>
*/
/* $DOC$
$TEMPLATE$
Class
$NAME$
QDesignerFormWindowCursorInterface()
$CATEGORY$
Harbour Bindings for Qt
$SUBCATEGORY$
GUI
$EXTERNALLINK$
http://doc.trolltech.com/4.5/qdesignerformwindowcursorinterface.html
$ONELINER$
Creates a new QDesignerFormWindowCursorInterface object.
$INHERITS$
$SYNTAX$
QDesignerFormWindowCursorInterface():new( ... )
QDesignerFormWindowCursorInterface():from( pPtr_OR_oObj_of_type_QDesignerFormWindowCursorInterface )
QDesignerFormWindowCursorInterface():configure( pPtr_OR_oObj_of_type_QDesignerFormWindowCursorInterface )
$ARGUMENTS$
$RETURNS$
An instance of the object of type QDesignerFormWindowCursorInterface
$METHODS$
:current() -> pQWidget
:formWindow() -> pQDesignerFormWindowInterface
:hasSelection() -> lBool
:isWidgetSelected( pWidget ) -> lBool
:movePosition( nOperation, nMode ) -> lBool
:position() -> nInt
:resetWidgetProperty( pWidget, cName ) -> NIL
:selectedWidget( nIndex ) -> pQWidget
:selectedWidgetCount() -> nInt
:setPosition( nPosition, nMode ) -> NIL
:setProperty( cName, pValue ) -> NIL
:setWidgetProperty( pWidget, cName, pValue ) -> NIL
:widget( nIndex ) -> pQWidget
:widgetCount() -> nInt
$DESCRIPTION$
$EXAMPLES$
$TESTS$
$STATUS$
R
$COMPLIANCE$
Not Clipper Compatible
$PLATFORMS$
Windows, Linux, MacOS, OS2
$VERSION$
4.5.3
$FILES$
Prg Source : contrib/hbqt/TQDesignerFormWindowCursorInterface.prg
C++ Wrappers : contrib/hbqt/QDesignerFormWindowCursorInterface.cpp
Library : hb
$SEEALSO$
$END$
*/

90
harbour/contrib/hbqt/qtdesigner/doc/en/class_qdesignerformwindowinterface.txt Normal file
View File

@@ -0,0 +1,90 @@
/*
* hbQTgen v1.0 - Harbour Callable Wrappers Generator for Qt v4.5.3+
* Please do not modify this document as it is subject to change in future.
* Pritpal Bedi <bedipritpal@hotmail.com>
*/
/* $DOC$
$TEMPLATE$
Class
$NAME$
QDesignerFormWindowInterface()
$CATEGORY$
Harbour Bindings for Qt
$SUBCATEGORY$
GUI
$EXTERNALLINK$
http://doc.trolltech.com/4.5/qdesignerformwindowinterface.html
$ONELINER$
Creates a new QDesignerFormWindowInterface object.
$INHERITS$
QWidget
$SYNTAX$
QDesignerFormWindowInterface():new( ... )
QDesignerFormWindowInterface():from( pPtr_OR_oObj_of_type_QDesignerFormWindowInterface )
QDesignerFormWindowInterface():configure( pPtr_OR_oObj_of_type_QDesignerFormWindowInterface )
$ARGUMENTS$
$RETURNS$
An instance of the object of type QDesignerFormWindowInterface
$METHODS$
:addResourceFile( cPath ) -> NIL
:author() -> cQString
:comment() -> cQString
:contents() -> cQString
:core() -> pQDesignerFormEditorInterface
:cursor() -> pQDesignerFormWindowCursorInterface
:emitSelectionChanged() -> NIL
:exportMacro() -> cQString
:features() -> nFeature
:fileName() -> cQString
:grid() -> pQPoint
:hasFeature( nFeature ) -> lBool
:includeHints() -> pQStringList
:isDirty() -> lBool
:isManaged( pWidget ) -> lBool
:layoutDefault( @nMargin, @nSpacing ) -> NIL
:mainContainer() -> pQWidget
:pixmapFunction() -> cQString
:removeResourceFile( cPath ) -> NIL
:resourceFiles() -> pQStringList
:setAuthor( cAuthor ) -> NIL
:setComment( cComment ) -> NIL
:setContents( pDevice ) -> NIL
:setExportMacro( cExportMacro ) -> NIL
:setIncludeHints( pIncludeHints ) -> NIL
:setLayoutDefault( nMargin, nSpacing ) -> NIL
:setMainContainer( pMainContainer ) -> NIL
:setPixmapFunction( cPixmapFunction ) -> NIL
:clearSelection( lUpdate ) -> NIL
:manageWidget( pWidget ) -> NIL
:selectWidget( pWidget, lSelect ) -> NIL
:setContents_1( cContents ) -> NIL
:setDirty( lDirty ) -> NIL
:setFeatures( nFeatures ) -> NIL
:setFileName( cFileName ) -> NIL
:setGrid( pGrid ) -> NIL
:unmanageWidget( pWidget ) -> NIL
$DESCRIPTION$
$EXAMPLES$
$TESTS$
$STATUS$
R
$COMPLIANCE$
Not Clipper Compatible
$PLATFORMS$
Windows, Linux, MacOS, OS2
$VERSION$
4.5.3
$FILES$
Prg Source : contrib/hbqt/TQDesignerFormWindowInterface.prg
C++ Wrappers : contrib/hbqt/QDesignerFormWindowInterface.cpp
Library : hb
$SEEALSO$
QWidget
$END$
*/

79
harbour/contrib/hbqt/qtdesigner/doc/en/class_qdesignerformwindowmanagerinterface.txt Normal file
View File

@@ -0,0 +1,79 @@
/*
* hbQTgen v1.0 - Harbour Callable Wrappers Generator for Qt v4.5.3+
* Please do not modify this document as it is subject to change in future.
* Pritpal Bedi <bedipritpal@hotmail.com>
*/
/* $DOC$
$TEMPLATE$
Class
$NAME$
QDesignerFormWindowManagerInterface()
$CATEGORY$
Harbour Bindings for Qt
$SUBCATEGORY$
GUI
$EXTERNALLINK$
http://doc.trolltech.com/4.5/qdesignerformwindowmanagerinterface.html
$ONELINER$
Creates a new QDesignerFormWindowManagerInterface object.
$INHERITS$
QObject
$SYNTAX$
QDesignerFormWindowManagerInterface():new( ... )
QDesignerFormWindowManagerInterface():from( pPtr_OR_oObj_of_type_QDesignerFormWindowManagerInterface )
QDesignerFormWindowManagerInterface():configure( pPtr_OR_oObj_of_type_QDesignerFormWindowManagerInterface )
$ARGUMENTS$
$RETURNS$
An instance of the object of type QDesignerFormWindowManagerInterface
$METHODS$
:actionAdjustSize() -> pQAction
:actionBreakLayout() -> pQAction
:actionCopy() -> pQAction
:actionCut() -> pQAction
:actionDelete() -> pQAction
:actionFormLayout() -> pQAction
:actionGridLayout() -> pQAction
:actionHorizontalLayout() -> pQAction
:actionLower() -> pQAction
:actionPaste() -> pQAction
:actionRaise() -> pQAction
:actionRedo() -> pQAction
:actionSelectAll() -> pQAction
:actionSimplifyLayout() -> pQAction
:actionSplitHorizontal() -> pQAction
:actionSplitVertical() -> pQAction
:actionUndo() -> pQAction
:actionVerticalLayout() -> pQAction
:activeFormWindow() -> pQDesignerFormWindowInterface
:core() -> pQDesignerFormEditorInterface
:createFormWindow( pParent, nFlags ) -> pQDesignerFormWindowInterface
:formWindow( nIndex ) -> pQDesignerFormWindowInterface
:formWindowCount() -> nInt
:addFormWindow( pFormWindow ) -> NIL
:removeFormWindow( pFormWindow ) -> NIL
:setActiveFormWindow( pFormWindow ) -> NIL
$DESCRIPTION$
$EXAMPLES$
$TESTS$
$STATUS$
R
$COMPLIANCE$
Not Clipper Compatible
$PLATFORMS$
Windows, Linux, MacOS, OS2
$VERSION$
4.5.3
$FILES$
Prg Source : contrib/hbqt/TQDesignerFormWindowManagerInterface.prg
C++ Wrappers : contrib/hbqt/QDesignerFormWindowManagerInterface.cpp
Library : hb
$SEEALSO$
QObject
$END$
*/

55
harbour/contrib/hbqt/qtdesigner/doc/en/class_qdesignerobjectinspectorinterface.txt Normal file
View File

@@ -0,0 +1,55 @@
/*
* hbQTgen v1.0 - Harbour Callable Wrappers Generator for Qt v4.5.3+
* Please do not modify this document as it is subject to change in future.
* Pritpal Bedi <bedipritpal@hotmail.com>
*/
/* $DOC$
$TEMPLATE$
Class
$NAME$
QDesignerObjectInspectorInterface()
$CATEGORY$
Harbour Bindings for Qt
$SUBCATEGORY$
GUI
$EXTERNALLINK$
http://doc.trolltech.com/4.5/qdesignerobjectinspectorinterface.html
$ONELINER$
Creates a new QDesignerObjectInspectorInterface object.
$INHERITS$
QWidget
$SYNTAX$
QDesignerObjectInspectorInterface():new( ... )
QDesignerObjectInspectorInterface():from( pPtr_OR_oObj_of_type_QDesignerObjectInspectorInterface )
QDesignerObjectInspectorInterface():configure( pPtr_OR_oObj_of_type_QDesignerObjectInspectorInterface )
$ARGUMENTS$
$RETURNS$
An instance of the object of type QDesignerObjectInspectorInterface
$METHODS$
:core() -> pQDesignerFormEditorInterface
:setFormWindow( pFormWindow ) -> NIL
$DESCRIPTION$
$EXAMPLES$
$TESTS$
$STATUS$
R
$COMPLIANCE$
Not Clipper Compatible
$PLATFORMS$
Windows, Linux, MacOS, OS2
$VERSION$
4.5.3
$FILES$
Prg Source : contrib/hbqt/TQDesignerObjectInspectorInterface.prg
C++ Wrappers : contrib/hbqt/QDesignerObjectInspectorInterface.cpp
Library : hb
$SEEALSO$
QWidget
$END$
*/

60
harbour/contrib/hbqt/qtdesigner/doc/en/class_qdesignerpropertyeditorinterface.txt Normal file
View File

@@ -0,0 +1,60 @@
/*
* hbQTgen v1.0 - Harbour Callable Wrappers Generator for Qt v4.5.3+
* Please do not modify this document as it is subject to change in future.
* Pritpal Bedi <bedipritpal@hotmail.com>
*/
/* $DOC$
$TEMPLATE$
Class
$NAME$
QDesignerPropertyEditorInterface()
$CATEGORY$
Harbour Bindings for Qt
$SUBCATEGORY$
GUI
$EXTERNALLINK$
http://doc.trolltech.com/4.5/qdesignerpropertyeditorinterface.html
$ONELINER$
Creates a new QDesignerPropertyEditorInterface object.
$INHERITS$
QWidget
$SYNTAX$
QDesignerPropertyEditorInterface():new( ... )
QDesignerPropertyEditorInterface():from( pPtr_OR_oObj_of_type_QDesignerPropertyEditorInterface )
QDesignerPropertyEditorInterface():configure( pPtr_OR_oObj_of_type_QDesignerPropertyEditorInterface )
$ARGUMENTS$
$RETURNS$
An instance of the object of type QDesignerPropertyEditorInterface
$METHODS$
:core() -> pQDesignerFormEditorInterface
:currentPropertyName() -> cQString
:isReadOnly() -> lBool
:object() -> pQObject
:setObject( pObject ) -> NIL
:setPropertyValue( cName, pValue, lChanged ) -> NIL
:setReadOnly( lReadOnly ) -> NIL
$DESCRIPTION$
$EXAMPLES$
$TESTS$
$STATUS$
R
$COMPLIANCE$
Not Clipper Compatible
$PLATFORMS$
Windows, Linux, MacOS, OS2
$VERSION$
4.5.3
$FILES$
Prg Source : contrib/hbqt/TQDesignerPropertyEditorInterface.prg
C++ Wrappers : contrib/hbqt/QDesignerPropertyEditorInterface.cpp
Library : hb
$SEEALSO$
QWidget
$END$
*/

57
harbour/contrib/hbqt/qtdesigner/doc/en/class_qdesignerwidgetboxinterface.txt Normal file
View File

@@ -0,0 +1,57 @@
/*
* hbQTgen v1.0 - Harbour Callable Wrappers Generator for Qt v4.5.3+
* Please do not modify this document as it is subject to change in future.
* Pritpal Bedi <bedipritpal@hotmail.com>
*/
/* $DOC$
$TEMPLATE$
Class
$NAME$
QDesignerWidgetBoxInterface()
$CATEGORY$
Harbour Bindings for Qt
$SUBCATEGORY$
GUI
$EXTERNALLINK$
http://doc.trolltech.com/4.5/qdesignerwidgetboxinterface.html
$ONELINER$
Creates a new QDesignerWidgetBoxInterface object.
$INHERITS$
QWidget
$SYNTAX$
QDesignerWidgetBoxInterface():new( ... )
QDesignerWidgetBoxInterface():from( pPtr_OR_oObj_of_type_QDesignerWidgetBoxInterface )
QDesignerWidgetBoxInterface():configure( pPtr_OR_oObj_of_type_QDesignerWidgetBoxInterface )
$ARGUMENTS$
$RETURNS$
An instance of the object of type QDesignerWidgetBoxInterface
$METHODS$
:fileName() -> cQString
:load() -> lBool
:save() -> lBool
:setFileName( cFileName ) -> NIL
$DESCRIPTION$
$EXAMPLES$
$TESTS$
$STATUS$
R
$COMPLIANCE$
Not Clipper Compatible
$PLATFORMS$
Windows, Linux, MacOS, OS2
$VERSION$
4.5.3
$FILES$
Prg Source : contrib/hbqt/TQDesignerWidgetBoxInterface.prg
C++ Wrappers : contrib/hbqt/QDesignerWidgetBoxInterface.cpp
Library : hb
$SEEALSO$
QWidget
$END$
*/

28
harbour/contrib/hbqt/qtdesigner/hbqt_garbage.h Normal file
View File

@@ -0,0 +1,28 @@
/*
* $Id$
*/
/* -------------------------------------------------------------------- */
/* WARNING: Automatically generated source file. DO NOT EDIT! */
/* Instead, edit corresponding .qth file, */
/* or the generator tool itself, and run regenarate. */
/* -------------------------------------------------------------------- */
extern QT_G_FUNC( hbqt_gcRelease_QDesignerActionEditorInterface );
extern QT_G_FUNC( hbqt_gcRelease_QDesignerFormEditorInterface );
extern QT_G_FUNC( hbqt_gcRelease_QDesignerFormWindowCursorInterface );
extern QT_G_FUNC( hbqt_gcRelease_QDesignerFormWindowInterface );
extern QT_G_FUNC( hbqt_gcRelease_QDesignerFormWindowManagerInterface );
extern QT_G_FUNC( hbqt_gcRelease_QDesignerObjectInspectorInterface );
extern QT_G_FUNC( hbqt_gcRelease_QDesignerPropertyEditorInterface );
extern QT_G_FUNC( hbqt_gcRelease_QDesignerWidgetBoxInterface );
extern void * hbqt_gcAllocate_QDesignerActionEditorInterface( void * pObj, bool bNew );
extern void * hbqt_gcAllocate_QDesignerFormEditorInterface( void * pObj, bool bNew );
extern void * hbqt_gcAllocate_QDesignerFormWindowCursorInterface( void * pObj, bool bNew );
extern void * hbqt_gcAllocate_QDesignerFormWindowInterface( void * pObj, bool bNew );
extern void * hbqt_gcAllocate_QDesignerFormWindowManagerInterface( void * pObj, bool bNew );
extern void * hbqt_gcAllocate_QDesignerObjectInspectorInterface( void * pObj, bool bNew );
extern void * hbqt_gcAllocate_QDesignerPropertyEditorInterface( void * pObj, bool bNew );
extern void * hbqt_gcAllocate_QDesignerWidgetBoxInterface( void * pObj, bool bNew );

66
harbour/contrib/hbqt/qtdesigner/hbqt_local.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* $Id$
*/
/*
* Harbour Project source code:
* QT wrapper main header
*
* Copyright 2010 Pritpal Bedi <pritpal@vouchcac.com>
*
* 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.
*
*/
/*----------------------------------------------------------------------*/
#ifndef __HBQT_LOCAL_H
#define __HBQT_LOCAL_H
#define hbqt_par_QDesignerActionEditorInterface( n ) ( ( QDesignerActionEditorInterface * ) hbqt_gcpointer( n ) )
#define hbqt_par_QDesignerFormEditorInterface( n ) ( ( QDesignerFormEditorInterface * ) hbqt_gcpointer( n ) )
#define hbqt_par_QDesignerFormWindowCursorInterface( n ) ( ( QDesignerFormWindowCursorInterface * ) hbqt_gcpointer( n ) )
#define hbqt_par_QDesignerFormWindowInterface( n ) ( ( QDesignerFormWindowInterface * ) hbqt_gcpointer( n ) )
#define hbqt_par_QDesignerFormWindowManagerInterface( n ) ( ( QDesignerFormWindowManagerInterface * ) hbqt_gcpointer( n ) )
#define hbqt_par_QDesignerObjectInspectorInterface( n ) ( ( QDesignerObjectInspectorInterface * ) hbqt_gcpointer( n ) )
#define hbqt_par_QDesignerPropertyEditorInterface( n ) ( ( QDesignerPropertyEditorInterface * ) hbqt_gcpointer( n ) )
#define hbqt_par_QDesignerWidgetBoxInterface( n ) ( ( QDesignerWidgetBoxInterface * ) hbqt_gcpointer( n ) )
#endif /* __HBQT_LOCAL_H */

46
harbour/contrib/hbqt/qtdesigner/hbqtdesigner.hbp Normal file
View File

@@ -0,0 +1,46 @@
-3rd=hbide_version=1.0
-3rd=hbide_type=Lib
-3rd=hbide_title=qtdesigner
-3rd=hbide_location=C:/harbour/contrib/hbqt/qtdesigner/
-3rd=hbide_workingfolder=
-3rd=hbide_destinationfolder=
-3rd=hbide_output=qscintilla
-3rd=hbide_launchparams=
-3rd=hbide_launchprogram=
-3rd=hbide_backupfolder=
-3rd=hbide_xhb=NO
-3rd=hbide_xpp=NO
-3rd=hbide_clp=NO
-info
-trace
-inc
-w2
-es2
-hblib
-incpath=../
-incpath=${HB_WITH_QT}
-incpath=${HB_WITH_QT}/QtDesigner
-ohbqtdesigner
-plugin=../../../utils/hbmk2/examples/plug_moc.prg
QDesignerActionEditorInterface.cpp
QDesignerFormEditorInterface.cpp
QDesignerFormWindowCursorInterface.cpp
QDesignerFormWindowInterface.cpp
QDesignerFormWindowManagerInterface.cpp
QDesignerObjectInspectorInterface.cpp
QDesignerPropertyEditorInterface.cpp
QDesignerWidgetBoxInterface.cpp
TQDesignerActionEditorInterface.prg
TQDesignerFormEditorInterface.prg
TQDesignerFormWindowCursorInterface.prg
TQDesignerFormWindowInterface.prg
TQDesignerFormWindowManagerInterface.prg
TQDesignerObjectInspectorInterface.prg
TQDesignerPropertyEditorInterface.prg
TQDesignerWidgetBoxInterface.prg

24
harbour/contrib/hbqt/qtdesigner/hbqtdesigner.qtp Normal file
View File

@@ -0,0 +1,24 @@
;
; $Id$
;
;
; Harbour Source Wrapper Generator's Project File for QT v4.5
;
; Pritpal Bedi <bedipritpal@hotmail.com>
;
-I=qth
-O=
-D=doc
QDesignerActionEditorInterface.qth
QDesignerFormEditorInterface.qth
QDesignerFormWindowCursorInterface.qth
QDesignerFormWindowInterface.qth
QDesignerFormWindowManagerInterface.qth
QDesignerObjectInspectorInterface.qth
QDesignerPropertyEditorInterface.qth
QDesignerWidgetBoxInterface.qth

102
harbour/contrib/hbqt/qtdesigner/qth/QDesignerActionEditorInterface.qth Normal file
View File

@@ -0,0 +1,102 @@
/*
* $Id$
*/
/*
* Harbour Project source code:
* QT Source Generator for Harbour
*
* Copyright 2009 Pritpal Bedi <pritpal@vouchcac.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.
*
*/
/*----------------------------------------------------------------------*/
;
; Header File to Generate QT Wrapper Sources
;
<CLASS>
QObject =
Inherits = QWidget
Type =
New =
folder = hbqtdesigner
</CLASS>
<SUBCLASS>
</SUBCLASS>
<DOC>
</DOC>
<CODE>
#include <QtDesigner/QDesignerActionEditorInterface>
#include "hbqt_garbage.h"
#include "hbqt_local.h"
/*
* QDesignerActionEditorInterface ( QWidget * parent, Qt::WindowFlags flags = 0 )
* ~QDesignerActionEditorInterface ()
*
*/
HB_FUNC( QT_QDESIGNERACTIONEDITORINTERFACE )
{
//hb_retptr( new QDesignerActionEditorInterface() );
}
</CODE>
<ENUMS>
</ENUMS>
<PROTOS>
virtual QDesignerFormEditorInterface * core () const
virtual void manageAction ( QAction * action ) = 0
virtual void unmanageAction ( QAction * action ) = 0
</PROTOS>
<SLOTS>
virtual void setFormWindow ( QDesignerFormWindowInterface * formWindow ) = 0
</SLOTS>
<SIGNALS>
</SIGNALS>

116
harbour/contrib/hbqt/qtdesigner/qth/QDesignerFormEditorInterface.qth Normal file
View File

@@ -0,0 +1,116 @@
/*
* $Id$
*/
/*
* Harbour Project source code:
* QT Source Generator for Harbour
*
* Copyright 2009 Pritpal Bedi <pritpal@vouchcac.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.
*
*/
/*----------------------------------------------------------------------*/
;
; Header File to Generate QT Wrapper Sources
;
<CLASS>
QObject =
Inherits = QObject
Type =
New =
folder = hbqtdesigner
</CLASS>
<SUBCLASS>
</SUBCLASS>
<DOC>
</DOC>
<CODE>
#include <QtDesigner/QDesignerFormEditorInterface>
#include "hbqt_garbage.h"
#include "hbqt_local.h"
/*
* QDesignerFormEditorInterface ( QObject * parent = 0 )
* virtual ~QDesignerFormEditorInterface ()
*
*/
HB_FUNC( QT_QDESIGNERFORMEDITORINTERFACE )
{
if( HB_ISPOINTER( 1 ) )
{
hb_retptr( new QDesignerFormEditorInterface( hbqt_par_QObject( 1 ) ) );
}
else
{
hb_retptr( new QDesignerFormEditorInterface() );
}
}
</CODE>
<ENUMS>
</ENUMS>
<PROTOS>
QDesignerActionEditorInterface * actionEditor () const
//QExtensionManager * extensionManager () const
QDesignerFormWindowManagerInterface * formWindowManager () const
QDesignerObjectInspectorInterface * objectInspector () const
QDesignerPropertyEditorInterface * propertyEditor () const
void setActionEditor ( QDesignerActionEditorInterface * actionEditor )
void setObjectInspector ( QDesignerObjectInspectorInterface * objectInspector )
void setPropertyEditor ( QDesignerPropertyEditorInterface * propertyEditor )
void setWidgetBox ( QDesignerWidgetBoxInterface * widgetBox )
QWidget * topLevel () const
QDesignerWidgetBoxInterface * widgetBox () const
</PROTOS>
<SLOTS>
</SLOTS>
<SIGNALS>
</SIGNALS>

113
harbour/contrib/hbqt/qtdesigner/qth/QDesignerFormWindowCursorInterface.qth Normal file
View File

@@ -0,0 +1,113 @@
/*
* $Id$
*/
/*
* Harbour Project source code:
* QT Source Generator for Harbour
*
* Copyright 2009 Pritpal Bedi <pritpal@vouchcac.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.
*
*/
/*----------------------------------------------------------------------*/
;
; Header File to Generate QT Wrapper Sources
;
<CLASS>
QObject = no
Inherits =
Type =
New =
folder = hbqtdesigner
</CLASS>
<SUBCLASS>
</SUBCLASS>
<DOC>
</DOC>
<CODE>
#include <QtDesigner/QDesignerFormWindowCursorInterface>
#include "hbqt_garbage.h"
#include "hbqt_local.h"
/*
* ~QDesignerFormWindowCursorInterface ()
*
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWCURSORINTERFACE )
{
//hb_retptr( new QDesignerFormWindowCursorInterface() );
}
</CODE>
<ENUMS>
enum MoveMode { MoveAnchor, KeepAnchor }
enum MoveOperation { NoMove, Start, End, Next, ..., Down }
</ENUMS>
<PROTOS>
virtual QWidget * current () const = 0
virtual QDesignerFormWindowInterface * formWindow () const = 0
virtual bool hasSelection () const = 0
bool isWidgetSelected ( QWidget * widget ) const
virtual bool movePosition ( MoveOperation operation, MoveMode mode = MoveAnchor ) = 0
virtual int position () const = 0
virtual void resetWidgetProperty ( QWidget * widget, const QString & name ) = 0
virtual QWidget * selectedWidget ( int index ) const = 0
virtual int selectedWidgetCount () const = 0
virtual void setPosition ( int position, MoveMode mode = MoveAnchor ) = 0
virtual void setProperty ( const QString & name, const QVariant & value ) = 0
virtual void setWidgetProperty ( QWidget * widget, const QString & name, const QVariant & value ) = 0
virtual QWidget * widget ( int index ) const = 0
virtual int widgetCount () const = 0
</PROTOS>
<SLOTS>
</SLOTS>
<SIGNALS>
</SIGNALS>

157
harbour/contrib/hbqt/qtdesigner/qth/QDesignerFormWindowInterface.qth Normal file
View File

@@ -0,0 +1,157 @@
/*
* $Id$
*/
/*
* Harbour Project source code:
* QT Source Generator for Harbour
*
* Copyright 2009 Pritpal Bedi <pritpal@vouchcac.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.
*
*/
/*----------------------------------------------------------------------*/
;
; Header File to Generate QT Wrapper Sources
;
<CLASS>
QObject =
Inherits = QWidget
Type =
New =
folder = hbqtdesigner
</CLASS>
<SUBCLASS>
</SUBCLASS>
<DOC>
</DOC>
<CODE>
#include <QtDesigner/QDesignerFormWindowInterface>
#include "hbqt_garbage.h"
#include "hbqt_local.h"
/*
* QDesignerFormWindowInterface ( QWidget * parent = 0, Qt::WindowFlags flags = 0 )
* ~QDesignerFormWindowInterface ()
*
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWINTERFACE )
{
//hb_retptr( new QDesignerFormWindowInterface() );
}
</CODE>
<ENUMS>
flags Feature
enum FeatureFlag { EditFeature, GridFeature, TabOrderFeature, DefaultFeature }
</ENUMS>
<PROTOS>
//virtual QDir absoluteDir () const = 0
virtual void addResourceFile ( const QString & path ) = 0
virtual QString author () const = 0
virtual QString comment () const = 0
virtual QString contents () const = 0
virtual QDesignerFormEditorInterface * core () const
virtual QDesignerFormWindowCursorInterface * cursor () const = 0
virtual void emitSelectionChanged () = 0
virtual QString exportMacro () const = 0
virtual Feature features () const = 0
virtual QString fileName () const = 0
virtual QPoint grid () const = 0
virtual bool hasFeature ( Feature feature ) const = 0
virtual QStringList includeHints () const = 0
virtual bool isDirty () const = 0
virtual bool isManaged ( QWidget * widget ) const = 0
virtual void layoutDefault ( int * margin, int * spacing ) = 0
//virtual void layoutFunction ( QString * margin, QString * spacing ) = 0
virtual QWidget * mainContainer () const = 0
virtual QString pixmapFunction () const = 0
virtual void removeResourceFile ( const QString & path ) = 0
virtual QStringList resourceFiles () const = 0
virtual void setAuthor ( const QString & author ) = 0
virtual void setComment ( const QString & comment ) = 0
virtual void setContents ( QIODevice * device ) = 0
virtual void setExportMacro ( const QString & exportMacro ) = 0
virtual void setIncludeHints ( const QStringList & includeHints ) = 0
virtual void setLayoutDefault ( int margin, int spacing ) = 0
//virtual void setLayoutFunction ( const QString & margin, const QString & spacing ) = 0
virtual void setMainContainer ( QWidget * mainContainer ) = 0
virtual void setPixmapFunction ( const QString & pixmapFunction ) = 0
QDesignerFormWindowInterface * findFormWindow ( QWidget * widget )
QDesignerFormWindowInterface * findFormWindow ( QObject * object )
</PROTOS>
<SLOTS>
virtual void clearSelection ( bool update = true ) = 0
virtual void manageWidget ( QWidget * widget ) = 0
virtual void selectWidget ( QWidget * widget, bool select = true ) = 0
virtual void setContents ( const QString & contents ) = 0
virtual void setDirty ( bool dirty ) = 0
virtual void setFeatures ( Feature features ) = 0
virtual void setFileName ( const QString & fileName ) = 0
virtual void setGrid ( const QPoint & grid ) = 0
virtual void unmanageWidget ( QWidget * widget ) = 0
</SLOTS>
<SIGNALS>
void aboutToUnmanageWidget ( QWidget * widget )
void activated ( QWidget * widget )
void changed ()
void featureChanged ( Feature feature )
void fileNameChanged ( const QString & fileName )
void geometryChanged ()
void mainContainerChanged ( QWidget * mainContainer )
void objectRemoved ( QObject * object )
void resourceFilesChanged ()
void selectionChanged ()
void widgetManaged ( QWidget * widget )
void widgetRemoved ( QWidget * widget )
void widgetUnmanaged ( QWidget * widget )
</SIGNALS>

128
harbour/contrib/hbqt/qtdesigner/qth/QDesignerFormWindowManagerInterface.qth Normal file
View File

@@ -0,0 +1,128 @@
/*
* $Id$
*/
/*
* Harbour Project source code:
* QT Source Generator for Harbour
*
* Copyright 2009 Pritpal Bedi <pritpal@vouchcac.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.
*
*/
/*----------------------------------------------------------------------*/
;
; Header File to Generate QT Wrapper Sources
;
<CLASS>
QObject =
Inherits = QObject
Type =
New =
folder = hbqtdesigner
</CLASS>
<SUBCLASS>
</SUBCLASS>
<DOC>
</DOC>
<CODE>
#include <QtDesigner/QDesignerFormWindowManagerInterface>
#include "hbqt_garbage.h"
#include "hbqt_local.h"
/*
* QDesignerFormWindowManagerInterface ( QObject * parent = 0 )
* ~QDesignerFormWindowManagerInterface ()
*
*/
HB_FUNC( QT_QDESIGNERFORMWINDOWMANAGERINTERFACE )
{
//hb_retptr( new QDesignerFormWindowManagerInterface() );
}
</CODE>
<ENUMS>
</ENUMS>
<PROTOS>
virtual QAction * actionAdjustSize () const
virtual QAction * actionBreakLayout () const
virtual QAction * actionCopy () const
virtual QAction * actionCut () const
virtual QAction * actionDelete () const
QAction * actionFormLayout () const
virtual QAction * actionGridLayout () const
virtual QAction * actionHorizontalLayout () const
virtual QAction * actionLower () const
virtual QAction * actionPaste () const
virtual QAction * actionRaise () const
virtual QAction * actionRedo () const
virtual QAction * actionSelectAll () const
QAction * actionSimplifyLayout () const
virtual QAction * actionSplitHorizontal () const
virtual QAction * actionSplitVertical () const
virtual QAction * actionUndo () const
virtual QAction * actionVerticalLayout () const
virtual QDesignerFormWindowInterface * activeFormWindow () const
virtual QDesignerFormEditorInterface * core () const
virtual QDesignerFormWindowInterface * createFormWindow ( QWidget * parent = 0, Qt::WindowFlags flags = 0 )
virtual QDesignerFormWindowInterface * formWindow ( int index ) const
virtual int formWindowCount () const
</PROTOS>
<SLOTS>
virtual void addFormWindow ( QDesignerFormWindowInterface * formWindow )
virtual void removeFormWindow ( QDesignerFormWindowInterface * formWindow )
virtual void setActiveFormWindow ( QDesignerFormWindowInterface * formWindow )
</SLOTS>
<SIGNALS>
void activeFormWindowChanged ( QDesignerFormWindowInterface * formWindow )
void formWindowAdded ( QDesignerFormWindowInterface * formWindow )
void formWindowRemoved ( QDesignerFormWindowInterface * formWindow )
</SIGNALS>

100
harbour/contrib/hbqt/qtdesigner/qth/QDesignerObjectInspectorInterface.qth Normal file
View File

@@ -0,0 +1,100 @@
/*
* $Id$
*/
/*
* Harbour Project source code:
* QT Source Generator for Harbour
*
* Copyright 2009 Pritpal Bedi <pritpal@vouchcac.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.
*
*/
/*----------------------------------------------------------------------*/
;
; Header File to Generate QT Wrapper Sources
;
<CLASS>
QObject =
Inherits = QWidget
Type =
New =
folder = hbqtdesigner
</CLASS>
<SUBCLASS>
</SUBCLASS>
<DOC>
</DOC>
<CODE>
#include <QtDesigner/QDesignerObjectInspectorInterface>
#include "hbqt_garbage.h"
#include "hbqt_local.h"
/*
* QDesignerObjectInspectorInterface ( QWidget * parent, Qt::WindowFlags flags = 0 )
* ~QDesignerObjectInspectorInterface ()
*
*/
HB_FUNC( QT_QDESIGNEROBJECTINSPECTORINTERFACE )
{
//hb_retptr( new QDesignerObjectInspectorInterface() );
}
</CODE>
<ENUMS>
</ENUMS>
<PROTOS>
virtual QDesignerFormEditorInterface * core () const
</PROTOS>
<SLOTS>
virtual void setFormWindow ( QDesignerFormWindowInterface * formWindow ) = 0
</SLOTS>
<SIGNALS>
</SIGNALS>

105
harbour/contrib/hbqt/qtdesigner/qth/QDesignerPropertyEditorInterface.qth Normal file
View File

@@ -0,0 +1,105 @@
/*
* $Id$
*/
/*
* Harbour Project source code:
* QT Source Generator for Harbour
*
* Copyright 2009 Pritpal Bedi <pritpal@vouchcac.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.
*
*/
/*----------------------------------------------------------------------*/
;
; Header File to Generate QT Wrapper Sources
;
<CLASS>
QObject =
Inherits = QWidget
Type =
New =
folder = hbqtdesigner
</CLASS>
<SUBCLASS>
</SUBCLASS>
<DOC>
</DOC>
<CODE>
#include <QtDesigner/QDesignerPropertyEditorInterface>
#include "hbqt_garbage.h"
#include "hbqt_local.h"
/*
* QDesignerPropertyEditorInterface ( QWidget * parent, Qt::WindowFlags flags = 0 )
* ~QDesignerPropertyEditorInterface ()
*
*/
HB_FUNC( QT_QDESIGNERPROPERTYEDITORINTERFACE )
{
//hb_retptr( new QDesignerPropertyEditorInterface() );
}
</CODE>
<ENUMS>
</ENUMS>
<PROTOS>
virtual QDesignerFormEditorInterface * core () const
virtual QString currentPropertyName () const = 0
virtual bool isReadOnly () const = 0
virtual QObject * object () const = 0
</PROTOS>
<SLOTS>
virtual void setObject ( QObject * object ) = 0
virtual void setPropertyValue ( const QString & name, const QVariant & value, bool changed = true ) = 0
virtual void setReadOnly ( bool readOnly ) = 0
</SLOTS>
<SIGNALS>
</SIGNALS>

26
harbour/contrib/hbqt/qth/QItemEditorCreator.qth → harbour/contrib/hbqt/qtdesigner/qth/QDesignerWidgetBoxInterface.qth
View File

@@ -55,10 +55,11 @@
;
<CLASS>
QObject =
Inherits = QItemEditorCreatorBase
Type =
QObject =
Inherits = QWidget
Type =
New =
folder = hbqtdesigner
</CLASS>
<SUBCLASS>
@@ -68,16 +69,19 @@ New =
</DOC>
<CODE>
#include <QtGui/QItemEditorCreator>
#include <QtDesigner/QDesignerWidgetBoxInterface>
#include "hbqt_garbage.h"
#include "hbqt_local.h"
/*
* QItemEditorCreator ( const QByteArray & valuePropertyName )
*
* QDesignerWidgetBoxInterface ( QWidget * parent = 0, Qt::WindowFlags flags = 0 )
* ~QDesignerWidgetBoxInterface ()
*
*/
HB_FUNC( QT_QITEMEDITORCREATOR )
HB_FUNC( QT_QDESIGNERWIDGETBOXINTERFACE )
{
// hb_retptr( new QItemEditorCreator( hbqt_par_QByteArray( 1 ) ) );
//hb_retptr( new QDesignerWidgetBoxInterface() );
}
</CODE>
@@ -85,8 +89,10 @@ HB_FUNC( QT_QITEMEDITORCREATOR )
</ENUMS>
<PROTOS>
virtual QWidget * createWidget ( QWidget * parent ) const
virtual QByteArray valuePropertyName () const
virtual QString fileName () const = 0
virtual bool load () = 0
virtual bool save () = 0
virtual void setFileName ( const QString & fileName ) = 0
</PROTOS>
<SLOTS>