1b633cd242
* contrib/gtqtc/gtqtc.h
* contrib/gtqtc/gtqtc1.cpp
+ added support for disabling title and frames of console window by
hb_gtInfo( HB_GTI_WINTITLE, <lNoFrame> )
* src/rtl/transfrm.c
! fixed bug in "@S<n>" transformation when multibyte CDP is used
3996 lines
126 KiB
C++
3996 lines
126 KiB
C++
/*
|
|
* QT Console
|
|
*
|
|
* Copyright 2013 Przemyslaw Czerpak <druzus /at/ priv.onet.pl>
|
|
* Slightly based on GTQTC
|
|
* Copyright 2009-2011 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 program; see the file LICENSE.txt. If not, write to
|
|
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
* Boston, MA 02110-1301 USA (or visit https://www.gnu.org/licenses/).
|
|
*
|
|
* 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 "gtqtc.h"
|
|
|
|
static int s_GtId;
|
|
static HB_GT_FUNCS SuperTable;
|
|
#define HB_GTSUPER ( &SuperTable )
|
|
#define HB_GTID_PTR ( &s_GtId )
|
|
|
|
#define HB_GTQTC_GET( p ) ( static_cast< PHB_GTQTC >( HB_GTLOCAL( p ) ) )
|
|
|
|
|
|
#if defined( HB_OS_UNIX )
|
|
# if ! defined( HB_QT_NEEDLOCKS )
|
|
# define HB_QT_NEEDLOCKS
|
|
# endif
|
|
# if ! defined( HB_XLIB_NEEDLOCKS )
|
|
/* # define HB_XLIB_NEEDLOCKS */
|
|
# endif
|
|
#endif
|
|
|
|
#ifdef HB_QT_NEEDLOCKS
|
|
# if QT_VERSION >= 0x060000
|
|
static QRecursiveMutex s_qMtx;
|
|
# else
|
|
static QMutex s_qMtx( QMutex::Recursive );
|
|
# endif
|
|
# define HB_QTC_LOCK() do { s_qMtx.lock()
|
|
# define HB_QTC_UNLOCK() s_qMtx.unlock(); } while( 0 )
|
|
#else
|
|
# define HB_QTC_LOCK() do {} while( 0 )
|
|
# define HB_QTC_UNLOCK() do {} while( 0 )
|
|
#endif
|
|
|
|
static QApplication * s_qtapp = NULL;
|
|
|
|
/* --- */
|
|
|
|
static void hb_gt_qtc_appFree( void * cargo )
|
|
{
|
|
HB_SYMBOL_UNUSED( cargo );
|
|
|
|
s_qtapp->quit();
|
|
delete s_qtapp;
|
|
s_qtapp = NULL;
|
|
}
|
|
|
|
static void hb_gt_qtc_itemGetQString( PHB_ITEM pItem, QString * pqStr )
|
|
{
|
|
const HB_WCHAR * wStr;
|
|
HB_SIZE nSize;
|
|
void * hStr;
|
|
|
|
if( ( wStr = hb_itemGetStrU16( pItem, HB_CDP_ENDIAN_NATIVE, &hStr, &nSize ) ) != NULL )
|
|
{
|
|
#if defined( HB_OS_WIN )
|
|
* pqStr = QString::fromWCharArray( wStr, nSize );
|
|
#elif QT_VERSION >= 0x060000
|
|
* pqStr = QString::fromUtf16( ( char16_t * ) wStr, nSize );
|
|
#else
|
|
* pqStr = QString::fromUtf16( wStr, nSize );
|
|
#endif
|
|
hb_strfree( hStr );
|
|
}
|
|
}
|
|
|
|
static PHB_ITEM hb_gt_qtc_itemPutQString( PHB_ITEM pItem, const QString * pqStr )
|
|
{
|
|
#if defined( HB_OS_WIN )
|
|
return hb_itemPutStrLenU16( pItem, HB_CDP_ENDIAN_NATIVE,
|
|
reinterpret_cast< const HB_WCHAR * >( pqStr->utf16() ),
|
|
pqStr->size() );
|
|
#else
|
|
return hb_itemPutStrLenU16( pItem, HB_CDP_ENDIAN_NATIVE,
|
|
pqStr->utf16(), pqStr->size() );
|
|
#endif
|
|
}
|
|
|
|
/* --- */
|
|
|
|
#define hb_bm_paint_begin( qBitMap ) do { \
|
|
QPainter painter( qBitMap ); \
|
|
painter.setBackgroundMode( Qt::OpaqueMode ); \
|
|
painter.setBrush( Qt::SolidPattern ); \
|
|
painter.setPen( Qt::SolidLine )
|
|
|
|
#define hb_bm_paint_end() } while( 0 )
|
|
|
|
#define hb_bm_color( c ) painter.setPen( QTC_NUM2RGB( c ) )
|
|
#define hb_bm_rect( x, y, w, h ) painter.drawRect( x, y, w, h )
|
|
#define hb_bm_fillrectc( x, y, w, h, c ) painter.fillRect( x, y, w, h, QTC_NUM2RGB( c ) )
|
|
|
|
#define hb_bm_line( x1, y1, x2, y2 ) painter.drawLine( x1, y1, x2, y2 )
|
|
#define hb_bm_point( x, y ) painter.drawPoint( x, y )
|
|
#define hb_bm_fillrect( x, y, w, h ) painter.fillRect( x, y, w, h, Qt::color1 )
|
|
#define hb_bm_polygon( pts, n ) painter.drawPolygon( pts, n )
|
|
#define hb_bm_invertrect( x, y, w, h ) do { \
|
|
painter.setCompositionMode( QPainter::RasterOp_SourceXorDestination ); \
|
|
painter.fillRect( 0, 0, w, h, Qt::color1 ); \
|
|
} while( 0 )
|
|
#define hb_bm_text( ch ) do { \
|
|
QPainter painter( qBitMap ); \
|
|
painter.setBackgroundMode( Qt::OpaqueMode ); \
|
|
painter.setFont( QFont( pQTC->qWnd->qConsole->font, painter.device() ) ); \
|
|
painter.drawText( 0, pQTC->fontAscent, QString( ch ) ); \
|
|
} while( 0 )
|
|
|
|
static QBitmap * hb_gt_qtc_bitmap_char( int cellx, int celly )
|
|
{
|
|
QBitmap * qBitMap = new QBitmap( cellx, celly );
|
|
qBitMap->clear();
|
|
return qBitMap;
|
|
}
|
|
|
|
static QBitmap * hb_gt_qtc_defineBoxButtonL( int cellx, int celly )
|
|
{
|
|
QBitmap * qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
|
|
hb_bm_paint_begin( qBitMap );
|
|
|
|
hb_bm_line( cellx - 1, 0, 0, 0 );
|
|
hb_bm_line( 0, 0, 0, celly - 1 );
|
|
hb_bm_line( 0, celly - 1, cellx - 1, celly - 1 );
|
|
|
|
hb_bm_line( 2, celly - 2, cellx - 1, celly - 2 );
|
|
|
|
hb_bm_paint_end();
|
|
|
|
return qBitMap;
|
|
}
|
|
|
|
static QBitmap * hb_gt_qtc_defineBoxButtonR( int cellx, int celly )
|
|
{
|
|
QBitmap * qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
|
|
hb_bm_paint_begin( qBitMap );
|
|
|
|
hb_bm_line( 0, 0, cellx - 1, 0 );
|
|
hb_bm_line( cellx - 1, 0, cellx - 1, celly - 1 );
|
|
hb_bm_line( cellx - 1, celly - 1, 0, celly - 1 );
|
|
|
|
hb_bm_line( cellx - 2, 3, cellx - 2, celly - 2 );
|
|
hb_bm_line( cellx - 2, celly - 2, 0, celly - 2 );
|
|
|
|
hb_bm_paint_end();
|
|
|
|
return qBitMap;
|
|
}
|
|
|
|
static QBitmap * hb_gt_qtc_defineBoxChar( PHB_GTQTC pQTC, HB_USHORT usCh )
|
|
{
|
|
QBitmap * qBitMap = NULL;
|
|
int cellx = pQTC->cellX;
|
|
int celly = pQTC->cellY;
|
|
int i, y, x, yy, xx;
|
|
QPoint pts[ 3 ];
|
|
|
|
if( usCh >= HB_BOXCH_RC_MIN && usCh <= HB_BOXCH_RC_MAX )
|
|
switch( usCh )
|
|
{
|
|
case HB_BOXCH_RC_ARROW_DL:
|
|
qBitMap = hb_gt_qtc_defineBoxButtonL( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
yy = celly / 2 - 1;
|
|
for( y = celly - 4, x = cellx - 1; x >= 3 && y >= yy; --x, --y )
|
|
hb_bm_line( x, y, cellx - 1, y );
|
|
xx = HB_MAX( cellx * 2 / 5, 3 ) | 1;
|
|
for( x = cellx - xx / 2 - 1; y >= 3; --y )
|
|
hb_bm_line( x, y, cellx - 1, y );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_ARROW_DR:
|
|
qBitMap = hb_gt_qtc_defineBoxButtonR( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
yy = ( celly + 1 ) / 2;
|
|
for( y = celly - 5, x = 0; x < cellx - 4 && y >= yy; ++x, --y )
|
|
hb_bm_line( 0, y, x, y );
|
|
xx = HB_MAX( cellx * 2 / 5, 3 ) | 1;
|
|
for( x = xx / 2 - 1; y >= 3; --y )
|
|
hb_bm_line( 0, y, x, y );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_ARROW_UL:
|
|
qBitMap = hb_gt_qtc_defineBoxButtonL( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
yy = ( celly + 1 ) / 2;
|
|
for( y = 3, x = cellx - 1; x >= 3 && y <= yy; --x, ++y )
|
|
hb_bm_line( x, y, cellx - 1, y );
|
|
xx = HB_MAX( cellx * 2 / 5, 3 ) | 1;
|
|
for( x = cellx - xx / 2 - 1; y < celly - 3; ++y )
|
|
hb_bm_line( x, y, cellx - 1, y );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_ARROW_UR:
|
|
qBitMap = hb_gt_qtc_defineBoxButtonR( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
yy = ( celly + 1 ) / 2;
|
|
for( y = 4, x = 0; x < cellx - 4 && y <= yy; ++x, ++y )
|
|
hb_bm_line( 0, y, x, y );
|
|
xx = HB_MAX( cellx * 2 / 5, 3 ) | 1;
|
|
for( x = xx / 2 - 1; y < celly - 3; ++y )
|
|
hb_bm_line( 0, y, x, y );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_ARROW_VL:
|
|
qBitMap = hb_gt_qtc_defineBoxButtonL( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
yy = ( celly - 1 ) / 2;
|
|
for( y = 3, x = cellx - 1; x >= 3 && y < yy; --x, ++y )
|
|
hb_bm_line( x, y, cellx - 1, y );
|
|
for( y = yy + 2, ++x; x <= cellx - 1 && y < celly - 3; ++x, ++y )
|
|
hb_bm_line( x, y, cellx - 1, y );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_ARROW_VR:
|
|
qBitMap = hb_gt_qtc_defineBoxButtonR( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
yy = ( celly - 1 ) / 2;
|
|
for( y = 4, x = 0; x < cellx - 4 && y < yy; ++x, ++y )
|
|
hb_bm_line( 0, y, x, y );
|
|
for( y = yy + 2, --x; x >= 0 && y < celly - 3; --x, ++y )
|
|
hb_bm_line( 0, y, x, y );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_BUTTON_L:
|
|
qBitMap = hb_gt_qtc_defineBoxButtonL( cellx, celly );
|
|
break;
|
|
|
|
case HB_BOXCH_RC_BUTTON_R:
|
|
qBitMap = hb_gt_qtc_defineBoxButtonR( cellx, celly );
|
|
break;
|
|
|
|
case HB_BOXCH_RC_ARROW_LL:
|
|
qBitMap = hb_gt_qtc_defineBoxButtonL( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
yy = ( celly - 1 ) / 2;
|
|
for( x = 3, y = 0; x < cellx; ++x, ++y )
|
|
hb_bm_line( x, yy - y, x, yy + y );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_ARROW_LR:
|
|
qBitMap = hb_gt_qtc_defineBoxButtonR( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
yy = HB_MAX( celly / 5, 3 ) | 1;
|
|
for( y = ( celly - yy ) / 2; yy--; ++y )
|
|
hb_bm_line( 0, y, cellx - 4, y );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_ARROW_RL:
|
|
qBitMap = hb_gt_qtc_defineBoxButtonL( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
yy = HB_MAX( celly / 5, 3 ) | 1;
|
|
for( y = ( celly - yy ) / 2; yy--; ++y )
|
|
hb_bm_line( 3, y, cellx - 1, y );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_ARROW_RR:
|
|
qBitMap = hb_gt_qtc_defineBoxButtonR( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
yy = ( celly - 1 ) / 2;
|
|
for( x = cellx - 4, y = 0; x >= 0; --x, ++y )
|
|
hb_bm_line( x, yy - y, x, yy + y );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_ENTER1:
|
|
/* TODO */
|
|
break;
|
|
case HB_BOXCH_RC_ENTER2:
|
|
/* TODO */
|
|
break;
|
|
case HB_BOXCH_RC_ENTER3:
|
|
/* TODO */
|
|
break;
|
|
|
|
case HB_BOXCH_RC_VSCRL_LD:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
|
|
hb_bm_line( 0, 0, 0, celly - 1 );
|
|
hb_bm_line( 0, celly / 2, cellx - 1, celly / 2 );
|
|
hb_bm_line( 2, celly / 2 - 1, cellx - 1, celly / 2 - 1 );
|
|
|
|
for( y = celly / 2 + 1; y < celly; y++ )
|
|
{
|
|
for( x = ( y & 1 ) + 2; x < cellx; x += 2 )
|
|
hb_bm_point( x, y );
|
|
}
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_VSCRL_RD:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
|
|
hb_bm_line( cellx - 1, 0, cellx - 1, celly - 1 );
|
|
hb_bm_line( cellx - 2, 0, cellx - 2, celly / 2 - 1 );
|
|
hb_bm_line( 0, celly / 2, cellx - 1, celly / 2 );
|
|
hb_bm_line( 0, celly / 2 - 1, cellx - 1, celly / 2 - 1 );
|
|
|
|
for( y = celly / 2 + 1; y < celly; y++ )
|
|
{
|
|
for( x = ( y ^ cellx ) & 1; x < cellx - 2; x += 2 )
|
|
hb_bm_point( x, y );
|
|
}
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_VSCRL_LU:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
|
|
hb_bm_line( 0, 0, 0, celly - 1 );
|
|
hb_bm_line( 0, celly / 2, cellx - 1, celly / 2 );
|
|
|
|
for( y = 0; y < celly / 2; y++ )
|
|
{
|
|
for( x = ( y & 1 ) + 2; x < cellx; x += 2 )
|
|
hb_bm_point( x, y );
|
|
}
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_VSCRL_RU:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
|
|
hb_bm_line( cellx - 1, 0, cellx - 1, celly - 1 );
|
|
hb_bm_line( 0, celly / 2, cellx - 1, celly / 2 );
|
|
hb_bm_line( cellx - 2, celly / 2 + 3, cellx - 2, celly - 1 );
|
|
|
|
for( y = 0; y < celly / 2; y++ )
|
|
{
|
|
for( x = ( y ^ cellx ) & 1; x < cellx - 2; x += 2 )
|
|
hb_bm_point( x, y );
|
|
}
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_VSCRL_L:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
|
|
hb_bm_line( 0, 0, 0, celly - 1 );
|
|
|
|
for( y = 0; y < celly; y++ )
|
|
{
|
|
for( x = ( y & 1 ) + 2; x < cellx; x += 2 )
|
|
hb_bm_point( x, y );
|
|
}
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_VSCRL_R:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
|
|
hb_bm_line( cellx - 1, 0, cellx - 1, celly - 1 );
|
|
|
|
for( y = 0; y < celly; y++ )
|
|
{
|
|
for( x = ( y ^ cellx ) & 1; x < cellx - 2; x += 2 )
|
|
hb_bm_point( x, y );
|
|
}
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_HSCRL:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
|
|
hb_bm_line( 0, 0, cellx - 1, 0 );
|
|
hb_bm_line( 0, celly - 1, cellx - 1, celly - 1 );
|
|
|
|
for( y = 2; y < celly - 2; y++ )
|
|
{
|
|
for( x = y & 1; x < cellx; x += 2 )
|
|
hb_bm_point( x, y );
|
|
}
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_0:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_text( "0" );
|
|
break;
|
|
|
|
case HB_BOXCH_RC_1:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_text( "1" );
|
|
break;
|
|
|
|
case HB_BOXCH_RC_2:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_text( "2" );
|
|
break;
|
|
|
|
case HB_BOXCH_RC_3:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_text( "3" );
|
|
break;
|
|
|
|
case HB_BOXCH_RC_4:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_text( "4" );
|
|
break;
|
|
|
|
case HB_BOXCH_RC_5:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_text( "5" );
|
|
break;
|
|
|
|
case HB_BOXCH_RC_6:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_text( "6" );
|
|
break;
|
|
|
|
case HB_BOXCH_RC_7:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_text( "7" );
|
|
break;
|
|
|
|
case HB_BOXCH_RC_8:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_text( "8" );
|
|
break;
|
|
|
|
case HB_BOXCH_RC_9:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_text( "9" );
|
|
break;
|
|
|
|
case HB_BOXCH_RC_DOT:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_text( "." );
|
|
break;
|
|
|
|
case HB_BOXCH_RC_ACC:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_text( "'" );
|
|
break;
|
|
|
|
case HB_BOXCH_RC_BOX_ML:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( 0, celly / 2, cellx - 1, celly / 2 );
|
|
hb_bm_line( 0, 0, 0, celly - 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_BOX_MR:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( 0, celly / 2, cellx - 1, celly / 2 );
|
|
hb_bm_line( cellx - 1, 0, cellx - 1, celly - 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_HWND_L:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx - 1, 0, 0, 0 );
|
|
hb_bm_line( 0, 0, 0, celly - 1 );
|
|
hb_bm_line( 0, celly - 1, cellx - 1, celly - 1 );
|
|
hb_bm_line( cellx - 1, celly / 4 + 2, cellx / 4 + 1, celly / 4 + 2 );
|
|
hb_bm_line( cellx / 4 + 1, celly / 4 + 2, cellx / 4 + 1, celly - 4 - celly / 4 );
|
|
hb_bm_line( cellx / 4 + 1, celly - 4 - celly / 4, cellx - 1, celly - 4 - celly / 4 );
|
|
hb_bm_line( cellx / 4 + 2, celly - 3 - celly / 4, cellx - 1, celly - 3 - celly / 4 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_HWND_R:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( 0, 0, cellx - 1, 0 );
|
|
hb_bm_line( cellx - 1, 0, cellx - 1, celly - 1 );
|
|
hb_bm_line( cellx - 1, celly - 1, 0, celly - 1 );
|
|
hb_bm_line( 0, celly / 4 + 2, cellx - cellx / 4 - 2, celly / 4 + 2 );
|
|
hb_bm_line( cellx - cellx / 4 - 2, celly / 4 + 2, cellx - cellx / 4 - 2, celly - 4 - celly / 4 );
|
|
hb_bm_line( cellx - cellx / 4 - 2, celly - 4 - celly / 4, 0, celly - 4 - celly / 4 );
|
|
hb_bm_line( 0, celly - 3 - celly / 4, cellx - cellx / 4 - 1, celly - 3 - celly / 4 );
|
|
hb_bm_line( cellx - cellx / 4 - 1, celly - 3 - celly / 4, cellx - cellx / 4 - 1, celly / 4 + 2 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_BOX_TL:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( 0, 0, cellx - 1, 0 );
|
|
hb_bm_line( 0, 0, 0, celly - 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_BOX_T:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( 0, 0, cellx - 1, 0 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_BOX_TR:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( 0, 0, cellx - 1, 0 );
|
|
hb_bm_line( cellx - 1, 0, cellx - 1, celly - 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_BOX_R:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx - 1, 0, cellx - 1, celly - 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_BOX_BR:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx - 1, 0, cellx - 1, celly - 1 );
|
|
hb_bm_line( 0, celly - 1, cellx - 1, celly - 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_BOX_B:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( 0, celly - 1, cellx - 1, celly - 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_BOX_BL:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( 0, 0, 0, celly - 1 );
|
|
hb_bm_line( 0, celly - 1, cellx - 1, celly - 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_BOX_L:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( 0, 0, 0, celly - 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_BOX_MT:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx / 2, 0, cellx / 2, celly - 1 );
|
|
hb_bm_line( 0, 0, cellx - 1, 0 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_BOX_MB:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx / 2, 0, cellx / 2, celly - 1 );
|
|
hb_bm_line( 0, celly - 1, cellx - 1, celly - 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_BUTTON_CL:
|
|
qBitMap = hb_gt_qtc_defineBoxButtonL( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
yy = celly - 2 / 3;
|
|
xx = cellx - 4;
|
|
if( yy > xx )
|
|
yy = xx;
|
|
xx = ( xx * 2 + 1 ) / 3;
|
|
if( xx < 2 )
|
|
xx = 2;
|
|
for( y = celly - yy - 3 - xx, i = 0; i < xx; ++y, ++i )
|
|
hb_bm_line( 3, y, 3 + yy - 1, y + yy - 1 );
|
|
y = celly - 5 - xx;
|
|
hb_bm_line( cellx - 1, y, cellx - 1, y + xx - 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_BUTTON_CR:
|
|
qBitMap = hb_gt_qtc_defineBoxButtonR( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
yy = celly - 2 / 3;
|
|
xx = cellx - 4;
|
|
if( yy > xx )
|
|
yy = xx;
|
|
xx = ( xx * 2 + 1 ) / 3;
|
|
if( xx < 2 )
|
|
xx = 2;
|
|
for( y = celly - 6 - xx, i = 0; i < xx; ++y, ++i )
|
|
hb_bm_line( 0, y, yy, y - yy );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_FARROW_DL:
|
|
qBitMap = hb_gt_qtc_defineBoxButtonL( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
yy = ( celly - cellx ) / 2 + 1;
|
|
yy = HB_MAX( yy, 2 );
|
|
for( y = celly - yy - 1, x = cellx - 1; x >= 2 && y >= 3; --x, --y )
|
|
hb_bm_line( x, y, cellx - 1, y );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_FARROW_DR:
|
|
qBitMap = hb_gt_qtc_defineBoxButtonR( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
yy = ( celly - cellx ) / 2 + 1;
|
|
yy = HB_MAX( yy, 2 );
|
|
for( y = celly - yy - 2, x = 0; x < cellx - 3 && y >= 3; ++x, --y )
|
|
hb_bm_line( 0, y, x, y );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_DOTS:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
|
|
for( x = 1; x < cellx; x += 2 )
|
|
hb_bm_point( x, celly / 2 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_DOTS_L:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
|
|
i = cellx / 2;
|
|
xx = i - i / 2;
|
|
yy = HB_MAX( 2, xx - 1 );
|
|
|
|
hb_bm_fillrect( cellx - xx / 2 - i, celly / 3 * 2, xx , yy );
|
|
hb_bm_fillrect( cellx - xx / 2 , celly / 3 * 2, xx / 2, yy );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_RC_DOTS_R:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
|
|
i = cellx / 2;
|
|
xx = i - i / 2;
|
|
yy = HB_MAX( 2, xx - 1 );
|
|
|
|
hb_bm_fillrect( 0 , celly / 3 * 2, xx - xx / 2, yy );
|
|
hb_bm_fillrect( i - xx / 2, celly / 3 * 2, xx , yy );
|
|
hb_bm_paint_end();
|
|
break;
|
|
}
|
|
else
|
|
switch( usCh )
|
|
{
|
|
case HB_BOXCH_FILLER1:
|
|
case HB_BOXCH_FILLER2:
|
|
case HB_BOXCH_FILLER3:
|
|
{
|
|
int skip, start, mod;
|
|
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
|
|
if( usCh == HB_BOXCH_FILLER1 )
|
|
{
|
|
skip = 4;
|
|
start = mod = 1;
|
|
}
|
|
else if( usCh == HB_BOXCH_FILLER2 )
|
|
{
|
|
skip = 2;
|
|
start = 0;
|
|
mod = 1;
|
|
}
|
|
else
|
|
{
|
|
skip = 4;
|
|
start = mod = 0;
|
|
}
|
|
for( y = 0; y < celly; y++ )
|
|
{
|
|
for( x = start + ( skip >> 1 ) * ( ( y & 1 ) ^ mod ); x < cellx; x += skip )
|
|
hb_bm_point( x, y );
|
|
}
|
|
if( usCh == HB_BOXCH_FILLER3 )
|
|
hb_bm_invertrect( 0, 0, cellx, celly );
|
|
hb_bm_paint_end();
|
|
break;
|
|
}
|
|
case HB_BOXCH_ARROW_R:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
|
|
i = HB_MIN( ( celly >> 1 ), cellx ) - 3;
|
|
pts[ 0 ].setX( ( cellx - i ) >> 1 );
|
|
pts[ 0 ].setY( ( celly >> 1 ) - i );
|
|
pts[ 1 ].setX( pts[ 0 ].x() + i );
|
|
pts[ 1 ].setY( pts[ 0 ].y() + i );
|
|
pts[ 2 ].setX( pts[ 1 ].x() - i );
|
|
pts[ 2 ].setY( pts[ 1 ].y() + i );
|
|
hb_bm_polygon( pts, 3 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_ARROW_L:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
|
|
i = HB_MIN( ( celly >> 1 ), cellx ) - 3;
|
|
pts[ 0 ].setX( ( ( cellx - i ) >> 1 ) + i );
|
|
pts[ 0 ].setY( ( celly >> 1 ) - i );
|
|
pts[ 1 ].setX( pts[ 0 ].x() - i );
|
|
pts[ 1 ].setY( pts[ 0 ].y() + i );
|
|
pts[ 2 ].setX( pts[ 1 ].x() + i );
|
|
pts[ 2 ].setY( pts[ 1 ].y() + i );
|
|
hb_bm_polygon( pts, 3 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_ARROW_U:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
|
|
i = HB_MIN( celly, cellx >> 1 );
|
|
pts[ 0 ].setX( ( cellx >> 1 ) - i );
|
|
pts[ 0 ].setY( ( ( celly - i ) >> 1 ) + i );
|
|
pts[ 1 ].setX( pts[ 0 ].x() + i );
|
|
pts[ 1 ].setY( pts[ 0 ].y() - i );
|
|
pts[ 2 ].setX( pts[ 1 ].x() + i );
|
|
pts[ 2 ].setY( pts[ 1 ].y() + i );
|
|
hb_bm_polygon( pts, 3 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_ARROW_D:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
|
|
i = HB_MIN( celly, cellx >> 1 );
|
|
pts[ 0 ].setX( ( cellx >> 1 ) - i );
|
|
pts[ 0 ].setY( ( celly - i ) >> 1 );
|
|
pts[ 1 ].setX( pts[ 0 ].x() + i );
|
|
pts[ 1 ].setY( pts[ 0 ].y() + i );
|
|
pts[ 2 ].setX( pts[ 1 ].x() + i );
|
|
pts[ 2 ].setY( pts[ 1 ].y() - i );
|
|
hb_bm_polygon( pts, 3 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_FULL:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_fillrect( 0, 0, cellx, celly );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_FULL_B:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_fillrect( 0, celly / 2 + 1, cellx, ( celly + 1 ) / 2 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_FULL_T:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_fillrect( 0, 0, cellx, celly / 2 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_FULL_R:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_fillrect( cellx / 2 + 1, 0, ( cellx + 1 ) / 2, celly );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_FULL_L:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_fillrect( 0, 0, cellx / 2, celly );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_SNG_LT:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx / 2, celly - 1, cellx / 2, celly / 2 );
|
|
hb_bm_line( cellx / 2, celly / 2, cellx - 1, celly / 2 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_SNG_TD:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( 0, celly / 2, cellx - 1, celly / 2 );
|
|
hb_bm_line( cellx / 2, celly / 2, cellx / 2, celly - 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_SNG_RT:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx / 2, celly - 1, cellx / 2, celly / 2 );
|
|
hb_bm_line( cellx / 2, celly / 2, 0, celly / 2 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_SNG_LB:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx / 2, 0, cellx / 2, celly / 2 );
|
|
hb_bm_line( cellx / 2, celly / 2, cellx - 1, celly / 2 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_SNG_BU:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx / 2, 0, cellx / 2, celly / 2 );
|
|
hb_bm_line( 0, celly / 2, cellx - 1, celly / 2 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_SNG_RB:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx / 2, 0, cellx / 2, celly / 2 );
|
|
hb_bm_line( cellx / 2, celly / 2, 0, celly / 2 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_SNG_VL:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx / 2, 0, cellx / 2, celly - 1 );
|
|
hb_bm_line( cellx / 2, celly / 2, cellx - 1, celly / 2 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_SNG_VR:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx / 2, 0, cellx / 2, celly - 1 );
|
|
hb_bm_line( cellx / 2, celly / 2, 0, celly / 2 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_SNG_CRS:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx / 2, 0, cellx / 2, celly - 1 );
|
|
hb_bm_line( 0, celly / 2, cellx - 1, celly / 2 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_SNG_HOR:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( 0, celly / 2, cellx - 1, celly / 2 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_SNG_VRT:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx / 2, 0, cellx / 2, celly - 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_DBL_LT:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx / 2 - 1, celly - 1, cellx / 2 - 1, celly / 2 - 1 );
|
|
hb_bm_line( cellx / 2 - 1, celly / 2 - 1, cellx - 1, celly / 2 - 1 );
|
|
hb_bm_line( cellx / 2 + 1, celly - 1, cellx / 2 + 1, celly / 2 + 1 );
|
|
hb_bm_line( cellx / 2 + 1, celly / 2 + 1, cellx - 1, celly / 2 + 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_DBL_TD:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( 0, celly / 2 - 1, cellx - 1, celly / 2 - 1 );
|
|
hb_bm_line( 0, celly / 2 + 1, cellx / 2 - 1, celly / 2 + 1 );
|
|
hb_bm_line( cellx / 2 - 1, celly / 2 + 1, cellx / 2 - 1, celly - 1 );
|
|
hb_bm_line( cellx / 2 + 1, celly / 2 + 1, cellx - 1, celly / 2 + 1 );
|
|
hb_bm_line( cellx / 2 + 1, celly / 2 + 1, cellx / 2 + 1, celly - 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_DBL_RT:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx / 2 - 1, celly - 1, cellx / 2 - 1, celly / 2 + 1 );
|
|
hb_bm_line( cellx / 2 - 1, celly / 2 + 1, 0, celly / 2 + 1 );
|
|
hb_bm_line( cellx / 2 + 1, celly - 1, cellx / 2 + 1, celly / 2 - 1 );
|
|
hb_bm_line( cellx / 2 + 1, celly / 2 - 1, 0, celly / 2 - 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_DBL_LB:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx / 2 - 1, 0, cellx / 2 - 1, celly / 2 + 1 );
|
|
hb_bm_line( cellx / 2 - 1, celly / 2 + 1, cellx - 1, celly / 2 + 1 );
|
|
hb_bm_line( cellx / 2 + 1, 0, cellx / 2 + 1, celly / 2 - 1 );
|
|
hb_bm_line( cellx / 2 + 1, celly / 2 - 1, cellx - 1, celly / 2 - 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_DBL_BU:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( 0, celly / 2 + 1, cellx - 1, celly / 2 + 1 );
|
|
hb_bm_line( 0, celly / 2 - 1, cellx / 2 - 1, celly / 2 - 1 );
|
|
hb_bm_line( cellx / 2 + 1, celly / 2 - 1, cellx - 1, celly / 2 - 1 );
|
|
hb_bm_line( cellx / 2 - 1, celly / 2 - 1, cellx / 2 - 1, 0 );
|
|
hb_bm_line( cellx / 2 + 1, celly / 2 - 1, cellx / 2 + 1, 0 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_DBL_RB:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx / 2 - 1, 0, cellx / 2 - 1, celly / 2 - 1 );
|
|
hb_bm_line( cellx / 2 - 1, celly / 2 - 1, 0, celly / 2 - 1 );
|
|
hb_bm_line( cellx / 2 + 1, 0, cellx / 2 + 1, celly / 2 + 1 );
|
|
hb_bm_line( cellx / 2 + 1, celly / 2 + 1, 0, celly / 2 + 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_DBL_VL:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx / 2 - 1, 0, cellx / 2 - 1, celly - 1 );
|
|
hb_bm_line( cellx / 2 + 1, 0, cellx / 2 + 1, celly / 2 - 1 );
|
|
hb_bm_line( cellx / 2 + 1, celly / 2 + 1, cellx / 2 + 1, celly - 1 );
|
|
hb_bm_line( cellx / 2 + 1, celly / 2 - 1, cellx - 1, celly / 2 - 1 );
|
|
hb_bm_line( cellx / 2 + 1, celly / 2 + 1, cellx - 1, celly / 2 + 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_DBL_VR:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx / 2 + 1, 0, cellx / 2 + 1, celly - 1 );
|
|
hb_bm_line( cellx / 2 - 1, 0, cellx / 2 - 1, celly / 2 - 1 );
|
|
hb_bm_line( cellx / 2 - 1, celly / 2 + 1, cellx / 2 - 1, celly - 1 );
|
|
hb_bm_line( cellx / 2 - 1, celly / 2 - 1, 0, celly / 2 - 1 );
|
|
hb_bm_line( cellx / 2 - 1, celly / 2 + 1, 0, celly / 2 + 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_DBL_CRS:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx / 2 - 1, 0, cellx / 2 - 1, celly / 2 - 1 );
|
|
hb_bm_line( cellx / 2 - 1, celly / 2 + 1, cellx / 2 - 1, celly - 1 );
|
|
hb_bm_line( cellx / 2 - 1, celly / 2 - 1, 0, celly / 2 - 1 );
|
|
hb_bm_line( cellx / 2 - 1, celly / 2 + 1, 0, celly / 2 + 1 );
|
|
hb_bm_line( cellx / 2 + 1, 0, cellx / 2 + 1, celly / 2 - 1 );
|
|
hb_bm_line( cellx / 2 + 1, celly / 2 + 1, cellx / 2 + 1, celly - 1 );
|
|
hb_bm_line( cellx / 2 + 1, celly / 2 - 1, cellx - 1, celly / 2 - 1 );
|
|
hb_bm_line( cellx / 2 + 1, celly / 2 + 1, cellx - 1, celly / 2 + 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_DBL_HOR:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( 0, celly / 2 - 1, cellx - 1, celly / 2 - 1 );
|
|
hb_bm_line( 0, celly / 2 + 1, cellx - 1, celly / 2 + 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_DBL_VRT:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx / 2 - 1, 0, cellx / 2 - 1, celly - 1 );
|
|
hb_bm_line( cellx / 2 + 1, 0, cellx / 2 + 1, celly - 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_SNG_L_DBL_T:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx / 2, celly / 2 - 1, cellx - 1, celly / 2 - 1 );
|
|
hb_bm_line( cellx / 2, celly / 2 + 1, cellx - 1, celly / 2 + 1 );
|
|
hb_bm_line( cellx / 2, celly / 2 - 1, cellx / 2, celly - 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_SNG_T_DBL_D:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( 0, celly / 2, cellx - 1, celly / 2 );
|
|
hb_bm_line( cellx / 2 - 1, celly / 2, cellx / 2 - 1, celly - 1 );
|
|
hb_bm_line( cellx / 2 + 1, celly / 2, cellx / 2 + 1, celly - 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_SNG_R_DBL_T:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( 0, celly / 2, cellx / 2 + 1, celly / 2 );
|
|
hb_bm_line( cellx / 2 - 1, celly / 2, cellx / 2 - 1, celly - 1 );
|
|
hb_bm_line( cellx / 2 + 1, celly / 2, cellx / 2 + 1, celly - 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_SNG_L_DBL_B:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx / 2, celly / 2 - 1, cellx - 1, celly / 2 - 1 );
|
|
hb_bm_line( cellx / 2, celly / 2 + 1, cellx - 1, celly / 2 + 1 );
|
|
hb_bm_line( cellx / 2, 0, cellx / 2, celly / 2 + 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_SNG_B_DBL_U:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( 0, celly / 2, cellx - 1, celly / 2 );
|
|
hb_bm_line( cellx / 2 - 1, 0, cellx / 2 - 1, celly / 2 );
|
|
hb_bm_line( cellx / 2 + 1, 0, cellx / 2 + 1, celly / 2 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_SNG_R_DBL_B:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( 0, celly / 2, cellx / 2 + 1, celly / 2 );
|
|
hb_bm_line( cellx / 2 - 1, 0, cellx / 2 - 1, celly / 2 );
|
|
hb_bm_line( cellx / 2 + 1, 0, cellx / 2 + 1, celly / 2 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_SNG_V_DBL_L:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx / 2, 0, cellx / 2, celly - 1 );
|
|
hb_bm_line( cellx / 2, celly / 2 - 1, cellx - 1, celly / 2 - 1 );
|
|
hb_bm_line( cellx / 2, celly / 2 + 1, cellx - 1, celly / 2 + 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_SNG_V_DBL_R:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx / 2, 0, cellx / 2, celly - 1 );
|
|
hb_bm_line( 0, celly / 2 - 1, cellx / 2, celly / 2 - 1 );
|
|
hb_bm_line( 0, celly / 2 + 1, cellx / 2, celly / 2 + 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_SNG_DBL_CRS:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx / 2, 0, cellx / 2, celly - 1 );
|
|
hb_bm_line( 0, celly / 2 - 1, cellx - 1, celly / 2 - 1 );
|
|
hb_bm_line( 0, celly / 2 + 1, cellx - 1, celly / 2 + 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_DBL_L_SNG_T:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx / 2 - 1, celly / 2, cellx / 2 - 1, celly - 1 );
|
|
hb_bm_line( cellx / 2 + 1, celly / 2, cellx / 2 + 1, celly - 1 );
|
|
hb_bm_line( cellx / 2 - 1, celly / 2, cellx - 1, celly / 2 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_DBL_T_SNG_D:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( 0, celly / 2 - 1, cellx - 1, celly / 2 - 1 );
|
|
hb_bm_line( 0, celly / 2 + 1, cellx - 1, celly / 2 + 1 );
|
|
hb_bm_line( cellx / 2, celly / 2 + 1, cellx / 2, celly - 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_DBL_R_SNG_T:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( 0, celly / 2 - 1, cellx / 2, celly / 2 - 1 );
|
|
hb_bm_line( 0, celly / 2 + 1, cellx / 2, celly / 2 + 1 );
|
|
hb_bm_line( cellx / 2, celly / 2 - 1, cellx / 2, celly - 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_DBL_L_SNG_B:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx / 2 - 1, 0, cellx / 2 - 1, celly / 2 );
|
|
hb_bm_line( cellx / 2 + 1, 0, cellx / 2 + 1, celly / 2 );
|
|
hb_bm_line( cellx / 2 - 1, celly / 2, cellx - 1, celly / 2 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_DBL_B_SNG_U:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( 0, celly / 2 - 1, cellx - 1, celly / 2 - 1 );
|
|
hb_bm_line( 0, celly / 2 + 1, cellx - 1, celly / 2 + 1 );
|
|
hb_bm_line( cellx / 2, 0, cellx / 2, celly / 2 - 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_DBL_R_SNG_B:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( 0, celly / 2 - 1, cellx / 2, celly / 2 - 1 );
|
|
hb_bm_line( 0, celly / 2 + 1, cellx / 2, celly / 2 + 1 );
|
|
hb_bm_line( cellx / 2, 0, cellx / 2, celly / 2 + 1 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_DBL_V_SNG_L:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx / 2 - 1, 0, cellx / 2 - 1, celly - 1 );
|
|
hb_bm_line( cellx / 2 + 1, 0, cellx / 2 + 1, celly - 1 );
|
|
hb_bm_line( cellx / 2 + 1, celly / 2, cellx - 1, celly / 2 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_DBL_V_SNG_R:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx / 2 - 1, 0, cellx / 2 - 1, celly - 1 );
|
|
hb_bm_line( cellx / 2 + 1, 0, cellx / 2 + 1, celly - 1 );
|
|
hb_bm_line( 0, celly / 2, cellx / 2 - 1, celly / 2 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_DBL_SNG_CRS:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
hb_bm_line( cellx / 2 - 1, 0, cellx / 2 - 1, celly - 1 );
|
|
hb_bm_line( cellx / 2 + 1, 0, cellx / 2 + 1, celly - 1 );
|
|
hb_bm_line( 0, celly / 2, cellx - 1, celly / 2 );
|
|
hb_bm_paint_end();
|
|
break;
|
|
|
|
case HB_BOXCH_SQUARE:
|
|
qBitMap = hb_gt_qtc_bitmap_char( cellx, celly );
|
|
hb_bm_paint_begin( qBitMap );
|
|
xx = yy = cellx - HB_MAX( cellx >> 2, 2 );
|
|
hb_bm_fillrect( ( cellx - xx ) >> 1, ( celly - yy ) >> 1, xx, yy );
|
|
hb_bm_paint_end();
|
|
break;
|
|
}
|
|
|
|
return qBitMap;
|
|
}
|
|
|
|
static QBitmap * hb_gt_qtc_getBoxChar( PHB_GTQTC pQTC, HB_USHORT * puc16 )
|
|
{
|
|
HB_USHORT uc16 = *puc16;
|
|
int iPos, iTrans;
|
|
|
|
if( ( pQTC->fontAttribute & HB_GTI_FONTA_DRAWBOX ) == 0 )
|
|
return NULL;
|
|
|
|
if( uc16 >= HB_BOXCH_RC_0 && uc16 <= HB_BOXCH_RC_ACC )
|
|
{
|
|
switch( uc16 )
|
|
{
|
|
case HB_BOXCH_RC_0:
|
|
*puc16 = '0';
|
|
break;
|
|
case HB_BOXCH_RC_1:
|
|
*puc16 = '1';
|
|
break;
|
|
case HB_BOXCH_RC_2:
|
|
*puc16 = '2';
|
|
break;
|
|
case HB_BOXCH_RC_3:
|
|
*puc16 = '3';
|
|
break;
|
|
case HB_BOXCH_RC_4:
|
|
*puc16 = '4';
|
|
break;
|
|
case HB_BOXCH_RC_5:
|
|
*puc16 = '5';
|
|
break;
|
|
case HB_BOXCH_RC_6:
|
|
*puc16 = '6';
|
|
break;
|
|
case HB_BOXCH_RC_7:
|
|
*puc16 = '7';
|
|
break;
|
|
case HB_BOXCH_RC_8:
|
|
*puc16 = '8';
|
|
break;
|
|
case HB_BOXCH_RC_9:
|
|
*puc16 = '9';
|
|
break;
|
|
case HB_BOXCH_RC_DOT:
|
|
*puc16 = '.';
|
|
break;
|
|
case HB_BOXCH_RC_ACC:
|
|
*puc16 = '\'';
|
|
break;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
if ( uc16 == HB_BOXCH_ARROW_R )
|
|
iPos = 0;
|
|
else if( uc16 == HB_BOXCH_ARROW_L )
|
|
iPos = 1;
|
|
else if( uc16 == HB_BOXCH_ARROW_U )
|
|
iPos = 2;
|
|
else if( uc16 == HB_BOXCH_ARROW_D )
|
|
iPos = 3;
|
|
else if( uc16 >= HB_BOXCH_BOX_MIN && uc16 <= HB_BOXCH_BOX_MAX )
|
|
iPos = HB_BOXCH_CHR_BASE +
|
|
( uc16 - HB_BOXCH_BOX_MIN );
|
|
else if( uc16 >= HB_BOXCH_RC_MIN && uc16 <= HB_BOXCH_RC_MAX )
|
|
iPos = HB_BOXCH_CHR_BASE + ( HB_BOXCH_BOX_MAX - HB_BOXCH_BOX_MIN + 1 ) +
|
|
( uc16 - HB_BOXCH_RC_MIN );
|
|
else
|
|
return NULL;
|
|
|
|
iTrans = pQTC->boxIndex[ iPos ];
|
|
if( iTrans == HB_BOXCH_TRANS_MAX )
|
|
{
|
|
if( pQTC->boxCount < HB_BOXCH_TRANS_MAX - 1 )
|
|
{
|
|
iTrans = pQTC->boxCount + 1;
|
|
pQTC->boxImage[ iTrans ] = hb_gt_qtc_defineBoxChar( pQTC, uc16 );
|
|
if( pQTC->boxImage[ iTrans ] )
|
|
pQTC->boxCount = iTrans;
|
|
else
|
|
iTrans = 0;
|
|
}
|
|
else
|
|
iTrans = 0;
|
|
pQTC->boxIndex[ iPos ] = iTrans;
|
|
}
|
|
|
|
return pQTC->boxImage[ iTrans ];
|
|
}
|
|
|
|
static void hb_gt_qtc_resetBoxCharBitmaps( PHB_GTQTC pQTC )
|
|
{
|
|
int i;
|
|
|
|
for( i = 1; i <= pQTC->boxCount; i++ )
|
|
delete pQTC->boxImage[ i ];
|
|
|
|
memset( pQTC->boxImage, 0, sizeof( pQTC->boxImage ) );
|
|
pQTC->boxCount = 0;
|
|
|
|
for( i = 0; i < HB_BOXCH_TRANS_COUNT; ++i )
|
|
pQTC->boxIndex[ i ] = HB_BOXCH_TRANS_MAX;
|
|
}
|
|
|
|
/* --- */
|
|
|
|
static void hb_gt_qtc_free( PHB_GTQTC pQTC )
|
|
{
|
|
if( pQTC->qEventLoop )
|
|
{
|
|
pQTC->qEventLoop->exit();
|
|
delete pQTC->qEventLoop;
|
|
}
|
|
|
|
if( pQTC->qWnd )
|
|
delete pQTC->qWnd;
|
|
|
|
hb_gt_qtc_resetBoxCharBitmaps( pQTC );
|
|
|
|
if( pQTC->fontName )
|
|
delete pQTC->fontName;
|
|
|
|
if( pQTC->wndTitle )
|
|
delete pQTC->wndTitle;
|
|
|
|
if( pQTC->qIcon )
|
|
delete pQTC->qIcon;
|
|
|
|
if( pQTC->textLine )
|
|
hb_xfree( pQTC->textLine );
|
|
|
|
hb_xfree( pQTC );
|
|
}
|
|
|
|
static PHB_GTQTC hb_gt_qtc_new( PHB_GT pGT )
|
|
{
|
|
PHB_GTQTC pQTC;
|
|
|
|
pQTC = static_cast< PHB_GTQTC >( hb_xgrabz( sizeof( HB_GTQTC ) ) );
|
|
pQTC->pGT = pGT;
|
|
|
|
pQTC->colors[ 0 ] = BLACK;
|
|
pQTC->colors[ 1 ] = BLUE;
|
|
pQTC->colors[ 2 ] = GREEN;
|
|
pQTC->colors[ 3 ] = CYAN;
|
|
pQTC->colors[ 4 ] = RED;
|
|
pQTC->colors[ 5 ] = MAGENTA;
|
|
pQTC->colors[ 6 ] = BROWN;
|
|
pQTC->colors[ 7 ] = LIGHT_GRAY;
|
|
pQTC->colors[ 8 ] = GRAY;
|
|
pQTC->colors[ 9 ] = BRIGHT_BLUE;
|
|
pQTC->colors[ 10 ] = BRIGHT_GREEN;
|
|
pQTC->colors[ 11 ] = BRIGHT_CYAN;
|
|
pQTC->colors[ 12 ] = BRIGHT_RED;
|
|
pQTC->colors[ 13 ] = BRIGHT_MAGENTA;
|
|
pQTC->colors[ 14 ] = YELLOW;
|
|
pQTC->colors[ 15 ] = WHITE;
|
|
|
|
pQTC->iRows = QTC_DEFAULT_ROWS;
|
|
pQTC->iCols = QTC_DEFAULT_COLS;
|
|
|
|
pQTC->textLine = static_cast< QChar * >( hb_xgrab( pQTC->iCols * sizeof( QChar ) ) );
|
|
|
|
pQTC->iNewPosX = -1;
|
|
pQTC->iNewPosY = -1;
|
|
|
|
pQTC->fontWidth = QTC_DEFAULT_FONT_WIDTH;
|
|
pQTC->fontHeight = QTC_DEFAULT_FONT_HEIGHT;
|
|
pQTC->fontWeight = QTC_DEFAULT_FONT_WEIGHT;
|
|
pQTC->fontAttribute = QTC_DEFAULT_FONT_ATTRIBUTE;
|
|
pQTC->fontAscent = 0;
|
|
pQTC->fontName = new QString( QTC_DEFAULT_FONT_NAME );
|
|
pQTC->cellY = pQTC->fontHeight;
|
|
pQTC->cellX = pQTC->fontWidth == 0 ? pQTC->cellY / 2: pQTC->fontWidth;
|
|
pQTC->iCloseMode = 0;
|
|
pQTC->iResizeMode = HB_GTI_RESIZEMODE_FONT;
|
|
pQTC->fResizable = HB_TRUE;
|
|
pQTC->fResizeInc = HB_FALSE;
|
|
pQTC->fAltEnter = HB_FALSE;
|
|
pQTC->fMaximized = HB_FALSE;
|
|
pQTC->fMinimized = HB_FALSE;
|
|
pQTC->fFullScreen = HB_FALSE;
|
|
pQTC->fSelectCopy = HB_FALSE;
|
|
pQTC->fMsgAlert = HB_FALSE;
|
|
pQTC->fRepaint = HB_TRUE;
|
|
|
|
{
|
|
PHB_ITEM pItem = hb_itemPutCPtr( NULL, hb_cmdargBaseProgName() );
|
|
pQTC->wndTitle = new QString();
|
|
hb_gt_qtc_itemGetQString( pItem, pQTC->wndTitle );
|
|
hb_itemRelease( pItem );
|
|
}
|
|
return pQTC;
|
|
}
|
|
|
|
static void hb_gt_qtc_updateCursor( PHB_GTQTC pQTC )
|
|
{
|
|
int cursorType = pQTC->cursorVisible ? pQTC->cursorType : SC_NONE;
|
|
|
|
if( pQTC->lastCursorType != cursorType ||
|
|
pQTC->lastCursorCol != pQTC->cursorCol ||
|
|
pQTC->lastCursorRow != pQTC->cursorRow )
|
|
{
|
|
switch( cursorType )
|
|
{
|
|
case SC_NORMAL:
|
|
pQTC->cursorSize = 2;
|
|
pQTC->cursorOffset = pQTC->cellY - pQTC->cursorSize - 1;
|
|
break;
|
|
case SC_INSERT:
|
|
pQTC->cursorSize = ( pQTC->cellY - 2 ) >> 1;
|
|
pQTC->cursorOffset = pQTC->cellY - pQTC->cursorSize - 1;
|
|
break;
|
|
case SC_SPECIAL1:
|
|
pQTC->cursorSize = pQTC->cellY - 2;
|
|
pQTC->cursorOffset = 1;
|
|
break;
|
|
case SC_SPECIAL2:
|
|
pQTC->cursorSize = ( pQTC->cellY - 2 ) >> 1;
|
|
pQTC->cursorOffset = 1;
|
|
break;
|
|
default:
|
|
pQTC->cursorSize = 0;
|
|
break;
|
|
}
|
|
if( pQTC->lastCursorType != SC_NONE )
|
|
{
|
|
pQTC->qWnd->qConsole->update( pQTC->lastCursorCol * pQTC->cellX + pQTC->marginLeft,
|
|
pQTC->lastCursorRow * pQTC->cellY + pQTC->marginTop,
|
|
pQTC->cellX, pQTC->cellY );
|
|
}
|
|
if( pQTC->cursorSize != 0 &&
|
|
( pQTC->lastCursorType == SC_NONE ||
|
|
pQTC->lastCursorCol != pQTC->cursorCol ||
|
|
pQTC->lastCursorRow != pQTC->cursorRow ) )
|
|
{
|
|
pQTC->qWnd->qConsole->update( pQTC->cursorCol * pQTC->cellX + pQTC->marginLeft,
|
|
pQTC->cursorRow * pQTC->cellY + pQTC->marginTop,
|
|
pQTC->cellX, pQTC->cellY );
|
|
}
|
|
pQTC->lastCursorType = cursorType;
|
|
pQTC->lastCursorCol = pQTC->cursorCol;
|
|
pQTC->lastCursorRow = pQTC->cursorRow;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* functions for handling the input queues for the mouse and keyboard
|
|
*/
|
|
static void hb_gt_qtc_addKeyToInputQueue( PHB_GTQTC pQTC, int iKey )
|
|
{
|
|
int iHead = pQTC->keyHead;
|
|
|
|
if( pQTC->keyHead != pQTC->keyTail )
|
|
{
|
|
if( HB_INKEY_ISMOUSEPOS( iKey ) )
|
|
{
|
|
int iLastKey = pQTC->keyBuffer[ pQTC->keyLast ];
|
|
|
|
/* Clipper strips repeated mouse movemnt - let's do the same */
|
|
if( HB_INKEY_ISMOUSEPOS( iLastKey ) )
|
|
{
|
|
pQTC->keyBuffer[ pQTC->keyLast ] = iKey;
|
|
return;
|
|
}
|
|
}
|
|
else if( iKey == HB_K_RESIZE &&
|
|
iKey == pQTC->keyBuffer[ pQTC->keyLast ] )
|
|
return;
|
|
}
|
|
|
|
/* When the buffer is full new event overwrite the last one
|
|
* in the buffer - it's Clipper behavior [druzus]
|
|
*/
|
|
pQTC->keyBuffer[ pQTC->keyLast = iHead ] = iKey;
|
|
if( ++iHead >= QTC_KEY_QUEUE_SIZE )
|
|
iHead = 0;
|
|
if( iHead != pQTC->keyTail )
|
|
pQTC->keyHead = iHead;
|
|
}
|
|
|
|
static HB_BOOL hb_gt_qtc_getKeyFromInputQueue( PHB_GTQTC pQTC, int * piKey )
|
|
{
|
|
if( pQTC && pQTC->keyTail != pQTC->keyHead )
|
|
{
|
|
*piKey = pQTC->keyBuffer[ pQTC->keyTail ];
|
|
if( ++pQTC->keyTail >= QTC_KEY_QUEUE_SIZE )
|
|
pQTC->keyTail = 0;
|
|
return HB_TRUE;
|
|
}
|
|
*piKey = 0;
|
|
return HB_FALSE;
|
|
}
|
|
|
|
static int hb_gt_qtc_getKbdState( void )
|
|
{
|
|
int iKbdState = 0;
|
|
Qt::KeyboardModifiers kbState = QApplication::keyboardModifiers();
|
|
|
|
if( kbState & Qt::ShiftModifier ) iKbdState |= HB_GTI_KBD_SHIFT;
|
|
if( kbState & Qt::ControlModifier ) iKbdState |= HB_GTI_KBD_CTRL;
|
|
if( kbState & Qt::AltModifier ) iKbdState |= HB_GTI_KBD_ALT;
|
|
|
|
return iKbdState;
|
|
}
|
|
|
|
static int hb_gt_qtc_getKeyFlags( Qt::KeyboardModifiers keyFlags )
|
|
{
|
|
int iFlags = 0;
|
|
|
|
if( keyFlags & Qt::AltModifier ) iFlags |= HB_KF_ALT;
|
|
if( keyFlags & Qt::ControlModifier ) iFlags |= HB_KF_CTRL;
|
|
if( keyFlags & Qt::ShiftModifier ) iFlags |= HB_KF_SHIFT;
|
|
if( keyFlags & Qt::KeypadModifier ) iFlags |= HB_KF_KEYPAD;
|
|
#ifdef HB_OS_DARWIN
|
|
if( keyFlags & Qt::MetaModifier ) iFlags |= HB_KF_CTRL;
|
|
#elif defined( HB_OS_ANDROID )
|
|
if( ( keyFlags & Qt::AltModifier ) != 0 &&
|
|
( keyFlags & Qt::ShiftModifier ) != 0 &&
|
|
( keyFlags & Qt::ControlModifier ) == 0 )
|
|
iFlags = ( iFlags & ~( HB_KF_ALT | HB_KF_SHIFT ) ) | HB_KF_CTRL;
|
|
#endif
|
|
|
|
return iFlags;
|
|
}
|
|
|
|
static void hb_gt_qtc_setMouseKey( PHB_GTQTC pQTC, int x, int y, int iKey,
|
|
Qt::KeyboardModifiers keyFlags )
|
|
{
|
|
x -= pQTC->marginLeft;
|
|
y -= pQTC->marginTop;
|
|
pQTC->mousePosX = x;
|
|
pQTC->mousePosY = y;
|
|
x /= pQTC->cellX;
|
|
y /= pQTC->cellY;
|
|
if( pQTC->mouseCol != x || pQTC->mouseRow != y )
|
|
{
|
|
pQTC->mouseCol = x;
|
|
pQTC->mouseRow = y;
|
|
hb_gt_qtc_addKeyToInputQueue( pQTC, HB_INKEY_NEW_MPOS( x, y ) );
|
|
}
|
|
|
|
if( iKey != 0 )
|
|
{
|
|
int iFlags = hb_gt_qtc_getKeyFlags( keyFlags );
|
|
hb_gt_qtc_addKeyToInputQueue( pQTC, HB_INKEY_NEW_MKEY( iKey, iFlags ) );
|
|
}
|
|
}
|
|
|
|
static HB_BOOL hb_gt_qtc_setWindowSize( PHB_GTQTC pQTC, int iRows, int iCols )
|
|
{
|
|
if( HB_GTSELF_RESIZE( pQTC->pGT, iRows, iCols ) )
|
|
{
|
|
if( pQTC->iCols != iCols )
|
|
pQTC->textLine = static_cast< QChar * >( hb_xrealloc( pQTC->textLine,
|
|
iCols * sizeof( QChar ) ) );
|
|
|
|
if( pQTC->qWnd && ( iRows != pQTC->iRows || iCols != pQTC->iCols ) )
|
|
hb_gt_qtc_addKeyToInputQueue( pQTC, HB_K_RESIZE );
|
|
|
|
pQTC->iRows = iRows;
|
|
pQTC->iCols = iCols;
|
|
|
|
return HB_TRUE;
|
|
}
|
|
return HB_FALSE;
|
|
}
|
|
|
|
static void hb_gt_qtc_setWindowFlags( PHB_GTQTC pQTC, Qt::WindowFlags flags, HB_BOOL fSet )
|
|
{
|
|
Qt::WindowFlags currFlags = pQTC->qWnd->windowFlags(), newFlags;
|
|
|
|
if( fSet )
|
|
newFlags = currFlags | flags;
|
|
else
|
|
newFlags = currFlags & ~flags;
|
|
|
|
if( newFlags != currFlags )
|
|
{
|
|
pQTC->qWnd->setWindowFlags( newFlags );
|
|
HB_QTC_LOCK();
|
|
pQTC->qWnd->show();
|
|
HB_QTC_UNLOCK();
|
|
}
|
|
}
|
|
|
|
static void hb_gt_qtc_setWindowState( PHB_GTQTC pQTC, Qt::WindowStates state, HB_BOOL fSet, HB_BOOL fShow )
|
|
{
|
|
Qt::WindowStates currState = pQTC->qWnd->windowState(), newState;
|
|
|
|
if( fSet )
|
|
newState = currState | state;
|
|
else
|
|
newState = currState & ~state;
|
|
|
|
if( newState != currState )
|
|
{
|
|
pQTC->qWnd->setWindowState( newState );
|
|
if( fShow )
|
|
{
|
|
HB_QTC_LOCK();
|
|
pQTC->qWnd->show();
|
|
HB_QTC_UNLOCK();
|
|
}
|
|
}
|
|
}
|
|
|
|
static QSize hb_gt_qtc_screenSize( PHB_GTQTC pQTC )
|
|
{
|
|
if( pQTC->qWnd )
|
|
{
|
|
#if QT_VERSION >= 0x050E00
|
|
/* return pQTC->qWnd->screen()->availableSize(); */
|
|
return pQTC->qWnd->screen()->size();
|
|
#else
|
|
/* return QApplication::desktop()->availableGeometry( pQTC->qWnd ).size(); */
|
|
return QApplication::desktop()->screenGeometry( pQTC->qWnd ).size();
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
#if QT_VERSION >= 0x050600
|
|
/* return QGuiApplication::primaryScreen()->availableSize(); */
|
|
return QGuiApplication::primaryScreen()->size();
|
|
#else
|
|
/* return QApplication::desktop()->availableGeometry().size(); */
|
|
return QApplication::desktop()->screenGeometry().size();
|
|
#endif
|
|
}
|
|
}
|
|
|
|
static void hb_gt_qtc_initWindow( PHB_GTQTC pQTC, HB_BOOL fCenter )
|
|
{
|
|
pQTC->qWnd->qConsole->resetWindowSize();
|
|
if( fCenter || pQTC->iNewPosX < 0 || pQTC->iNewPosY < 0 )
|
|
{
|
|
#if QT_VERSION >= 0x050E00
|
|
QRect rc( pQTC->qWnd->screen()->availableGeometry() );
|
|
#else
|
|
QRect rc( QApplication::desktop()->availableGeometry( pQTC->qWnd ) );
|
|
#endif
|
|
|
|
pQTC->iNewPosX = rc.left() + ( ( rc.width() - pQTC->qWnd->width() ) >> 1 );
|
|
pQTC->iNewPosY = rc.top() + ( ( rc.height() - pQTC->qWnd->height() ) >> 1 );
|
|
}
|
|
/* initial moving fulscreen or maximized window in MS-Windows
|
|
* disables this modes [druzus]
|
|
*/
|
|
if( ( pQTC->qWnd->windowState() & ( Qt::WindowMaximized | Qt::WindowFullScreen ) ) == 0 )
|
|
pQTC->qWnd->move( pQTC->iNewPosX, pQTC->iNewPosY );
|
|
}
|
|
|
|
static void hb_gt_qtc_createConsoleWindow( PHB_GTQTC pQTC )
|
|
{
|
|
pQTC->qWnd = new QTCWindow( pQTC );
|
|
if( ! pQTC->qWnd )
|
|
hb_errInternal( 10002, "Failed to create QTC window", NULL, NULL );
|
|
|
|
hb_gt_qtc_initWindow( pQTC, HB_FALSE );
|
|
|
|
HB_QTC_LOCK();
|
|
pQTC->qWnd->show();
|
|
HB_QTC_UNLOCK();
|
|
pQTC->qWnd->update();
|
|
}
|
|
|
|
static int hb_gt_qtc_messageBox( PHB_GTQTC pQTC, PHB_ITEM pText, PHB_ITEM pButtons, double dDelay )
|
|
{
|
|
int iRet = 0;
|
|
|
|
if( pText )
|
|
{
|
|
QMessageBox qMsg( pQTC->qWnd );
|
|
QString qStr;
|
|
PHB_ITEM pTitle, pInfoText, pDetailed;
|
|
int iLen;
|
|
|
|
pTitle = pInfoText = pDetailed = NULL;
|
|
|
|
if( HB_IS_HASH( pText ) )
|
|
{
|
|
if( ! pButtons || ! HB_IS_ARRAY( pButtons ) )
|
|
pButtons = hb_hashGetCItemPtr( pText, "BTN" );
|
|
if( dDelay <= 0 )
|
|
{
|
|
PHB_ITEM pVal = hb_hashGetCItemPtr( pText, "TIM" );
|
|
if( pVal && HB_IS_NUMERIC( pVal ) )
|
|
dDelay = hb_itemGetND( pVal );
|
|
}
|
|
pTitle = hb_hashGetCItemPtr( pText, "TIT" );
|
|
pInfoText = hb_hashGetCItemPtr( pText, "INF" );
|
|
pDetailed = hb_hashGetCItemPtr( pText, "DTL" );
|
|
pText = hb_hashGetCItemPtr( pText, "TXT" );
|
|
}
|
|
|
|
if( pTitle && HB_IS_STRING( pTitle ) )
|
|
{
|
|
hb_gt_qtc_itemGetQString( pTitle, &qStr );
|
|
qMsg.setWindowTitle( qStr );
|
|
}
|
|
else if( ! pQTC->wndTitle->isNull() )
|
|
qMsg.setWindowTitle( *pQTC->wndTitle );
|
|
if( pText && HB_IS_STRING( pText ) )
|
|
{
|
|
hb_gt_qtc_itemGetQString( pText, &qStr );
|
|
qMsg.setText( qStr );
|
|
}
|
|
if( pInfoText && HB_IS_STRING( pInfoText ) )
|
|
{
|
|
hb_gt_qtc_itemGetQString( pInfoText, &qStr );
|
|
qMsg.setInformativeText( qStr );
|
|
}
|
|
if( pDetailed && HB_IS_STRING( pDetailed ) )
|
|
{
|
|
hb_gt_qtc_itemGetQString( pDetailed, &qStr );
|
|
qMsg.setDetailedText( qStr );
|
|
}
|
|
if( pButtons && HB_IS_ARRAY( pButtons ) &&
|
|
( iLen = ( int ) hb_arrayLen( pButtons ) ) > 0 )
|
|
{
|
|
int i;
|
|
|
|
#if defined( HB_OS_ANDROID )
|
|
qputenv( "QT_USE_ANDROID_NATIVE_DIALOGS", "0" );
|
|
#endif
|
|
|
|
for( i = 1; i <= iLen; ++i )
|
|
{
|
|
PHB_ITEM pItem = hb_arrayGetItemPtr( pButtons, i );
|
|
|
|
if( HB_IS_STRING( pItem ) )
|
|
{
|
|
hb_gt_qtc_itemGetQString( pItem, &qStr );
|
|
qMsg.addButton( qStr, QMessageBox::ActionRole );
|
|
}
|
|
}
|
|
}
|
|
|
|
QAction * act = new QAction( &qMsg );
|
|
act->setShortcut( Qt::Key_Escape );
|
|
qMsg.connect( act, SIGNAL( triggered( bool ) ), SLOT( reject() ) );
|
|
qMsg.addAction( act );
|
|
|
|
if( dDelay * 100 >= 1 )
|
|
QTimer::singleShot( ( int ) ( dDelay * 1000 ), &qMsg, SLOT( reject() ) );
|
|
|
|
qMsg.exec();
|
|
|
|
iRet = qMsg.buttons().indexOf( qMsg.clickedButton() ) + 1;
|
|
}
|
|
|
|
return iRet;
|
|
}
|
|
|
|
/* --- */
|
|
|
|
static void hb_gt_qtc_InitMT( void );
|
|
|
|
static void hb_gt_qtc_Init( PHB_GT pGT, HB_FHANDLE hFilenoStdin, HB_FHANDLE hFilenoStdout, HB_FHANDLE hFilenoStderr )
|
|
{
|
|
PHB_GTQTC pQTC;
|
|
|
|
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_qtc_Init(%p,%p,%p,%p)", pGT, ( void * ) ( HB_PTRUINT ) hFilenoStdin, ( void * ) ( HB_PTRUINT ) hFilenoStdout, ( void * ) ( HB_PTRUINT ) hFilenoStderr ) );
|
|
|
|
if( ! s_qtapp )
|
|
{
|
|
hb_gt_qtc_InitMT();
|
|
|
|
s_qtapp = qApp;
|
|
if( ! s_qtapp )
|
|
{
|
|
/* QT requires these variables to be valid for whole application life
|
|
* so we have to declare them as static [druzus]
|
|
*/
|
|
static char ** s_argv;
|
|
static int s_argc;
|
|
|
|
s_argc = hb_cmdargARGC();
|
|
s_argv = hb_cmdargARGV();
|
|
|
|
s_qtapp = new QApplication( s_argc, s_argv );
|
|
if( ! s_qtapp )
|
|
hb_errInternal( 10001, "QT initialization error.", NULL, NULL );
|
|
|
|
hb_vmAtQuit( hb_gt_qtc_appFree, NULL );
|
|
hb_cmdargInit( s_argc, s_argv );
|
|
}
|
|
}
|
|
|
|
pQTC = hb_gt_qtc_new( pGT );
|
|
HB_GTLOCAL( pGT ) = static_cast< void * >( pQTC );
|
|
|
|
if( ! pQTC->qEventLoop )
|
|
pQTC->qEventLoop = new QEventLoop();
|
|
|
|
/* SUPER GT initialization */
|
|
HB_GTSUPER_INIT( pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr );
|
|
HB_GTSELF_RESIZE( pGT, pQTC->iRows, pQTC->iCols );
|
|
HB_GTSELF_SETFLAG( pGT, HB_GTI_REDRAWMAX, 1 );
|
|
HB_GTSELF_SEMICOLD( pGT );
|
|
}
|
|
|
|
/* --- */
|
|
|
|
static void hb_gt_qtc_Exit( PHB_GT pGT )
|
|
{
|
|
PHB_GTQTC pQTC;
|
|
|
|
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_qtc_Exit(%p)", ( void * ) pGT ) );
|
|
|
|
pQTC = HB_GTQTC_GET( pGT );
|
|
HB_GTSUPER_EXIT( pGT );
|
|
|
|
if( pQTC )
|
|
hb_gt_qtc_free( pQTC );
|
|
}
|
|
|
|
/* --- */
|
|
|
|
static void hb_gt_qtc_Redraw( PHB_GT pGT, int iRow, int iCol, int iSize )
|
|
{
|
|
PHB_GTQTC pQTC;
|
|
|
|
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_qtc_Redraw(%p,%d,%d,%d)", ( void * ) pGT, iRow, iCol, iSize ) );
|
|
|
|
pQTC = HB_GTQTC_GET( pGT );
|
|
if( pQTC )
|
|
{
|
|
if( !pQTC->qWnd )
|
|
hb_gt_qtc_createConsoleWindow( pQTC );
|
|
|
|
pQTC->qWnd->qConsole->repaintChars( QRect( iCol * pQTC->cellX,
|
|
iRow * pQTC->cellY,
|
|
iSize * pQTC->cellX,
|
|
pQTC->cellY ) );
|
|
}
|
|
}
|
|
|
|
/* --- */
|
|
|
|
static void hb_gt_qtc_Refresh( PHB_GT pGT )
|
|
{
|
|
PHB_GTQTC pQTC;
|
|
|
|
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_qtc_Refresh(%p)", ( void * ) pGT ) );
|
|
|
|
HB_GTSUPER_REFRESH( pGT );
|
|
|
|
pQTC = HB_GTQTC_GET( pGT );
|
|
if( pQTC )
|
|
{
|
|
HB_GTSELF_GETSCRCURSOR( pGT, &pQTC->cursorRow, &pQTC->cursorCol,
|
|
&pQTC->cursorType );
|
|
if( pQTC->qWnd )
|
|
hb_gt_qtc_updateCursor( pQTC );
|
|
}
|
|
}
|
|
|
|
/* --- */
|
|
|
|
static HB_BOOL hb_gt_qtc_SetMode( PHB_GT pGT, int iRows, int iCols )
|
|
{
|
|
PHB_GTQTC pQTC;
|
|
HB_BOOL fResult, fCenter;
|
|
|
|
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_qtc_SetMode(%p,%d,%d)", ( void * ) pGT, iRows, iCols ) );
|
|
|
|
pQTC = HB_GTQTC_GET( pGT );
|
|
fCenter = iRows != pQTC->iRows || iCols != pQTC->iCols;
|
|
fResult = hb_gt_qtc_setWindowSize( pQTC, iRows, iCols );
|
|
if( fResult )
|
|
{
|
|
if( pQTC->qWnd )
|
|
{
|
|
hb_gt_qtc_initWindow( pQTC, fCenter );
|
|
HB_GTSELF_REFRESH( pGT );
|
|
}
|
|
else
|
|
HB_GTSELF_SEMICOLD( pGT );
|
|
}
|
|
|
|
return fResult;
|
|
}
|
|
|
|
/* --- */
|
|
|
|
static const char * hb_gt_qtc_Version( PHB_GT pGT, int iType )
|
|
{
|
|
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_qtc_Version(%p,%d)", ( void * ) pGT, iType ) );
|
|
|
|
HB_SYMBOL_UNUSED( pGT );
|
|
|
|
if( iType == 0 )
|
|
return HB_GT_DRVNAME( HB_GT_NAME );
|
|
else if( iType == 2 )
|
|
{
|
|
static const char * s_pszVersion = NULL;
|
|
static char s_szBuffer[ 12 ];
|
|
if( s_pszVersion == NULL )
|
|
{
|
|
hb_snprintf( s_szBuffer, sizeof( s_szBuffer ), "%d.%d.%d",
|
|
( QT_VERSION >> 16 ) & 0xFF,
|
|
( QT_VERSION >> 8 ) & 0xFF,
|
|
QT_VERSION & 0xFF );
|
|
s_pszVersion = s_szBuffer;
|
|
}
|
|
return s_pszVersion;
|
|
}
|
|
|
|
return "Harbour Terminal: QT GUI console (QTC)";
|
|
}
|
|
|
|
/* --- */
|
|
|
|
static int hb_gt_qtc_ReadKey( PHB_GT pGT, int iEventMask )
|
|
{
|
|
PHB_GTQTC pQTC;
|
|
|
|
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_qtc_ReadKey(%p,%d)", ( void * ) pGT, iEventMask ) );
|
|
|
|
HB_SYMBOL_UNUSED( iEventMask );
|
|
|
|
pQTC = HB_GTQTC_GET( pGT );
|
|
if( pQTC )
|
|
{
|
|
int iKey;
|
|
|
|
HB_QTC_LOCK();
|
|
if( pQTC->qEventLoop )
|
|
pQTC->qEventLoop->processEvents( QEventLoop::AllEvents );
|
|
else
|
|
QApplication::processEvents( QEventLoop::AllEvents );
|
|
HB_QTC_UNLOCK();
|
|
|
|
if( hb_gt_qtc_getKeyFromInputQueue( pQTC, &iKey ) )
|
|
return iKey;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* --- */
|
|
|
|
static void hb_gt_qtc_Tone( PHB_GT pGT, double dFrequency, double dDuration )
|
|
{
|
|
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_qtc_Tone(%p,%lf,%lf)", ( void * ) pGT, dFrequency, dDuration ) );
|
|
|
|
HB_SYMBOL_UNUSED( pGT );
|
|
HB_SYMBOL_UNUSED( dFrequency );
|
|
HB_SYMBOL_UNUSED( dDuration );
|
|
|
|
/* TODO: add support for something more advanced then simple system beep */
|
|
QApplication::beep();
|
|
}
|
|
|
|
/* --- */
|
|
|
|
static HB_BOOL hb_gt_qtc_mouse_IsPresent( PHB_GT pGT )
|
|
{
|
|
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_qtc_mouse_IsPresent(%p)", ( void * ) pGT ) );
|
|
|
|
HB_SYMBOL_UNUSED( pGT );
|
|
|
|
return HB_TRUE;
|
|
}
|
|
|
|
static void hb_gt_qtc_mouse_GetPos( PHB_GT pGT, int * piRow, int * piCol )
|
|
{
|
|
PHB_GTQTC pQTC;
|
|
|
|
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_qtc_mouse_GetPos(%p,%p,%p)", ( void * ) pGT, piRow, piCol ) );
|
|
|
|
pQTC = HB_GTQTC_GET( pGT );
|
|
*piRow = pQTC->mouseRow;
|
|
*piCol = pQTC->mouseCol;
|
|
}
|
|
|
|
static HB_BOOL hb_gt_qtc_mouse_ButtonState( PHB_GT pGT, int iButton )
|
|
{
|
|
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_qtc_mouse_ButtonState(%p,%i)", ( void * ) pGT, iButton ) );
|
|
|
|
HB_SYMBOL_UNUSED( pGT );
|
|
|
|
switch( iButton )
|
|
{
|
|
case 0:
|
|
return ( QApplication::mouseButtons() & Qt::LeftButton ) != 0;
|
|
case 1:
|
|
return ( QApplication::mouseButtons() & Qt::RightButton ) != 0;
|
|
case 2:
|
|
#if QT_VERSION >= 0x060000
|
|
return ( QApplication::mouseButtons() & Qt::MiddleButton ) != 0;
|
|
#else
|
|
return ( QApplication::mouseButtons() & Qt::MidButton ) != 0;
|
|
#endif
|
|
}
|
|
return HB_FALSE;
|
|
}
|
|
|
|
static int hb_gt_qtc_mouse_CountButton( PHB_GT pGT )
|
|
{
|
|
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_qtc_mouse_CountButton(%p)", ( void * ) pGT ) );
|
|
|
|
HB_SYMBOL_UNUSED( pGT );
|
|
|
|
return 3;
|
|
}
|
|
|
|
/* --- */
|
|
|
|
static int hb_gt_qtc_Alert( PHB_GT pGT, PHB_ITEM pMessage, PHB_ITEM pOptions,
|
|
int iClrNorm, int iClrHigh, double dDelay )
|
|
{
|
|
PHB_GTQTC pQTC;
|
|
int iRet;
|
|
|
|
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_qtc_Alert(%p,%p,%p,%d,%d,%f)", ( void * ) pGT, ( void * ) pMessage, ( void * ) pOptions, iClrNorm, iClrHigh, dDelay ) );
|
|
|
|
pQTC = HB_GTQTC_GET( pGT );
|
|
|
|
if( pQTC->fMsgAlert && pMessage &&
|
|
( HB_IS_STRING( pMessage ) || HB_IS_HASH( pMessage ) ) )
|
|
iRet = hb_gt_qtc_messageBox( pQTC, pMessage, pOptions, dDelay );
|
|
else
|
|
iRet = HB_GTSUPER_ALERT( pGT, pMessage, pOptions, iClrNorm, iClrHigh, dDelay );
|
|
|
|
return iRet;
|
|
}
|
|
|
|
static HB_BOOL hb_gt_qtc_Info( PHB_GT pGT, int iType, PHB_GT_INFO pInfo )
|
|
{
|
|
PHB_GTQTC pQTC;
|
|
int iVal;
|
|
|
|
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_qtc_Info(%p,%d,%p)", ( void * ) pGT, iType, ( void * ) pInfo ) );
|
|
|
|
pQTC = HB_GTQTC_GET( pGT );
|
|
|
|
switch( iType )
|
|
{
|
|
case HB_GTI_ISSCREENPOS:
|
|
case HB_GTI_KBDSUPPORT:
|
|
case HB_GTI_ISGRAPHIC:
|
|
case HB_GTI_ISUNICODE:
|
|
pInfo->pResult = hb_itemPutL( pInfo->pResult, HB_TRUE );
|
|
break;
|
|
|
|
case HB_GTI_ONLINE:
|
|
pInfo->pResult = hb_itemPutL( pInfo->pResult, pQTC->qWnd != NULL );
|
|
break;
|
|
|
|
case HB_GTI_FONTSIZE:
|
|
pInfo->pResult = hb_itemPutNI( pInfo->pResult, pQTC->cellY );
|
|
iVal = hb_itemGetNI( pInfo->pNewVal );
|
|
if( iVal > 0 )
|
|
{
|
|
pQTC->fontHeight = iVal;
|
|
if( pQTC->qWnd )
|
|
{
|
|
pQTC->qWnd->qConsole->resetWindowSize();
|
|
HB_GTSELF_REFRESH( pGT );
|
|
}
|
|
}
|
|
break;
|
|
|
|
case HB_GTI_FONTWIDTH:
|
|
pInfo->pResult = hb_itemPutNI( pInfo->pResult, pQTC->cellX );
|
|
iVal = hb_itemGetNI( pInfo->pNewVal );
|
|
if( iVal > 0 )
|
|
/* store font status for next operation on fontsize */
|
|
pQTC->fontWidth = iVal;
|
|
break;
|
|
|
|
case HB_GTI_FONTWEIGHT:
|
|
pInfo->pResult = hb_itemPutNI( pInfo->pResult, pQTC->fontWeight );
|
|
if( hb_itemType( pInfo->pNewVal ) & HB_IT_NUMERIC )
|
|
{
|
|
/* store font status for next operation on fontsize */
|
|
iVal = hb_itemGetNI( pInfo->pNewVal );
|
|
switch( iVal )
|
|
{
|
|
case HB_GTI_FONTW_THIN:
|
|
case HB_GTI_FONTW_NORMAL:
|
|
case HB_GTI_FONTW_BOLD:
|
|
pQTC->fontWeight = iVal;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case HB_GTI_FONTNAME:
|
|
pInfo->pResult = hb_gt_qtc_itemPutQString( pInfo->pResult, pQTC->fontName );
|
|
if( pInfo->pNewVal && HB_IS_STRING( pInfo->pNewVal ) )
|
|
/* store font status for next operation on fontsize */
|
|
hb_gt_qtc_itemGetQString( pInfo->pNewVal, pQTC->fontName );
|
|
break;
|
|
|
|
case HB_GTI_FONTATTRIBUTE:
|
|
pInfo->pResult = hb_itemPutNI( pInfo->pResult, pQTC->fontAttribute );
|
|
if( hb_itemType( pInfo->pNewVal ) & HB_IT_NUMERIC )
|
|
pQTC->fontAttribute = hb_itemGetNI( pInfo->pNewVal ) &
|
|
( HB_GTI_FONTA_FIXMETRIC |
|
|
HB_GTI_FONTA_CLRBKG |
|
|
HB_GTI_FONTA_CTRLCHARS |
|
|
HB_GTI_FONTA_DRAWBOX |
|
|
HB_GTI_FONTA_NOSTRETCH );
|
|
break;
|
|
|
|
case HB_GTI_SCREENHEIGHT:
|
|
pInfo->pResult = hb_itemPutNI( pInfo->pResult, pQTC->cellY * pQTC->iRows );
|
|
iVal = hb_itemGetNI( pInfo->pNewVal );
|
|
if( iVal > 0 )
|
|
HB_GTSELF_SETMODE( pGT, static_cast< HB_USHORT >( iVal / pQTC->cellY ), pQTC->iCols );
|
|
break;
|
|
|
|
case HB_GTI_SCREENWIDTH:
|
|
pInfo->pResult = hb_itemPutNI( pInfo->pResult, pQTC->cellX * pQTC->iCols );
|
|
iVal = hb_itemGetNI( pInfo->pNewVal );
|
|
if( iVal > 0 )
|
|
HB_GTSELF_SETMODE( pGT, pQTC->iRows, static_cast< HB_USHORT >( iVal / pQTC->cellX ) );
|
|
break;
|
|
|
|
case HB_GTI_DESKTOPWIDTH:
|
|
pInfo->pResult = hb_itemPutNI( pInfo->pResult,
|
|
hb_gt_qtc_screenSize( pQTC ).width() );
|
|
break;
|
|
|
|
case HB_GTI_DESKTOPHEIGHT:
|
|
pInfo->pResult = hb_itemPutNI( pInfo->pResult,
|
|
hb_gt_qtc_screenSize( pQTC ).height() );
|
|
break;
|
|
|
|
case HB_GTI_DESKTOPCOLS:
|
|
pInfo->pResult = hb_itemPutNI( pInfo->pResult,
|
|
hb_gt_qtc_screenSize( pQTC ).width() / pQTC->cellX );
|
|
break;
|
|
|
|
case HB_GTI_DESKTOPROWS:
|
|
pInfo->pResult = hb_itemPutNI( pInfo->pResult,
|
|
hb_gt_qtc_screenSize( pQTC ).height() / pQTC->cellY );
|
|
break;
|
|
|
|
case HB_GTI_WINTITLE:
|
|
pInfo->pResult = hb_gt_qtc_itemPutQString( pInfo->pResult, pQTC->wndTitle );
|
|
if( pInfo->pNewVal )
|
|
{
|
|
if( HB_IS_STRING( pInfo->pNewVal ) )
|
|
{
|
|
hb_gt_qtc_itemGetQString( pInfo->pNewVal, pQTC->wndTitle );
|
|
if( pQTC->qWnd )
|
|
pQTC->qWnd->setWindowTitle( *pQTC->wndTitle );
|
|
}
|
|
else if( HB_IS_LOGICAL( pInfo->pNewVal ) )
|
|
{
|
|
pQTC->fNoFrame = hb_itemGetL( pInfo->pNewVal );
|
|
if( pQTC->qWnd )
|
|
{
|
|
Qt::WindowFlags flags = Qt::CustomizeWindowHint;
|
|
|
|
if( pQTC->fNoFrame )
|
|
{
|
|
hb_gt_qtc_setWindowFlags( pQTC, /*Qt::WindowTitleHint |
|
|
Qt::WindowSystemMenuHint |*/
|
|
Qt::WindowMinimizeButtonHint |
|
|
Qt::WindowMaximizeButtonHint |
|
|
Qt::WindowCloseButtonHint, HB_FALSE );
|
|
flags |= Qt::FramelessWindowHint;
|
|
}
|
|
else
|
|
{
|
|
if( pQTC->iCloseMode < 2 )
|
|
flags |= Qt::WindowCloseButtonHint;
|
|
if( pQTC->fResizable )
|
|
flags |= Qt::WindowMaximizeButtonHint;
|
|
flags |= Qt::WindowMinimizeButtonHint;
|
|
}
|
|
hb_gt_qtc_setWindowFlags( pQTC, flags, pQTC->fNoFrame );
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case HB_GTI_ICONFILE:
|
|
if( pInfo->pNewVal && HB_IS_STRING( pInfo->pNewVal ) )
|
|
{
|
|
QString qStr;
|
|
hb_gt_qtc_itemGetQString( pInfo->pNewVal, &qStr );
|
|
if( pQTC->qIcon )
|
|
delete pQTC->qIcon;
|
|
pQTC->qIcon = new QIcon( qStr );
|
|
if( pQTC->qWnd )
|
|
pQTC->qWnd->setWindowIcon( *pQTC->qIcon );
|
|
}
|
|
break;
|
|
|
|
case HB_GTI_KBDSHIFTS:
|
|
pInfo->pResult = hb_itemPutNI( pInfo->pResult, hb_gt_qtc_getKbdState() );
|
|
break;
|
|
|
|
case HB_GTI_CURSORBLINKRATE:
|
|
pInfo->pResult = hb_itemPutNI( pInfo->pResult, QApplication::cursorFlashTime() );
|
|
if( pInfo->pNewVal && HB_IS_NUMERIC( pInfo->pNewVal ) )
|
|
{
|
|
iVal = hb_itemGetNI( pInfo->pNewVal );
|
|
if( iVal < 0 )
|
|
iVal = 0;
|
|
QApplication::setCursorFlashTime( iVal );
|
|
if( pQTC->qWnd )
|
|
{
|
|
if( pQTC->qWnd->qConsole->timer->isActive() )
|
|
pQTC->qWnd->qConsole->timer->stop();
|
|
if( QApplication::cursorFlashTime() / 2 > 0 )
|
|
pQTC->qWnd->qConsole->timer->start( QApplication::cursorFlashTime() / 2, pQTC->qWnd->qConsole );
|
|
}
|
|
}
|
|
break;
|
|
|
|
case HB_GTI_CLIPBOARDDATA:
|
|
{
|
|
QString qStr = QApplication::clipboard()->text();
|
|
if( qStr.isEmpty() && QApplication::clipboard()->supportsSelection() )
|
|
{
|
|
qStr = QApplication::clipboard()->text( QClipboard::Selection );
|
|
if( qStr.isEmpty() && QApplication::clipboard()->supportsFindBuffer() )
|
|
qStr = QApplication::clipboard()->text( QClipboard::FindBuffer );
|
|
}
|
|
pInfo->pResult = hb_gt_qtc_itemPutQString( pInfo->pResult, &qStr );
|
|
if( pInfo->pNewVal && HB_IS_STRING( pInfo->pNewVal ) )
|
|
{
|
|
hb_gt_qtc_itemGetQString( pInfo->pNewVal, &qStr );
|
|
QApplication::clipboard()->setText( qStr );
|
|
if( QApplication::clipboard()->supportsSelection() )
|
|
QApplication::clipboard()->setText( qStr, QClipboard::Selection );
|
|
}
|
|
break;
|
|
}
|
|
case HB_GTI_SCREENSIZE:
|
|
if( ! pInfo->pResult )
|
|
pInfo->pResult = hb_itemNew( NULL );
|
|
|
|
hb_arrayNew( pInfo->pResult, 2 );
|
|
hb_arraySetNI( pInfo->pResult, 2, pQTC->cellY * pQTC->iRows );
|
|
hb_arraySetNI( pInfo->pResult, 1, pQTC->cellX * pQTC->iCols );
|
|
break;
|
|
|
|
case HB_GTI_MAXIMIZED:
|
|
if( pQTC->qWnd )
|
|
pQTC->fMaximized = ( pQTC->qWnd->windowState() & Qt::WindowMaximized ) != 0;
|
|
pInfo->pResult = hb_itemPutL( pInfo->pResult, pQTC->fMaximized );
|
|
if( pInfo->pNewVal && HB_IS_LOGICAL( pInfo->pNewVal ) &&
|
|
( hb_itemGetL( pInfo->pNewVal ) ? ! pQTC->fMaximized : pQTC->fMaximized ) )
|
|
{
|
|
pQTC->fMaximized = ! pQTC->fMaximized;
|
|
if( pQTC->qWnd )
|
|
hb_gt_qtc_setWindowState( pQTC, Qt::WindowMaximized, pQTC->fMaximized, HB_TRUE );
|
|
}
|
|
break;
|
|
|
|
case HB_GTI_ISFULLSCREEN:
|
|
if( pQTC->qWnd )
|
|
pQTC->fFullScreen = ( pQTC->qWnd->windowState() & Qt::WindowFullScreen ) != 0;
|
|
pInfo->pResult = hb_itemPutL( pInfo->pResult, pQTC->fFullScreen );
|
|
if( pInfo->pNewVal && HB_IS_LOGICAL( pInfo->pNewVal ) &&
|
|
( hb_itemGetL( pInfo->pNewVal ) ? ! pQTC->fFullScreen : pQTC->fFullScreen ) )
|
|
{
|
|
pQTC->fFullScreen = ! pQTC->fFullScreen;
|
|
if( pQTC->qWnd )
|
|
hb_gt_qtc_setWindowState( pQTC, Qt::WindowFullScreen, pQTC->fFullScreen, HB_TRUE );
|
|
}
|
|
break;
|
|
|
|
case HB_GTI_ALTENTER:
|
|
pInfo->pResult = hb_itemPutL( pInfo->pResult, pQTC->fAltEnter );
|
|
if( pInfo->pNewVal && HB_IS_LOGICAL( pInfo->pNewVal ) )
|
|
pQTC->fAltEnter = hb_itemGetL( pInfo->pNewVal );
|
|
break;
|
|
|
|
case HB_GTI_MINIMIZED:
|
|
if( pQTC->qWnd )
|
|
pQTC->fMinimized = ( pQTC->qWnd->windowState() & Qt::WindowMinimized ) != 0;
|
|
pInfo->pResult = hb_itemPutL( pInfo->pResult, pQTC->fMinimized );
|
|
if( pInfo->pNewVal && HB_IS_LOGICAL( pInfo->pNewVal ) &&
|
|
( hb_itemGetL( pInfo->pNewVal ) ? ! pQTC->fMinimized : pQTC->fMinimized ) )
|
|
{
|
|
pQTC->fMinimized = ! pQTC->fMinimized;
|
|
if( pQTC->qWnd )
|
|
hb_gt_qtc_setWindowState( pQTC, Qt::WindowMinimized, pQTC->fMinimized, ! pQTC->fMinimized );
|
|
}
|
|
break;
|
|
|
|
case HB_GTI_CLOSABLE:
|
|
pInfo->pResult = hb_itemPutL( pInfo->pResult, pQTC->iCloseMode == 0 );
|
|
if( pInfo->pNewVal && HB_IS_LOGICAL( pInfo->pNewVal ) &&
|
|
( hb_itemGetL( pInfo->pNewVal ) ? ( pQTC->iCloseMode != 0 ) :
|
|
( pQTC->iCloseMode == 0 ) ) )
|
|
{
|
|
iVal = pQTC->iCloseMode;
|
|
pQTC->iCloseMode = iVal == 0 ? 1 : 0;
|
|
if( pQTC->qWnd )
|
|
hb_gt_qtc_setWindowFlags( pQTC, Qt::WindowCloseButtonHint, pQTC->iCloseMode < 2 );
|
|
}
|
|
break;
|
|
|
|
case HB_GTI_CLOSEMODE:
|
|
pInfo->pResult = hb_itemPutNI( pInfo->pResult, pQTC->iCloseMode );
|
|
if( pInfo->pNewVal && HB_IS_NUMERIC( pInfo->pNewVal ) )
|
|
{
|
|
iVal = hb_itemGetNI( pInfo->pNewVal );
|
|
if( iVal >= 0 && iVal <= 2 )
|
|
{
|
|
pQTC->iCloseMode = iVal;
|
|
if( pQTC->qWnd )
|
|
hb_gt_qtc_setWindowFlags( pQTC, Qt::WindowCloseButtonHint, pQTC->iCloseMode < 2 );
|
|
}
|
|
}
|
|
break;
|
|
|
|
case HB_GTI_RESIZABLE:
|
|
pInfo->pResult = hb_itemPutL( pInfo->pResult, pQTC->fResizable );
|
|
if( pInfo->pNewVal && HB_IS_LOGICAL( pInfo->pNewVal ) &&
|
|
( hb_itemGetL( pInfo->pNewVal ) ? ! pQTC->fResizable : pQTC->fResizable ) )
|
|
{
|
|
pQTC->fResizable = ! pQTC->fResizable;
|
|
if( pQTC->qWnd )
|
|
{
|
|
pQTC->qWnd->setResizing();
|
|
hb_gt_qtc_setWindowFlags( pQTC, Qt::WindowMaximizeButtonHint, pQTC->fResizable );
|
|
}
|
|
}
|
|
break;
|
|
|
|
case HB_GTI_RESIZEMODE:
|
|
pInfo->pResult = hb_itemPutNI( pInfo->pResult, pQTC->iResizeMode );
|
|
if( pInfo->pNewVal && HB_IS_NUMERIC( pInfo->pNewVal ) )
|
|
{
|
|
iVal = hb_itemGetNI( pInfo->pNewVal );
|
|
switch( iVal )
|
|
{
|
|
case HB_GTI_RESIZEMODE_FONT:
|
|
case HB_GTI_RESIZEMODE_ROWS:
|
|
if( pQTC->iResizeMode != iVal )
|
|
{
|
|
pQTC->iResizeMode = iVal;
|
|
if( pQTC->qWnd )
|
|
pQTC->qWnd->setResizing();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case HB_GTI_RESIZESTEP:
|
|
pInfo->pResult = hb_itemPutL( pInfo->pResult, pQTC->fResizeInc );
|
|
if( pInfo->pNewVal && HB_IS_LOGICAL( pInfo->pNewVal ) &&
|
|
( hb_itemGetL( pInfo->pNewVal ) ? ! pQTC->fResizeInc : pQTC->fResizeInc ) )
|
|
{
|
|
pQTC->fResizeInc = ! pQTC->fResizeInc;
|
|
if( pQTC->qWnd )
|
|
pQTC->qWnd->setResizing();
|
|
}
|
|
break;
|
|
|
|
case HB_GTI_SELECTCOPY:
|
|
pInfo->pResult = hb_itemPutL( pInfo->pResult, pQTC->fSelectCopy );
|
|
if( pInfo->pNewVal && HB_IS_LOGICAL( pInfo->pNewVal ) )
|
|
pQTC->fSelectCopy = hb_itemGetL( pInfo->pNewVal );
|
|
break;
|
|
|
|
case HB_GTI_MOUSEPOS_XY:
|
|
if( ! pInfo->pResult )
|
|
pInfo->pResult = hb_itemNew( NULL );
|
|
hb_arrayNew( pInfo->pResult, 2 );
|
|
hb_arraySetNI( pInfo->pResult, 1, pQTC->mousePosX );
|
|
hb_arraySetNI( pInfo->pResult, 2, pQTC->mousePosY );
|
|
break;
|
|
|
|
case HB_GTI_SETPOS_XY:
|
|
case HB_GTI_SETPOS_ROWCOL:
|
|
{
|
|
int x = pQTC->iNewPosX, y = pQTC->iNewPosY;
|
|
|
|
if( pQTC->qWnd )
|
|
{
|
|
x = pQTC->qWnd->pos().x();
|
|
y = pQTC->qWnd->pos().y();
|
|
}
|
|
if( ! pInfo->pResult )
|
|
pInfo->pResult = hb_itemNew( NULL );
|
|
hb_arrayNew( pInfo->pResult, 2 );
|
|
|
|
if( iType == HB_GTI_SETPOS_ROWCOL )
|
|
{
|
|
iVal = x;
|
|
x = y / pQTC->cellY;
|
|
y = iVal / pQTC->cellX;
|
|
}
|
|
hb_arraySetNI( pInfo->pResult, 1, x );
|
|
hb_arraySetNI( pInfo->pResult, 2, y );
|
|
|
|
if( pInfo->pNewVal && HB_IS_NUMERIC( pInfo->pNewVal ) &&
|
|
pInfo->pNewVal2 && HB_IS_NUMERIC( pInfo->pNewVal2 ) )
|
|
{
|
|
x = hb_itemGetNI( pInfo->pNewVal );
|
|
y = hb_itemGetNI( pInfo->pNewVal2 );
|
|
}
|
|
else if( pInfo->pNewVal && HB_IS_ARRAY( pInfo->pNewVal ) &&
|
|
hb_arrayLen( pInfo->pNewVal ) == 2 )
|
|
{
|
|
x = hb_arrayGetNI( pInfo->pNewVal, 1 );
|
|
y = hb_arrayGetNI( pInfo->pNewVal, 2 );
|
|
}
|
|
else
|
|
break;
|
|
|
|
if( iType == HB_GTI_SETPOS_ROWCOL )
|
|
{
|
|
iVal = x;
|
|
x = y * pQTC->cellX;
|
|
y = iVal * pQTC->cellY;
|
|
}
|
|
if( pQTC->qWnd )
|
|
pQTC->qWnd->move( x, y );
|
|
else
|
|
{
|
|
pQTC->iNewPosX = x;
|
|
pQTC->iNewPosY = y;
|
|
}
|
|
break;
|
|
}
|
|
case HB_GTI_PALETTE:
|
|
{
|
|
HB_BOOL fExpose = HB_FALSE;
|
|
|
|
if( pInfo->pNewVal && HB_IS_NUMERIC( pInfo->pNewVal ) )
|
|
{
|
|
iVal = hb_itemGetNI( pInfo->pNewVal );
|
|
if( iVal >= 0 && iVal < 16 )
|
|
{
|
|
pInfo->pResult = hb_itemPutNI( pInfo->pResult,
|
|
QTC_RGB2NUM( pQTC->colors[ iVal ] ) );
|
|
if( pInfo->pNewVal2 && HB_IS_NUMERIC( pInfo->pNewVal2 ) )
|
|
{
|
|
int iColor = hb_itemGetNI( pInfo->pNewVal2 );
|
|
QRgb rgb = QTC_NUM2RGB( iColor );
|
|
if( rgb != pQTC->colors[ iVal ] )
|
|
{
|
|
pQTC->colors[ iVal ] = rgb;
|
|
fExpose = HB_TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( ! pInfo->pResult )
|
|
pInfo->pResult = hb_itemNew( NULL );
|
|
hb_arrayNew( pInfo->pResult, 16 );
|
|
for( iVal = 0; iVal < 16; iVal++ )
|
|
hb_arraySetNL( pInfo->pResult, iVal + 1,
|
|
QTC_RGB2NUM( pQTC->colors[ iVal ] ) );
|
|
if( pInfo->pNewVal && HB_IS_ARRAY( pInfo->pNewVal ) &&
|
|
hb_arrayLen( pInfo->pNewVal ) == 16 )
|
|
{
|
|
for( iVal = 0; iVal < 16; iVal++ )
|
|
{
|
|
int iColor = hb_arrayGetNI( pInfo->pNewVal, iVal + 1 );
|
|
QRgb rgb = QTC_NUM2RGB( iColor );
|
|
if( rgb != pQTC->colors[ iVal ] )
|
|
{
|
|
pQTC->colors[ iVal ] = rgb;
|
|
fExpose = HB_TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if( fExpose && pQTC->qWnd )
|
|
HB_GTSELF_EXPOSEAREA( pQTC->pGT, 0, 0, pQTC->iRows, pQTC->iCols );
|
|
break;
|
|
}
|
|
case HB_GTI_WINHANDLE:
|
|
pInfo->pResult = hb_itemPutPtr( pInfo->pResult, pQTC->qWnd );
|
|
break;
|
|
|
|
case HB_GTI_DISPIMAGE:
|
|
if( pQTC->qWnd &&
|
|
( hb_itemType( pInfo->pNewVal ) & ( HB_IT_STRING | HB_IT_ARRAY ) ) )
|
|
{
|
|
QImage qImg = QImage();
|
|
|
|
/* filename or resource */
|
|
if( HB_IS_STRING( pInfo->pNewVal ) )
|
|
{
|
|
if( hb_itemGetCLen( pInfo->pNewVal ) > 0 )
|
|
{
|
|
QString qStr;
|
|
hb_gt_qtc_itemGetQString( pInfo->pNewVal, &qStr );
|
|
qImg = QImage( qStr );
|
|
}
|
|
}
|
|
else if( hb_arrayLen( pInfo->pNewVal ) == static_cast< HB_SIZE >
|
|
( ( hb_arrayGetType( pInfo->pNewVal, 4 ) & HB_IT_NUMERIC ) ? 4 : 3 ) &&
|
|
( hb_arrayGetType( pInfo->pNewVal, 1 ) & ( HB_IT_POINTER | HB_IT_STRING ) ) &&
|
|
( hb_arrayGetType( pInfo->pNewVal, 2 ) & HB_IT_NUMERIC ) &&
|
|
( hb_arrayGetType( pInfo->pNewVal, 3 ) & HB_IT_NUMERIC ) )
|
|
{
|
|
HB_SIZE nSize = hb_arrayGetCLen( pInfo->pNewVal, 1 );
|
|
int iWidth = hb_arrayGetNI( pInfo->pNewVal, 2 );
|
|
int iHeight = hb_arrayGetNI( pInfo->pNewVal, 3 );
|
|
int iDepth = hb_arrayGetNI( pInfo->pNewVal, 4 );
|
|
int iPitch = 0;
|
|
const uchar * data = NULL;
|
|
QImage::Format format;
|
|
|
|
switch( iDepth )
|
|
{
|
|
case 0:
|
|
iDepth = 32;
|
|
/* fallthrough */
|
|
case 32:
|
|
format = QImage::Format_RGB32;
|
|
break;
|
|
case 16:
|
|
format = QImage::Format_RGB16;
|
|
break;
|
|
case 1:
|
|
format = QImage::Format_Mono;
|
|
break;
|
|
default:
|
|
format = QImage::Format_Invalid;
|
|
break;
|
|
}
|
|
|
|
if( format != QImage::Format_Invalid && iWidth > 0 && iHeight > 0 )
|
|
{
|
|
if( nSize > 0 )
|
|
{
|
|
int iPad = 32;
|
|
while( data == NULL && iPad >= 8 )
|
|
{
|
|
iPitch = ( iWidth * iDepth + iPad - 1 ) / iPad;
|
|
if( nSize == static_cast< HB_SIZE >( iHeight * iPitch ) )
|
|
data = reinterpret_cast< const uchar * >( hb_arrayGetCPtr( pInfo->pNewVal, 1 ) );
|
|
else
|
|
iPad >>= 1;
|
|
}
|
|
}
|
|
else
|
|
data = reinterpret_cast< const uchar * >( hb_arrayGetPtr( pInfo->pNewVal, 1 ) );
|
|
}
|
|
if( data != NULL )
|
|
{
|
|
if( iPitch == 0 )
|
|
qImg = QImage( data, iWidth, iHeight, QImage::Format_RGB32 );
|
|
else
|
|
qImg = QImage( data, iWidth, iHeight, iPitch, QImage::Format_RGB32 );
|
|
}
|
|
}
|
|
|
|
QRect rx = pQTC->qWnd->qConsole->image->rect();
|
|
|
|
if( pInfo->pNewVal2 && HB_IS_ARRAY( pInfo->pNewVal2 ) )
|
|
{
|
|
switch( hb_arrayLen( pInfo->pNewVal2 ) )
|
|
{
|
|
case 2:
|
|
rx.setLeft( hb_arrayGetNI( pInfo->pNewVal2, 1 ) );
|
|
rx.setTop( hb_arrayGetNI( pInfo->pNewVal2, 2 ) );
|
|
if( ! qImg.isNull() )
|
|
rx.setSize( qImg.size() );
|
|
break;
|
|
case 4:
|
|
rx.setCoords( hb_arrayGetNI( pInfo->pNewVal2, 1 ),
|
|
hb_arrayGetNI( pInfo->pNewVal2, 2 ),
|
|
hb_arrayGetNI( pInfo->pNewVal2, 3 ),
|
|
hb_arrayGetNI( pInfo->pNewVal2, 4 ) );
|
|
}
|
|
}
|
|
else if( ! qImg.isNull() && hb_itemGetL( pInfo->pNewVal2 ) )
|
|
{
|
|
iVal = qImg.height() * rx.width() / qImg.width();
|
|
if( iVal <= rx.height() )
|
|
rx.setHeight( iVal );
|
|
else
|
|
rx.setWidth( qImg.width() * rx.height() / qImg.height() );
|
|
rx.moveCenter( pQTC->qWnd->qConsole->image->rect().center() );
|
|
}
|
|
|
|
if( qImg.isNull() )
|
|
pQTC->qWnd->qConsole->repaintChars( rx );
|
|
else
|
|
{
|
|
QPainter painter( pQTC->qWnd->qConsole->image );
|
|
painter.drawImage( rx, qImg );
|
|
}
|
|
pQTC->qWnd->qConsole->update();
|
|
}
|
|
break;
|
|
|
|
case HB_GTI_MSGBOX:
|
|
if( ! pInfo->pNewVal || HB_IS_LOGICAL( pInfo->pNewVal ) || HB_IS_NIL( pInfo->pNewVal ) )
|
|
{
|
|
pInfo->pResult = hb_itemPutL( pInfo->pResult, pQTC->fMsgAlert );
|
|
if( pInfo->pNewVal && HB_IS_LOGICAL( pInfo->pNewVal ) )
|
|
pQTC->fMsgAlert = hb_itemGetL( pInfo->pNewVal );
|
|
}
|
|
else
|
|
pInfo->pResult = hb_itemPutNI( pInfo->pResult,
|
|
hb_gt_qtc_messageBox( pQTC, pInfo->pNewVal, pInfo->pNewVal2, -1 ) );
|
|
break;
|
|
|
|
#ifdef HB_QT_SOUND
|
|
case HB_GTI_SOUND:
|
|
if( pInfo->pNewVal && HB_IS_STRING( pInfo->pNewVal ) &&
|
|
hb_itemGetCLen( pInfo->pNewVal ) > 0 )
|
|
{
|
|
QString qStr;
|
|
hb_gt_qtc_itemGetQString( pInfo->pNewVal, &qStr );
|
|
QSound::play( qStr );
|
|
}
|
|
break;
|
|
#endif
|
|
|
|
default:
|
|
return HB_GTSUPER_INFO( pGT, iType, pInfo );
|
|
}
|
|
|
|
return HB_TRUE;
|
|
}
|
|
|
|
#define hb_gfx_cord( t, l, b, r, tmp ) \
|
|
do { \
|
|
if( l > r ) { tmp = r; r = l; l = tmp; } \
|
|
if( t > b ) { tmp = b; b = t; t = tmp; } \
|
|
} while( 0 )
|
|
|
|
#define hb_gfx_update( x, y, w, h ) pQTC->qWnd->qConsole->update( x, y, w, h )
|
|
|
|
static int hb_gt_qtc_gfx_Primitive( PHB_GT pGT, int iType, int iTop, int iLeft, int iBottom, int iRight, int iColor )
|
|
{
|
|
PHB_GTQTC pQTC;
|
|
int iRet = 1;
|
|
|
|
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_qtc_gfx_Primitive(%p,%d,%d,%d,%d,%d,%d)", ( void * ) pGT, iType, iTop, iLeft, iBottom, iRight, iColor ) );
|
|
|
|
pQTC = HB_GTQTC_GET( pGT );
|
|
|
|
if( pQTC->qWnd )
|
|
{
|
|
int iTmp;
|
|
|
|
switch( iType )
|
|
{
|
|
case HB_GFX_MAKECOLOR:
|
|
{
|
|
QRgb qColor = qRgb( iTop & 0xFF, iLeft & 0xFF, iBottom & 0xFF );
|
|
iRet = QTC_RGB2NUM( qColor );
|
|
break;
|
|
}
|
|
case HB_GFX_PUTPIXEL:
|
|
hb_bm_paint_begin( pQTC->qWnd->qConsole->image );
|
|
hb_bm_color( iBottom );
|
|
hb_bm_point( iLeft, iTop );
|
|
hb_bm_paint_end();
|
|
hb_gfx_update( iLeft, iTop, 1, 1 );
|
|
break;
|
|
|
|
case HB_GFX_LINE:
|
|
hb_bm_paint_begin( pQTC->qWnd->qConsole->image );
|
|
hb_bm_color( iColor );
|
|
hb_bm_line( iLeft, iTop, iRight, iBottom );
|
|
hb_bm_paint_end();
|
|
hb_gfx_cord( iTop, iLeft, iBottom, iRight, iTmp );
|
|
hb_gfx_update( iLeft, iTop, iRight - iLeft + 1, iBottom - iTop + 1 );
|
|
break;
|
|
|
|
case HB_GFX_RECT:
|
|
hb_gfx_cord( iTop, iLeft, iBottom, iRight, iTmp );
|
|
hb_bm_paint_begin( pQTC->qWnd->qConsole->image );
|
|
hb_bm_color( iColor );
|
|
painter.setBrush( Qt::NoBrush );
|
|
hb_bm_rect( iLeft, iTop, iRight - iLeft, iBottom - iTop );
|
|
hb_bm_paint_end();
|
|
hb_gfx_update( iLeft, iTop, iRight - iLeft + 1, iBottom - iTop + 1 );
|
|
break;
|
|
|
|
case HB_GFX_FILLEDRECT:
|
|
hb_gfx_cord( iTop, iLeft, iBottom, iRight, iTmp );
|
|
hb_bm_paint_begin( pQTC->qWnd->qConsole->image );
|
|
hb_bm_color( iColor );
|
|
hb_bm_fillrectc( iLeft, iTop, iRight - iLeft, iBottom - iTop, iColor );
|
|
hb_bm_paint_end();
|
|
hb_gfx_update( iLeft, iTop, iRight - iLeft + 1, iBottom - iTop + 1 );
|
|
break;
|
|
|
|
case HB_GFX_CIRCLE:
|
|
hb_bm_paint_begin( pQTC->qWnd->qConsole->image );
|
|
hb_bm_color( iRight );
|
|
painter.setBrush( Qt::NoBrush );
|
|
painter.drawEllipse( QPoint( iLeft, iTop ), iBottom, iBottom );
|
|
hb_bm_paint_end();
|
|
hb_gfx_update( iLeft - iBottom, iTop - iBottom, iLeft + iBottom, iTop + iBottom );
|
|
break;
|
|
|
|
case HB_GFX_FILLEDCIRCLE:
|
|
hb_bm_paint_begin( pQTC->qWnd->qConsole->image );
|
|
hb_bm_color( iRight );
|
|
painter.setBrush( QBrush( QTC_NUM2RGB( iRight ) ) );
|
|
painter.drawEllipse( QPoint( iLeft, iTop ), iBottom, iBottom );
|
|
hb_bm_paint_end();
|
|
hb_gfx_update( iLeft - iBottom, iTop - iBottom, iLeft + iBottom, iTop + iBottom );
|
|
break;
|
|
|
|
case HB_GFX_ELLIPSE:
|
|
hb_bm_paint_begin( pQTC->qWnd->qConsole->image );
|
|
hb_bm_color( iColor );
|
|
painter.setBrush( Qt::NoBrush );
|
|
painter.drawEllipse( QPoint( iLeft, iTop ), iRight, iBottom );
|
|
hb_bm_paint_end();
|
|
hb_gfx_update( iLeft - iRight, iTop - iBottom, iLeft + iRight, iTop + iBottom );
|
|
break;
|
|
|
|
case HB_GFX_FILLEDELLIPSE:
|
|
hb_bm_paint_begin( pQTC->qWnd->qConsole->image );
|
|
hb_bm_color( iColor );
|
|
painter.setBrush( QBrush( QTC_NUM2RGB( iColor ) ) );
|
|
painter.drawEllipse( QPoint( iLeft, iTop ), iRight, iBottom );
|
|
hb_bm_paint_end();
|
|
hb_gfx_update( iLeft - iRight, iTop - iBottom, iLeft + iRight, iTop + iBottom );
|
|
break;
|
|
}
|
|
}
|
|
|
|
return iRet;
|
|
}
|
|
|
|
/* --- */
|
|
|
|
static HB_BOOL hb_gt_FuncInit( PHB_GT_FUNCS pFuncTable )
|
|
{
|
|
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_FuncInit(%p)", ( void * ) pFuncTable ) );
|
|
|
|
pFuncTable->Init = hb_gt_qtc_Init;
|
|
pFuncTable->Exit = hb_gt_qtc_Exit;
|
|
pFuncTable->SetMode = hb_gt_qtc_SetMode;
|
|
pFuncTable->Redraw = hb_gt_qtc_Redraw;
|
|
pFuncTable->Refresh = hb_gt_qtc_Refresh;
|
|
pFuncTable->Version = hb_gt_qtc_Version;
|
|
pFuncTable->Tone = hb_gt_qtc_Tone;
|
|
pFuncTable->Info = hb_gt_qtc_Info;
|
|
pFuncTable->Alert = hb_gt_qtc_Alert;
|
|
pFuncTable->ReadKey = hb_gt_qtc_ReadKey;
|
|
|
|
pFuncTable->MouseIsPresent = hb_gt_qtc_mouse_IsPresent;
|
|
pFuncTable->MouseGetPos = hb_gt_qtc_mouse_GetPos;
|
|
pFuncTable->MouseButtonState = hb_gt_qtc_mouse_ButtonState;
|
|
pFuncTable->MouseCountButton = hb_gt_qtc_mouse_CountButton;
|
|
|
|
pFuncTable->GfxPrimitive = hb_gt_qtc_gfx_Primitive;
|
|
|
|
return HB_TRUE;
|
|
}
|
|
|
|
/* --- */
|
|
|
|
static const HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
|
|
hb_gt_FuncInit,
|
|
HB_GTSUPER,
|
|
HB_GTID_PTR };
|
|
|
|
HB_GT_ANNOUNCE( HB_GT_NAME )
|
|
|
|
HB_CALL_ON_STARTUP_BEGIN( _hb_startup_gt_Init_ )
|
|
hb_gtRegister( >Init );
|
|
HB_CALL_ON_STARTUP_END( _hb_startup_gt_Init_ )
|
|
|
|
#if defined( HB_PRAGMA_STARTUP )
|
|
#pragma startup _hb_startup_gt_Init_
|
|
#elif defined( HB_MSC_STARTUP )
|
|
#if defined( HB_OS_WIN_64 )
|
|
#pragma section( HB_MSC_START_SEGMENT, long, read )
|
|
#endif
|
|
#pragma data_seg( HB_MSC_START_SEGMENT )
|
|
static HB_$INITSYM hb_vm_auto__hb_startup_gt_Init_ = _hb_startup_gt_Init_;
|
|
#pragma data_seg()
|
|
#endif
|
|
|
|
/* --- */
|
|
|
|
QTConsole::QTConsole( PHB_GTQTC pStructQTC, QWidget *parnt ) : QWidget( parnt )
|
|
{
|
|
pQTC = pStructQTC;
|
|
|
|
resizeMode = false;
|
|
selectMode = false;
|
|
image = NULL;
|
|
timer = NULL;
|
|
|
|
setAttribute( Qt::WA_StaticContents );
|
|
setAttribute( Qt::WA_OpaquePaintEvent );
|
|
setAttribute( Qt::WA_NoSystemBackground );
|
|
/* Warning! Qt::WA_KeyCompression attribute creates problems when
|
|
* barcode readers are used - some characters are eaten [druzus]
|
|
*/
|
|
#if 0
|
|
setAttribute( Qt::WA_KeyCompression );
|
|
#endif
|
|
|
|
/* Qt::WA_InputMethodEnabled disables support for
|
|
* national characters in few European countries
|
|
* (f.e. Polish characters with ALT in macOS)
|
|
* If some Asian users needs it then we will have
|
|
* to enable it optionally [druzus]
|
|
*/
|
|
#if 0
|
|
setAttribute( Qt::WA_InputMethodEnabled );
|
|
#endif
|
|
|
|
#if defined( HB_OS_ANDROID ) || defined( HB_OS_IOS ) || defined( HB_OS_WIN_CE )
|
|
setInputMethodHints( Qt::ImhNoPredictiveText );
|
|
#endif
|
|
|
|
setFocusPolicy( Qt::StrongFocus );
|
|
setMouseTracking( true );
|
|
|
|
image = new QImage();
|
|
|
|
timer = new QBasicTimer();
|
|
if( QApplication::cursorFlashTime() / 2 > 0 )
|
|
timer->start( QApplication::cursorFlashTime() / 2, this );
|
|
}
|
|
|
|
QTConsole::~QTConsole( void )
|
|
{
|
|
delete image;
|
|
|
|
if( timer->isActive() )
|
|
timer->stop();
|
|
delete timer;
|
|
}
|
|
|
|
void QTConsole::resetWindowSize( void )
|
|
{
|
|
font = QFont( *pQTC->fontName );
|
|
if( pQTC->fontWeight )
|
|
font.setWeight( pQTC->fontWeight == HB_GTI_FONTW_THIN ? QFont::Light :
|
|
( pQTC->fontWeight == HB_GTI_FONTW_BOLD ? QFont::Bold :
|
|
QFont::Normal ) ) ;
|
|
font.setFixedPitch( true );
|
|
font.setKerning( false );
|
|
setFontSize( pQTC->fontHeight, pQTC->fontWidth );
|
|
pQTC->qWnd->setWindowSize();
|
|
}
|
|
|
|
void QTConsole::setFontSize( int iFH, int iFW )
|
|
{
|
|
int iDec = 0, iHeight, iWidth, iAscent;
|
|
bool bStretch = ( pQTC->fontAttribute & HB_GTI_FONTA_NOSTRETCH ) == 0;
|
|
bool bMaxSize = ( pQTC->qWnd->windowState() &
|
|
( Qt::WindowMaximized | Qt::WindowFullScreen ) ) != 0;
|
|
|
|
if( iFH < 4 )
|
|
iFH = 4;
|
|
|
|
font.setStretch( 100 );
|
|
do
|
|
{
|
|
font.setPixelSize( iFH - iDec );
|
|
QFontMetrics fm( font );
|
|
iHeight = fm.height();
|
|
iWidth = fm.averageCharWidth();
|
|
iAscent = fm.ascent();
|
|
if( iHeight <= iFH && ( bStretch || ! bMaxSize || iWidth <= iFW ) )
|
|
break;
|
|
}
|
|
while( iFH - ++iDec >= 4 );
|
|
|
|
if( iFW > 0 && bStretch )
|
|
{
|
|
if( iFW < 2 )
|
|
iFW = 2;
|
|
|
|
if( iWidth != iFW )
|
|
{
|
|
int iDir;
|
|
|
|
iDec = ( iFW * 100 ) / iWidth;
|
|
if( iDec < 1 )
|
|
iDec = 1;
|
|
else if( iDec >= 4000 )
|
|
iDec = 3999;
|
|
iDir = iDec;
|
|
do
|
|
{
|
|
font.setStretch( iDec );
|
|
QFontMetrics fm( font );
|
|
iHeight = fm.height();
|
|
iWidth = fm.averageCharWidth();
|
|
iAscent = fm.ascent();
|
|
|
|
if( iWidth == iFW )
|
|
break;
|
|
|
|
if( iWidth < iFW )
|
|
{
|
|
if( iDir > iDec )
|
|
break;
|
|
++iDec;
|
|
}
|
|
else /* iWidth > iFW */
|
|
{
|
|
if( --iDec <= iDir )
|
|
iDir = iDec + 1;
|
|
}
|
|
}
|
|
while( iDec > ( iDir >> 1 ) && iDec < ( iDir << 1 ) && iDec < 4000 );
|
|
}
|
|
}
|
|
|
|
if( ( iHeight < iFH || iWidth < iFW ) &&
|
|
( pQTC->fontAttribute & HB_GTI_FONTA_CLRBKG ) != 0 &&
|
|
( pQTC->fontAttribute & HB_GTI_FONTA_DRAWBOX ) != 0 &&
|
|
( pQTC->fontAttribute & HB_GTI_FONTA_FIXMETRIC ) != 0 )
|
|
{
|
|
if( iHeight < iFH )
|
|
iHeight = iFH;
|
|
if( iWidth < iFW )
|
|
iWidth = iFW;
|
|
}
|
|
|
|
pQTC->fontHeight = iHeight;
|
|
pQTC->fontWidth = iWidth;
|
|
pQTC->fontAscent = iAscent;
|
|
|
|
pQTC->fRepaint = pQTC->cellX != pQTC->fontWidth ||
|
|
pQTC->cellY != pQTC->fontHeight;
|
|
|
|
pQTC->cellX = pQTC->fontWidth;
|
|
pQTC->cellY = pQTC->fontHeight;
|
|
|
|
if( pQTC->fRepaint || image->isNull() )
|
|
{
|
|
hb_gt_qtc_resetBoxCharBitmaps( pQTC );
|
|
if( ! image->isNull() && pQTC->iResizeMode == HB_GTI_RESIZEMODE_ROWS )
|
|
hb_gt_qtc_setWindowSize( pQTC, pQTC->qWnd->height() / pQTC->cellY,
|
|
pQTC->qWnd->width() / pQTC->cellX );
|
|
}
|
|
setImageSize();
|
|
}
|
|
|
|
void QTConsole::setImageSize( void )
|
|
{
|
|
int iWidth = pQTC->cellX * pQTC->iCols;
|
|
int iHeight = pQTC->cellY * pQTC->iRows;
|
|
|
|
if( iWidth != image->width() || iHeight != image->height() )
|
|
{
|
|
delete image;
|
|
image = new QImage( iWidth, iHeight, QImage::Format_RGB32 );
|
|
pQTC->fRepaint = HB_TRUE;
|
|
}
|
|
if( pQTC->fRepaint )
|
|
{
|
|
image->fill( BLACK );
|
|
repaintChars( image->rect() );
|
|
pQTC->fRepaint = HB_FALSE;
|
|
}
|
|
}
|
|
|
|
void QTConsole::resizeEvent( QResizeEvent * evt )
|
|
{
|
|
int iWidth = width();
|
|
int iHeight = height();
|
|
|
|
if( iWidth != image->width() || iHeight != image->height() )
|
|
{
|
|
resizeMode = true;
|
|
|
|
if( pQTC->iResizeMode == HB_GTI_RESIZEMODE_ROWS )
|
|
{
|
|
int iRows = iHeight / pQTC->cellY;
|
|
int iCols = iWidth / pQTC->cellX;
|
|
|
|
if( hb_gt_qtc_setWindowSize( pQTC, iRows, iCols ) )
|
|
setImageSize();
|
|
}
|
|
else
|
|
setFontSize( iHeight / pQTC->iRows, iWidth / pQTC->iCols );
|
|
|
|
update();
|
|
}
|
|
else
|
|
QWidget::resizeEvent( evt );
|
|
}
|
|
|
|
static QRect hb_gt_qtc_cellToPixel( PHB_GTQTC pQTC, const QRect & rc )
|
|
{
|
|
return QRect( rc.left() * pQTC->cellX,
|
|
rc.top() * pQTC->cellY,
|
|
rc.width() * pQTC->cellX,
|
|
rc.height() * pQTC->cellY );
|
|
}
|
|
|
|
static QRect hb_gt_qtc_pixelToCell( PHB_GTQTC pQTC, const QRect & rx )
|
|
{
|
|
QRect rc;
|
|
rc.setCoords( rx.left() / pQTC->cellX,
|
|
rx.top() / pQTC->cellY,
|
|
rx.right() / pQTC->cellX,
|
|
rx.bottom() / pQTC->cellY );
|
|
return rc;
|
|
}
|
|
|
|
static QRect hb_gt_qtc_mapRect( PHB_GTQTC pQTC, const QImage * image, const QRect & rx )
|
|
{
|
|
return hb_gt_qtc_pixelToCell( pQTC,
|
|
( rx.normalized() & QRect( pQTC->marginLeft, pQTC->marginTop,
|
|
image->width(), image->height() ) )
|
|
.translated( -pQTC->marginLeft, -pQTC->marginTop ) );
|
|
}
|
|
|
|
static QRect hb_gt_qtc_unmapRect( PHB_GTQTC pQTC, const QRect & rc )
|
|
{
|
|
return hb_gt_qtc_cellToPixel( pQTC, rc ).translated( pQTC->marginLeft,
|
|
pQTC->marginTop );
|
|
}
|
|
|
|
void QTConsole::copySelection( void )
|
|
{
|
|
const QRect rc = hb_gt_qtc_mapRect( pQTC, image, selectRect );
|
|
int iRow, iCol;
|
|
QString qStrEol( hb_conNewLine() );
|
|
QString qStr( "" );
|
|
|
|
qStr.reserve( rc.height() * ( rc.width() + qStrEol.size() ) );
|
|
|
|
selectMode = false;
|
|
update( hb_gt_qtc_unmapRect( pQTC, rc ) );
|
|
|
|
for( iRow = rc.top(); iRow <= rc.bottom(); ++iRow )
|
|
{
|
|
for( iCol = rc.left(); iCol <= rc.right(); ++iCol )
|
|
{
|
|
int iColor;
|
|
HB_BYTE bAttr;
|
|
HB_USHORT usChar;
|
|
|
|
if( ! HB_GTSELF_GETSCRCHAR( pQTC->pGT, iRow, iCol, &iColor, &bAttr, &usChar ) )
|
|
break;
|
|
qStr += QChar( usChar );
|
|
}
|
|
if( rc.height() > 1 )
|
|
qStr += qStrEol;
|
|
}
|
|
|
|
QApplication::clipboard()->setText( qStr );
|
|
if( QApplication::clipboard()->supportsSelection() )
|
|
QApplication::clipboard()->setText( qStr, QClipboard::Selection );
|
|
}
|
|
|
|
void QTConsole::repaintChars( const QRect & rx )
|
|
{
|
|
int iRow, iColor, iTextColor = 0;
|
|
HB_BYTE bAttr;
|
|
HB_USHORT usChar;
|
|
bool bClrBkg = ( pQTC->fontAttribute & HB_GTI_FONTA_CLRBKG ) != 0;
|
|
bool bFixMetric = ( pQTC->fontAttribute & HB_GTI_FONTA_FIXMETRIC ) != 0;
|
|
QRect rc = hb_gt_qtc_pixelToCell( pQTC, rx );
|
|
|
|
QPainter painter( image );
|
|
painter.setFont( QFont( font, painter.device() ) );
|
|
if( bClrBkg )
|
|
painter.setBackgroundMode( Qt::TransparentMode );
|
|
else
|
|
painter.setBackgroundMode( Qt::OpaqueMode );
|
|
|
|
for( iRow = rc.top(); iRow <= rc.bottom(); ++iRow )
|
|
{
|
|
int iCol, iStartCol, iLen;
|
|
|
|
iCol = iStartCol = rc.left();
|
|
iLen = 0;
|
|
|
|
while( iCol <= rc.right() )
|
|
{
|
|
if( ! HB_GTSELF_GETSCRCHAR( pQTC->pGT, iRow, iCol, &iColor, &bAttr, &usChar ) )
|
|
break;
|
|
|
|
if( ( pQTC->fontAttribute & HB_GTI_FONTA_CTRLCHARS ) == 0 )
|
|
usChar = hb_cdpGetU16Ctrl( usChar );
|
|
iColor &= 0xff;
|
|
|
|
QBitmap * qBitMap = hb_gt_qtc_getBoxChar( pQTC, &usChar );
|
|
|
|
if( iLen > 0 && ( iColor != iTextColor || bFixMetric || qBitMap ) )
|
|
{
|
|
if( bClrBkg )
|
|
painter.fillRect( iStartCol * pQTC->cellX, iRow * pQTC->cellY,
|
|
iLen * pQTC->cellX, pQTC->cellY,
|
|
pQTC->colors[ iTextColor >> 4 ] );
|
|
else
|
|
painter.setBackground( QBrush( pQTC->colors[ iTextColor >> 4 ] ) );
|
|
painter.setPen( pQTC->colors[ iTextColor & 0x0F ] );
|
|
painter.drawText( iStartCol * pQTC->cellX,
|
|
( iRow * pQTC->cellY ) + pQTC->fontAscent,
|
|
QString( pQTC->textLine, iLen ) );
|
|
iLen = 0;
|
|
}
|
|
if( qBitMap )
|
|
{
|
|
painter.setBackgroundMode( Qt::OpaqueMode );
|
|
painter.setBackground( QBrush( pQTC->colors[ iColor >> 4 ] ) );
|
|
painter.setPen( pQTC->colors[ iColor & 0x0F ] );
|
|
painter.drawPixmap( iCol * pQTC->cellX, iRow * pQTC->cellY, *qBitMap );
|
|
if( bClrBkg )
|
|
painter.setBackgroundMode( Qt::TransparentMode );
|
|
}
|
|
else
|
|
{
|
|
if( iLen == 0 )
|
|
{
|
|
iTextColor = iColor;
|
|
iStartCol = iCol;
|
|
}
|
|
pQTC->textLine[ iLen++ ] = usChar;
|
|
}
|
|
iCol++;
|
|
}
|
|
if( iLen > 0 )
|
|
{
|
|
if( bClrBkg )
|
|
painter.fillRect( iStartCol * pQTC->cellX, iRow * pQTC->cellY,
|
|
iLen * pQTC->cellX, pQTC->cellY,
|
|
pQTC->colors[ iTextColor >> 4 ] );
|
|
else
|
|
painter.setBackground( QBrush( pQTC->colors[ iTextColor >> 4 ] ) );
|
|
painter.setPen( pQTC->colors[ iTextColor & 0x0F ] );
|
|
painter.drawText( iStartCol * pQTC->cellX,
|
|
( iRow * pQTC->cellY ) + pQTC->fontAscent,
|
|
QString( pQTC->textLine, iLen ) );
|
|
}
|
|
}
|
|
|
|
update( rx.translated( pQTC->marginLeft, pQTC->marginTop ) );
|
|
}
|
|
|
|
void QTConsole::paintEvent( QPaintEvent * evt )
|
|
{
|
|
QPainter painter( this );
|
|
QRect rEvt = evt->rect();
|
|
|
|
if( rEvt.left() < pQTC->marginLeft )
|
|
{
|
|
QRect rc = rEvt;
|
|
rc.setRight( pQTC->marginLeft );
|
|
painter.fillRect( rc, QBrush( BLACK ) );
|
|
rEvt.setLeft( pQTC->marginLeft );
|
|
}
|
|
if( rEvt.top() < pQTC->marginTop )
|
|
{
|
|
QRect rc = rEvt;
|
|
rc.setBottom( pQTC->marginTop );
|
|
painter.fillRect( rc, QBrush( BLACK ) );
|
|
rEvt.setTop( pQTC->marginTop );
|
|
}
|
|
if( rEvt.right() > pQTC->marginLeft + image->width() )
|
|
{
|
|
QRect rc = rEvt;
|
|
rc.setLeft( pQTC->marginLeft + image->width() );
|
|
painter.fillRect( rc, QBrush( BLACK ) );
|
|
rEvt.setRight( pQTC->marginLeft + image->width() - 1 );
|
|
}
|
|
if( rEvt.bottom() > pQTC->marginTop + image->height() )
|
|
{
|
|
QRect rc = rEvt;
|
|
rc.setTop( pQTC->marginTop + image->height() );
|
|
painter.fillRect( rc, QBrush( BLACK ) );
|
|
rEvt.setBottom( pQTC->marginTop + image->height() - 1 );
|
|
}
|
|
|
|
painter.drawImage( rEvt, *image, rEvt.translated( -pQTC->marginLeft, -pQTC->marginTop ) );
|
|
|
|
if( selectMode )
|
|
{
|
|
/* Display selection */
|
|
QRect rSel = hb_gt_qtc_unmapRect( pQTC, hb_gt_qtc_mapRect( pQTC, image, selectRect ) );
|
|
if( rSel.intersects( rEvt ) )
|
|
{
|
|
#if defined( HB_OS_DARWIN )
|
|
/* RasterOp operations are not supported in macOS */
|
|
rEvt &= rSel;
|
|
image->invertPixels();
|
|
painter.drawImage( rEvt, *image, rEvt.translated( -pQTC->marginLeft, -pQTC->marginTop ) );
|
|
image->invertPixels();
|
|
#else
|
|
painter.setCompositionMode( QPainter::RasterOp_SourceXorDestination );
|
|
painter.fillRect( rSel & rEvt, Qt::color0 );
|
|
#endif
|
|
}
|
|
}
|
|
else if( pQTC->cursorType != SC_NONE && pQTC->cursorSize != 0 )
|
|
{
|
|
/* Display cursor */
|
|
QRect rCrs( pQTC->cursorCol * pQTC->cellX + pQTC->marginLeft,
|
|
pQTC->cursorRow * pQTC->cellY + pQTC->marginTop + pQTC->cursorOffset,
|
|
pQTC->cellX, pQTC->cursorSize );
|
|
if( rEvt.intersects( rCrs ) )
|
|
{
|
|
#if defined( HB_OS_DARWIN )
|
|
/* RasterOp operations are not supported in macOS,
|
|
* use foreground cell color like hardware VGA cursor
|
|
*/
|
|
HB_BYTE bAttr;
|
|
HB_USHORT usChar;
|
|
int iColor;
|
|
|
|
if( HB_GTSELF_GETSCRCHAR( pQTC->pGT, pQTC->cursorRow, pQTC->cursorCol,
|
|
&iColor, &bAttr, &usChar ) )
|
|
{
|
|
painter.fillRect( rCrs, pQTC->colors[ iColor & 0x0F ] );
|
|
}
|
|
#else
|
|
painter.setCompositionMode( QPainter::RasterOp_SourceXorDestination );
|
|
/* TODO? use foreground cell color like hardware VGA cursor ? */
|
|
painter.fillRect( rCrs, Qt::color0 );
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
void QTConsole::timerEvent( QTimerEvent * evt )
|
|
{
|
|
if( evt->timerId() == timer->timerId() )
|
|
{
|
|
if( hasFocus() )
|
|
{
|
|
pQTC->cursorVisible = ! pQTC->cursorVisible;
|
|
hb_gt_qtc_updateCursor( pQTC );
|
|
}
|
|
}
|
|
else
|
|
QWidget::timerEvent( evt );
|
|
}
|
|
|
|
void QTConsole::focusInEvent( QFocusEvent * evt )
|
|
{
|
|
hb_gt_qtc_addKeyToInputQueue( pQTC, HB_K_GOTFOCUS );
|
|
QWidget::focusInEvent( evt );
|
|
#if defined( HB_OS_ANDROID ) || defined( HB_OS_IOS ) || defined( HB_OS_WIN_CE )
|
|
QEvent reqSIPevent( QEvent::RequestSoftwareInputPanel );
|
|
QApplication::sendEvent( pQTC->qWnd, &reqSIPevent );
|
|
#endif
|
|
}
|
|
|
|
void QTConsole::focusOutEvent( QFocusEvent * evt )
|
|
{
|
|
hb_gt_qtc_addKeyToInputQueue( pQTC, HB_K_LOSTFOCUS );
|
|
QWidget::focusOutEvent( evt );
|
|
}
|
|
|
|
void QTConsole::mouseMoveEvent( QMouseEvent * evt )
|
|
{
|
|
if( pQTC->fSelectCopy && selectMode )
|
|
{
|
|
QRect rSel1 = hb_gt_qtc_unmapRect( pQTC, hb_gt_qtc_mapRect( pQTC, image, selectRect ) );
|
|
selectRect.setBottomRight( evt->pos() );
|
|
QRect rSel2 = hb_gt_qtc_unmapRect( pQTC, hb_gt_qtc_mapRect( pQTC, image, selectRect ) );
|
|
if( rSel1 != rSel2 )
|
|
update( QRegion( rSel1 ).xored( QRegion( rSel2 ) ) );
|
|
}
|
|
else
|
|
{
|
|
QPoint pos = evt->pos();
|
|
hb_gt_qtc_setMouseKey( pQTC, pos.x(), pos.y(), 0, evt->modifiers() );
|
|
}
|
|
}
|
|
|
|
void QTConsole::wheelEvent( QWheelEvent * evt )
|
|
{
|
|
#if QT_VERSION >= 0x050E00
|
|
QPoint delta = evt->angleDelta();
|
|
|
|
if( delta.y() != 0 || delta.x() != 0 )
|
|
{
|
|
QPoint pos = evt->position().toPoint();
|
|
|
|
if( delta.y() != 0 )
|
|
hb_gt_qtc_setMouseKey( pQTC, pos.x(), pos.y(), delta.y() < 0 ? K_MWBACKWARD : K_MWFORWARD, evt->modifiers() );
|
|
if( delta.x() != 0 )
|
|
hb_gt_qtc_setMouseKey( pQTC, pos.x(), pos.y(), delta.x() < 0 ? K_MWRIGHT : K_MWLEFT, evt->modifiers() );
|
|
}
|
|
else
|
|
QWidget::wheelEvent( evt );
|
|
#else
|
|
int iKey;
|
|
|
|
switch( evt->orientation() )
|
|
{
|
|
case Qt::Vertical:
|
|
iKey = evt->delta() < 0 ? K_MWBACKWARD : K_MWFORWARD;
|
|
break;
|
|
|
|
case Qt::Horizontal:
|
|
iKey = evt->delta() < 0 ? K_MWRIGHT : K_MWLEFT;
|
|
break;
|
|
|
|
default:
|
|
QWidget::wheelEvent( evt );
|
|
return;
|
|
}
|
|
|
|
hb_gt_qtc_setMouseKey( pQTC, evt->x(), evt->y(), iKey, evt->modifiers() );
|
|
#endif
|
|
}
|
|
|
|
void QTConsole::mouseDoubleClickEvent( QMouseEvent * evt )
|
|
{
|
|
int iKey;
|
|
|
|
switch( evt->button() )
|
|
{
|
|
case Qt::LeftButton:
|
|
#if defined( HB_OS_ANDROID ) || defined( HB_OS_IOS ) || defined( HB_OS_WIN_CE )
|
|
{
|
|
QEvent reqSIPevent( QEvent::RequestSoftwareInputPanel );
|
|
QApplication::sendEvent( pQTC->qWnd, &reqSIPevent );
|
|
}
|
|
#endif
|
|
iKey = K_LDBLCLK;
|
|
break;
|
|
|
|
case Qt::RightButton:
|
|
iKey = K_RDBLCLK;
|
|
break;
|
|
|
|
#if QT_VERSION >= 0x060000
|
|
case Qt::MiddleButton:
|
|
#else
|
|
case Qt::MidButton:
|
|
#endif
|
|
iKey = K_MDBLCLK;
|
|
break;
|
|
|
|
default:
|
|
QWidget::mouseDoubleClickEvent( evt );
|
|
return;
|
|
}
|
|
|
|
QPoint pos = evt->pos();
|
|
hb_gt_qtc_setMouseKey( pQTC, pos.x(), pos.y(), iKey, evt->modifiers() );
|
|
}
|
|
|
|
void QTConsole::mousePressEvent( QMouseEvent * evt )
|
|
{
|
|
int iKey;
|
|
|
|
switch( evt->button() )
|
|
{
|
|
case Qt::LeftButton:
|
|
if( ! selectMode && ( evt->modifiers() & Qt::ShiftModifier ) )
|
|
{
|
|
QPoint pos = evt->pos();
|
|
|
|
selectMode = true;
|
|
selectRect.setCoords( pos.x(), pos.y(), pos.x(), pos.y() );
|
|
update( hb_gt_qtc_unmapRect( pQTC, hb_gt_qtc_mapRect( pQTC, image, selectRect ) ) );
|
|
return;
|
|
}
|
|
iKey = K_LBUTTONDOWN;
|
|
break;
|
|
|
|
case Qt::RightButton:
|
|
iKey = K_RBUTTONDOWN;
|
|
break;
|
|
|
|
#if QT_VERSION >= 0x060000
|
|
case Qt::MiddleButton:
|
|
#else
|
|
case Qt::MidButton:
|
|
#endif
|
|
iKey = K_MBUTTONDOWN;
|
|
break;
|
|
|
|
default:
|
|
QWidget::mousePressEvent( evt );
|
|
return;
|
|
}
|
|
|
|
QPoint pos = evt->pos();
|
|
hb_gt_qtc_setMouseKey( pQTC, pos.x(), pos.y(), iKey, evt->modifiers() );
|
|
}
|
|
|
|
void QTConsole::mouseReleaseEvent( QMouseEvent * evt )
|
|
{
|
|
int iKey;
|
|
|
|
switch( evt->button() )
|
|
{
|
|
case Qt::LeftButton:
|
|
if( selectMode )
|
|
{
|
|
copySelection();
|
|
return;
|
|
}
|
|
iKey = K_LBUTTONUP;
|
|
break;
|
|
|
|
case Qt::RightButton:
|
|
iKey = K_RBUTTONUP;
|
|
break;
|
|
|
|
#if QT_VERSION >= 0x060000
|
|
case Qt::MiddleButton:
|
|
#else
|
|
case Qt::MidButton:
|
|
#endif
|
|
iKey = K_MBUTTONUP;
|
|
break;
|
|
|
|
default:
|
|
QWidget::mouseReleaseEvent( evt );
|
|
return;
|
|
}
|
|
|
|
QPoint pos = evt->pos();
|
|
hb_gt_qtc_setMouseKey( pQTC, pos.x(), pos.y(), iKey, evt->modifiers() );
|
|
}
|
|
|
|
bool QTConsole::event( QEvent * evt )
|
|
{
|
|
if( evt->type() == QEvent::KeyPress )
|
|
{
|
|
QKeyEvent * kevt = static_cast< QKeyEvent * >( evt );
|
|
if( kevt->key() == Qt::Key_Tab )
|
|
{
|
|
keyPressEvent( kevt );
|
|
return true;
|
|
}
|
|
}
|
|
if( resizeMode )
|
|
{
|
|
switch( evt->type() )
|
|
{
|
|
case QEvent::Enter:
|
|
case QEvent::Leave:
|
|
case QEvent::MouseMove:
|
|
case QEvent::FocusIn:
|
|
case QEvent::FocusOut:
|
|
case QEvent::ChildRemoved:
|
|
case QEvent::UpdateRequest:
|
|
resizeMode = false;
|
|
update();
|
|
pQTC->qWnd->setWindowSize();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
return QWidget::event( evt );
|
|
}
|
|
|
|
void QTConsole::inputMethodEvent( QInputMethodEvent * evt )
|
|
{
|
|
/* It's for SoftwareInputPanel in Andorid. */
|
|
|
|
QString qStr = evt->commitString();
|
|
|
|
if( qStr.size() > 0 )
|
|
{
|
|
for( int i = 0; i < qStr.size(); ++i )
|
|
{
|
|
HB_WCHAR wc = qStr[ i ].unicode();
|
|
hb_gt_qtc_addKeyToInputQueue( pQTC, HB_INKEY_NEW_UNICODE( wc ) );
|
|
}
|
|
evt->accept();
|
|
}
|
|
else
|
|
QWidget::inputMethodEvent( evt );
|
|
}
|
|
|
|
void QTConsole::keyReleaseEvent( QKeyEvent * evt )
|
|
{
|
|
if( selectMode && ( evt->modifiers() & Qt::ShiftModifier ) == 0 )
|
|
copySelection();
|
|
|
|
QWidget::keyReleaseEvent( evt );
|
|
}
|
|
|
|
void QTConsole::keyPressEvent( QKeyEvent * evt )
|
|
{
|
|
int iKey = 0, iFlags = hb_gt_qtc_getKeyFlags( evt->modifiers() ),
|
|
iSize;
|
|
|
|
/* support for national characters */
|
|
if( ( iSize = evt->text().size() ) > 0 )
|
|
{
|
|
QString qStr = evt->text();
|
|
HB_WCHAR wc = qStr[ 0 ].unicode();
|
|
|
|
if( iSize > 1 || ( wc >= 32 && wc != 127 ) )
|
|
{
|
|
int i;
|
|
|
|
if( ( iFlags & HB_KF_CTRL ) != 0 && ( iFlags & HB_KF_ALT ) != 0 )
|
|
/* workaround for AltGR and German keyboard */
|
|
iFlags &= ~( HB_KF_CTRL | HB_KF_ALT );
|
|
|
|
for( i = 0; i < iSize; ++i )
|
|
{
|
|
wc = qStr[ i ].unicode();
|
|
hb_gt_qtc_addKeyToInputQueue( pQTC,
|
|
wc < 127 &&
|
|
( iFlags & ( HB_KF_CTRL | HB_KF_ALT ) ) ?
|
|
HB_INKEY_NEW_KEY( wc, iFlags ) :
|
|
HB_INKEY_NEW_UNICODEF( wc, iFlags ) );
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
switch( evt->key() )
|
|
{
|
|
case Qt::Key_F1:
|
|
iKey = HB_KX_F1;
|
|
break;
|
|
case Qt::Key_F2:
|
|
iKey = HB_KX_F2;
|
|
break;
|
|
case Qt::Key_F3:
|
|
iKey = HB_KX_F3;
|
|
break;
|
|
case Qt::Key_F4:
|
|
iKey = HB_KX_F4;
|
|
break;
|
|
case Qt::Key_F5:
|
|
iKey = HB_KX_F5;
|
|
break;
|
|
case Qt::Key_F6:
|
|
iKey = HB_KX_F6;
|
|
break;
|
|
case Qt::Key_F7:
|
|
iKey = HB_KX_F7;
|
|
break;
|
|
case Qt::Key_F8:
|
|
iKey = HB_KX_F8;
|
|
break;
|
|
case Qt::Key_F9:
|
|
iKey = HB_KX_F9;
|
|
break;
|
|
case Qt::Key_F10:
|
|
iKey = HB_KX_F10;
|
|
break;
|
|
case Qt::Key_F11:
|
|
iKey = HB_KX_F11;
|
|
break;
|
|
case Qt::Key_F12:
|
|
iKey = HB_KX_F12;
|
|
break;
|
|
case Qt::Key_Up:
|
|
iKey = HB_KX_UP;
|
|
break;
|
|
case Qt::Key_Down:
|
|
iKey = HB_KX_DOWN;
|
|
break;
|
|
case Qt::Key_Left:
|
|
iKey = HB_KX_LEFT;
|
|
break;
|
|
case Qt::Key_Right:
|
|
iKey = HB_KX_RIGHT;
|
|
break;
|
|
case Qt::Key_Home:
|
|
iKey = HB_KX_HOME;
|
|
break;
|
|
case Qt::Key_End:
|
|
iKey = HB_KX_END;
|
|
break;
|
|
case Qt::Key_PageUp:
|
|
iKey = HB_KX_PGUP;
|
|
break;
|
|
case Qt::Key_PageDown:
|
|
iKey = HB_KX_PGDN;
|
|
break;
|
|
case Qt::Key_Insert:
|
|
iKey = HB_KX_INS;
|
|
break;
|
|
case Qt::Key_Delete:
|
|
iKey = HB_KX_DEL;
|
|
break;
|
|
case Qt::Key_Backspace:
|
|
iKey = HB_KX_BS;
|
|
break;
|
|
case Qt::Key_Tab:
|
|
iKey = HB_KX_TAB;
|
|
break;
|
|
case Qt::Key_Backtab:
|
|
iKey = HB_KX_TAB;
|
|
iFlags |= HB_KF_SHIFT;
|
|
break;
|
|
case Qt::Key_Escape:
|
|
iKey = HB_KX_ESC;
|
|
break;
|
|
case Qt::Key_Return:
|
|
case Qt::Key_Enter:
|
|
if( pQTC->fAltEnter && ( iFlags & HB_KF_ALT ) != 0 &&
|
|
( iFlags & HB_KF_KEYPAD ) == 0 )
|
|
{
|
|
pQTC->fFullScreen = ( pQTC->qWnd->windowState() & Qt::WindowFullScreen ) == 0;
|
|
hb_gt_qtc_setWindowState( pQTC, Qt::WindowFullScreen, pQTC->fFullScreen, HB_TRUE );
|
|
return;
|
|
}
|
|
iKey = HB_KX_ENTER;
|
|
break;
|
|
case Qt::Key_Menu:
|
|
hb_gt_qtc_addKeyToInputQueue( pQTC, HB_K_MENU );
|
|
break;
|
|
case Qt::Key_Clear:
|
|
iKey = HB_KX_CENTER;
|
|
break;
|
|
case Qt::Key_Print:
|
|
iKey = HB_KX_PRTSCR;
|
|
break;
|
|
case Qt::Key_Pause:
|
|
iKey = HB_KX_PAUSE;
|
|
break;
|
|
case Qt::Key_Space:
|
|
iKey = ' ';
|
|
break;
|
|
case Qt::Key_Exclam:
|
|
iKey = '!';
|
|
break;
|
|
case Qt::Key_QuoteDbl:
|
|
iKey = '"';
|
|
break;
|
|
case Qt::Key_NumberSign:
|
|
iKey = '#';
|
|
break;
|
|
case Qt::Key_Dollar:
|
|
iKey = '$';
|
|
break;
|
|
case Qt::Key_Percent:
|
|
iKey = '%';
|
|
break;
|
|
case Qt::Key_Ampersand:
|
|
iKey = '&';
|
|
break;
|
|
case Qt::Key_Apostrophe:
|
|
iKey = '\'';
|
|
break;
|
|
case Qt::Key_ParenLeft:
|
|
iKey = '(';
|
|
break;
|
|
case Qt::Key_ParenRight:
|
|
iKey = ')';
|
|
break;
|
|
case Qt::Key_Asterisk:
|
|
iKey = '*';
|
|
break;
|
|
case Qt::Key_Plus:
|
|
iKey = '+';
|
|
break;
|
|
case Qt::Key_Comma:
|
|
iKey = ',';
|
|
break;
|
|
case Qt::Key_Minus:
|
|
iKey = '-';
|
|
break;
|
|
case Qt::Key_Period:
|
|
iKey = '.';
|
|
break;
|
|
case Qt::Key_Slash:
|
|
iKey = '/';
|
|
break;
|
|
case Qt::Key_0:
|
|
iKey = '0';
|
|
break;
|
|
case Qt::Key_1:
|
|
iKey = '1';
|
|
break;
|
|
case Qt::Key_2:
|
|
iKey = '2';
|
|
break;
|
|
case Qt::Key_3:
|
|
iKey = '3';
|
|
break;
|
|
case Qt::Key_4:
|
|
iKey = '4';
|
|
break;
|
|
case Qt::Key_5:
|
|
iKey = '5';
|
|
break;
|
|
case Qt::Key_6:
|
|
iKey = '6';
|
|
break;
|
|
case Qt::Key_7:
|
|
iKey = '7';
|
|
break;
|
|
case Qt::Key_8:
|
|
iKey = '8';
|
|
break;
|
|
case Qt::Key_9:
|
|
iKey = '9';
|
|
break;
|
|
case Qt::Key_Colon:
|
|
iKey = ':';
|
|
break;
|
|
case Qt::Key_Semicolon:
|
|
iKey = ';';
|
|
break;
|
|
case Qt::Key_Less:
|
|
iKey = '<';
|
|
break;
|
|
case Qt::Key_Equal:
|
|
iKey = '=';
|
|
break;
|
|
case Qt::Key_Greater:
|
|
iKey = '>';
|
|
break;
|
|
case Qt::Key_Question:
|
|
iKey = '?';
|
|
break;
|
|
case Qt::Key_At:
|
|
iKey = '@';
|
|
break;
|
|
case Qt::Key_A:
|
|
iKey = 'A';
|
|
break;
|
|
case Qt::Key_B:
|
|
iKey = 'B';
|
|
break;
|
|
case Qt::Key_C:
|
|
iKey = 'C';
|
|
break;
|
|
case Qt::Key_D:
|
|
iKey = 'D';
|
|
break;
|
|
case Qt::Key_E:
|
|
iKey = 'E';
|
|
break;
|
|
case Qt::Key_F:
|
|
iKey = 'F';
|
|
break;
|
|
case Qt::Key_G:
|
|
iKey = 'G';
|
|
break;
|
|
case Qt::Key_H:
|
|
iKey = 'H';
|
|
break;
|
|
case Qt::Key_I:
|
|
iKey = 'I';
|
|
break;
|
|
case Qt::Key_J:
|
|
iKey = 'J';
|
|
break;
|
|
case Qt::Key_K:
|
|
iKey = 'K';
|
|
break;
|
|
case Qt::Key_L:
|
|
iKey = 'L';
|
|
break;
|
|
case Qt::Key_M:
|
|
iKey = 'M';
|
|
break;
|
|
case Qt::Key_N:
|
|
iKey = 'N';
|
|
break;
|
|
case Qt::Key_O:
|
|
iKey = 'O';
|
|
break;
|
|
case Qt::Key_P:
|
|
iKey = 'P';
|
|
break;
|
|
case Qt::Key_Q:
|
|
iKey = 'Q';
|
|
break;
|
|
case Qt::Key_R:
|
|
iKey = 'R';
|
|
break;
|
|
case Qt::Key_S:
|
|
iKey = 'S';
|
|
break;
|
|
case Qt::Key_T:
|
|
iKey = 'T';
|
|
break;
|
|
case Qt::Key_U:
|
|
iKey = 'U';
|
|
break;
|
|
case Qt::Key_V:
|
|
iKey = 'V';
|
|
break;
|
|
case Qt::Key_W:
|
|
iKey = 'W';
|
|
break;
|
|
case Qt::Key_X:
|
|
iKey = 'X';
|
|
break;
|
|
case Qt::Key_Y:
|
|
iKey = 'Y';
|
|
break;
|
|
case Qt::Key_Z:
|
|
iKey = 'Z';
|
|
break;
|
|
case Qt::Key_BracketLeft:
|
|
iKey = '[';
|
|
break;
|
|
case Qt::Key_Backslash:
|
|
iKey = '\\';
|
|
break;
|
|
case Qt::Key_BracketRight:
|
|
iKey = ']';
|
|
break;
|
|
case Qt::Key_AsciiCircum:
|
|
iKey = '^';
|
|
break;
|
|
case Qt::Key_Underscore:
|
|
iKey = '_';
|
|
break;
|
|
case Qt::Key_QuoteLeft:
|
|
iKey = '`';
|
|
break;
|
|
case Qt::Key_BraceLeft:
|
|
iKey = '{';
|
|
break;
|
|
case Qt::Key_Bar:
|
|
iKey = '|';
|
|
break;
|
|
case Qt::Key_BraceRight:
|
|
iKey = '}';
|
|
break;
|
|
case Qt::Key_AsciiTilde:
|
|
iKey = '~';
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if( iKey != 0 )
|
|
hb_gt_qtc_addKeyToInputQueue( pQTC, HB_INKEY_NEW_KEY( iKey, iFlags ) );
|
|
else
|
|
QWidget::keyPressEvent( evt );
|
|
}
|
|
|
|
/* --- */
|
|
|
|
QTCWindow::QTCWindow( PHB_GTQTC pQTC )
|
|
{
|
|
Qt::WindowFlags flags = ( windowFlags() & Qt::WindowType_Mask ) |
|
|
Qt::CustomizeWindowHint |
|
|
Qt::Window;
|
|
if( pQTC->fNoFrame )
|
|
{
|
|
flags |= Qt::FramelessWindowHint;
|
|
}
|
|
else
|
|
{
|
|
if( pQTC->iCloseMode < 2 )
|
|
flags |= Qt::WindowCloseButtonHint;
|
|
if( pQTC->fResizable )
|
|
flags |= Qt::WindowMaximizeButtonHint;
|
|
flags |= Qt::WindowMinimizeButtonHint |
|
|
Qt::WindowSystemMenuHint |
|
|
Qt::WindowTitleHint;
|
|
}
|
|
|
|
setWindowFlags( flags );
|
|
|
|
/* set default size used when leaving initial
|
|
* fullscreen or maximized mode [druzus]
|
|
*/
|
|
resize( pQTC->cellX * pQTC->iCols, pQTC->cellY * pQTC->iRows );
|
|
|
|
if( pQTC->fFullScreen )
|
|
setWindowState( windowState() | Qt::WindowFullScreen );
|
|
else if( pQTC->fMaximized )
|
|
setWindowState( windowState() | Qt::WindowMaximized );
|
|
else if( pQTC->fMinimized )
|
|
setWindowState( windowState() | Qt::WindowMinimized );
|
|
|
|
if( pQTC->qIcon )
|
|
setWindowIcon( *pQTC->qIcon );
|
|
setWindowTitle( *pQTC->wndTitle );
|
|
|
|
qConsole = new QTConsole( pQTC );
|
|
setCentralWidget( qConsole );
|
|
setFocusProxy( qConsole );
|
|
setFocusPolicy( Qt::StrongFocus );
|
|
/* In windows it helps to keep focus in fullscreen or maximized
|
|
* windows [druzus]
|
|
*/
|
|
setFocus( Qt::OtherFocusReason );
|
|
}
|
|
|
|
QTCWindow::~QTCWindow( void )
|
|
{
|
|
delete qConsole;
|
|
}
|
|
|
|
void QTCWindow::closeEvent( QCloseEvent * evt )
|
|
{
|
|
if( qConsole->pQTC->iCloseMode == 0 )
|
|
hb_vmRequestQuit();
|
|
else
|
|
hb_gt_qtc_addKeyToInputQueue( qConsole->pQTC, HB_K_CLOSE );
|
|
|
|
evt->ignore();
|
|
}
|
|
|
|
void QTCWindow::setWindowSize( void )
|
|
{
|
|
if( ( windowState() & ( Qt::WindowMaximized | Qt::WindowFullScreen ) ) != 0 )
|
|
{
|
|
qConsole->pQTC->marginLeft = width() - qConsole->image->width();
|
|
if( qConsole->pQTC->marginLeft > 0 )
|
|
qConsole->pQTC->marginLeft >>= 1;
|
|
else
|
|
qConsole->pQTC->marginLeft = 0;
|
|
|
|
qConsole->pQTC->marginTop = height() - qConsole->image->height();
|
|
if( qConsole->pQTC->marginTop > 0 )
|
|
qConsole->pQTC->marginTop >>= 1;
|
|
else
|
|
qConsole->pQTC->marginTop = 0;
|
|
}
|
|
else
|
|
{
|
|
qConsole->pQTC->marginLeft = qConsole->pQTC->marginTop = 0;
|
|
resize( qConsole->image->size() );
|
|
}
|
|
setResizing();
|
|
}
|
|
|
|
void QTCWindow::setResizing( void )
|
|
{
|
|
if( qConsole->pQTC->fResizable )
|
|
{
|
|
#if QT_VERSION >= 0x050E00
|
|
/* setMaximumSize( screen()->availableSize() ); */
|
|
setMaximumSize( screen()->size() );
|
|
#else
|
|
/* setMaximumSize( screen()->availableGeometry( this ).size() ); */
|
|
setMaximumSize( QApplication::desktop()->screenGeometry( this ).size() );
|
|
#endif
|
|
if( qConsole->pQTC->iResizeMode == HB_GTI_RESIZEMODE_ROWS )
|
|
{
|
|
setMinimumSize( qConsole->pQTC->cellX << 1, qConsole->pQTC->cellY << 1 );
|
|
if( ! qConsole->pQTC->fResizeInc || ( windowState() & Qt::WindowMaximized ) != 0 )
|
|
setSizeIncrement( 0, 0 );
|
|
else
|
|
setSizeIncrement( qConsole->pQTC->cellX, qConsole->pQTC->cellY );
|
|
}
|
|
else
|
|
{
|
|
setMinimumSize( qConsole->pQTC->iCols << 1, qConsole->pQTC->iRows << 2 );
|
|
if( ! qConsole->pQTC->fResizeInc || ( windowState() & Qt::WindowMaximized ) != 0 )
|
|
setSizeIncrement( 0, 0 );
|
|
else
|
|
setSizeIncrement( qConsole->pQTC->iCols, qConsole->pQTC->iRows );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
setFixedSize( size() );
|
|
setSizeIncrement( 0, 0 );
|
|
}
|
|
}
|
|
|
|
/* --- */
|
|
|
|
#ifdef HB_XLIB_NEEDLOCKS
|
|
|
|
#include <X11/Xlib.h>
|
|
|
|
static void hb_gt_qtc_InitMT( void )
|
|
{
|
|
if( hb_vmIsMt() )
|
|
{
|
|
if( ! XInitThreads() )
|
|
hb_errInternal( 10002, "XInitThreads() failed !!!", NULL, NULL );
|
|
}
|
|
}
|
|
|
|
#else
|
|
|
|
static void hb_gt_qtc_InitMT( void ) { }
|
|
|
|
#endif
|
|
|
|
/* --- */
|