2532 lines
73 KiB
C
2532 lines
73 KiB
C
/*
|
|
* Video subsystem for Windows using GUI windows instead of Console
|
|
* with multiple windows support
|
|
* Copyright 2004 Budyanto Dj. <budyanto@centrin.net.id>
|
|
* GTWVW draw functions
|
|
* GTWVW is initially created based on:
|
|
* =Id: gtwvt.c,v 1.60 2004-01-26 08:14:07 vouchcac Exp =
|
|
*
|
|
* 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 "hbgtwvw.h"
|
|
|
|
HB_FUNC( WVW_YESCLOSE )
|
|
{
|
|
UINT usWinNum = WVW_WHICH_WINDOW;
|
|
WIN_DATA * pWindowData = hb_gt_wvw_GetWindowsData( usWinNum );
|
|
HMENU hMenu = GetSystemMenu( pWindowData->hWnd, FALSE );
|
|
|
|
if( hMenu )
|
|
{
|
|
AppendMenu( hMenu, SC_CLOSE, MF_BYCOMMAND, "" );
|
|
DrawMenuBar( pWindowData->hWnd );
|
|
}
|
|
}
|
|
HB_FUNC( WIN_SENDMESSAGE )
|
|
{
|
|
char * cText = NULL;
|
|
|
|
if( HB_ISBYREF( 4 ) )
|
|
{
|
|
cText = ( char * ) hb_xgrab( hb_parcsiz( 4 ) );
|
|
hb_xmemcpy( cText, hb_parcx( 4 ), hb_parcsiz( 4 ) );
|
|
}
|
|
|
|
hb_retnl( ( ULONG ) SendMessage( ( HWND ) HB_PARHANDLE( 1 ),
|
|
( UINT ) hb_parni( 2 ),
|
|
( HB_ISNIL( 3 ) ? 0 : ( WPARAM ) hb_parnl( 3 ) ),
|
|
( HB_ISNIL( 4 ) ? 0 : ( HB_ISBYREF( 4 ) ? ( LPARAM ) ( LPSTR ) cText :
|
|
( HB_ISCHAR( 4 ) ? ( LPARAM ) ( LPSTR ) hb_parcx( 4 ) :
|
|
( LPARAM ) hb_parnl( 4 ) ) ) ) )
|
|
);
|
|
|
|
if( HB_ISBYREF( 4 ) )
|
|
{
|
|
hb_storclen( cText, hb_parcsiz( 4 ), 4 );
|
|
hb_xfree( cText );
|
|
}
|
|
}
|
|
|
|
|
|
HB_FUNC( WIN_SENDDLGITEMMESSAGE )
|
|
{
|
|
char * cText;
|
|
PHB_ITEM pText = hb_param( 5, HB_IT_STRING );
|
|
|
|
if( pText )
|
|
{
|
|
cText = ( char * ) hb_xgrab( hb_itemGetCLen( pText ) + 1 );
|
|
hb_xmemcpy( cText, hb_itemGetCPtr( pText ), hb_itemGetCLen( pText ) + 1 );
|
|
}
|
|
else
|
|
cText = NULL;
|
|
|
|
hb_retnl( ( LONG ) SendDlgItemMessage( ( HWND ) HB_PARHANDLE( 1 ),
|
|
( int ) hb_parni( 2 ),
|
|
( UINT ) hb_parni( 3 ),
|
|
( HB_ISNIL( 4 ) ? 0 : ( WPARAM ) hb_parnl( 4 ) ),
|
|
( cText ? ( LPARAM ) cText : ( LPARAM ) hb_parnl( 5 ) )
|
|
)
|
|
);
|
|
|
|
if( pText )
|
|
hb_storclen( cText, hb_itemGetCLen( pText ), 5 );
|
|
|
|
if( cText )
|
|
hb_xfree( cText );
|
|
}
|
|
|
|
/*
|
|
*
|
|
* win_SetTimer( hWnd, nIdentifier, nTimeOut )
|
|
*/
|
|
|
|
HB_FUNC( WIN_SETTIMER )
|
|
{
|
|
hb_retl( SetTimer( ( HWND ) HB_PARHANDLE( 1 ), hb_parni( 2 ), hb_parni( 3 ), NULL ) );
|
|
}
|
|
|
|
|
|
HB_FUNC( WIN_SETFOCUS )
|
|
{
|
|
SetFocus( ( HWND ) HB_PARHANDLE( 1 ) );
|
|
}
|
|
|
|
|
|
HB_FUNC( WIN_SETTEXTCOLOR )
|
|
{
|
|
hb_retnl( ( ULONG ) SetTextColor( ( HDC ) HB_PARHANDLE( 1 ), ( COLORREF ) hb_parnl( 2 ) ) );
|
|
}
|
|
|
|
|
|
HB_FUNC( WIN_SETBKCOLOR )
|
|
{
|
|
hb_retnl( ( ULONG ) SetBkColor( ( HDC ) HB_PARHANDLE( 1 ), ( COLORREF ) hb_parnl( 2 ) ) );
|
|
}
|
|
|
|
|
|
HB_FUNC( WVW_SETBKMODE )
|
|
{
|
|
hb_retni( ( int ) SetBkMode( ( HDC ) HB_PARHANDLE( 1 ), hb_parni( 2 ) ) );
|
|
}
|
|
|
|
|
|
HB_FUNC( WIN_GETSTOCKOBJECT )
|
|
{
|
|
hb_retnl( ( ULONG ) GetStockObject( hb_parnl( 1 ) ) );
|
|
}
|
|
|
|
|
|
HB_FUNC( WIN_DELETEOBJECT )
|
|
{
|
|
hb_retl( DeleteObject( ( HGDIOBJ ) HB_PARHANDLE( 1 ) ) );
|
|
}
|
|
|
|
|
|
HB_FUNC( WIN_SELECTOBJECT )
|
|
{
|
|
hb_retnl( ( ULONG ) SelectObject( ( HDC ) HB_PARHANDLE( 1 ), ( HGDIOBJ ) HB_PARHANDLE( 2 ) ) );
|
|
}
|
|
|
|
|
|
HB_FUNC( WIN_MULDIV )
|
|
{
|
|
hb_retni( MulDiv( hb_parni( 1 ), hb_parni( 2 ), hb_parni( 3 ) ) );
|
|
}
|
|
|
|
|
|
HB_FUNC( WIN_GETDIALOGBASEUNITS )
|
|
{
|
|
hb_retnl( ( LONG ) GetDialogBaseUnits() );
|
|
}
|
|
|
|
|
|
HB_FUNC( WIN_SETDLGITEMTEXT )
|
|
{
|
|
SetDlgItemText( ( HWND ) HB_PARHANDLE( 1 ), hb_parni( 2 ), hb_parc( 3 ) );
|
|
}
|
|
|
|
|
|
HB_FUNC( WIN_GETDLGITEMTEXT )
|
|
{
|
|
USHORT iLen = ( USHORT ) SendMessage( ( HWND ) GetDlgItem( ( HWND ) HB_PARHANDLE( 1 ), hb_parni( 2 ) ), ( UINT ) WM_GETTEXTLENGTH, ( WPARAM ) 0, ( LPARAM ) 0 ) + 1;
|
|
char * cText = ( char * ) hb_xgrab( iLen + 1 );
|
|
|
|
GetDlgItemText( ( HWND ) HB_PARHANDLE( 1 ),
|
|
hb_parni( 2 ),
|
|
( LPTSTR ) cText,
|
|
iLen
|
|
);
|
|
|
|
hb_retc( cText );
|
|
hb_xfree( cText );
|
|
}
|
|
|
|
|
|
HB_FUNC( WIN_CHECKDLGBUTTON )
|
|
{
|
|
hb_retl( CheckDlgButton( ( HWND ) HB_PARHANDLE( 1 ), hb_parni( 2 ),
|
|
HB_ISNUM( 3 ) ? hb_parni( 3 ) : ( UINT ) hb_parl( 3 ) ) );
|
|
}
|
|
|
|
|
|
HB_FUNC( WIN_ISDLGBUTTONCHECKED )
|
|
{
|
|
hb_retni( IsDlgButtonChecked( ( HWND ) HB_PARHANDLE( 1 ), hb_parni( 2 ) ) );
|
|
}
|
|
|
|
|
|
HB_FUNC( WIN_CHECKRADIOBUTTON )
|
|
{
|
|
hb_retl( CheckRadioButton( ( HWND ) HB_PARHANDLE( 1 ),
|
|
hb_parni( 2 ),
|
|
hb_parni( 3 ),
|
|
hb_parni( 4 )
|
|
) );
|
|
}
|
|
|
|
|
|
HB_FUNC( WIN_GETDLGITEM )
|
|
{
|
|
hb_retnl( ( ULONG ) GetDlgItem( ( HWND ) HB_PARHANDLE( 1 ), hb_parni( 2 ) ) );
|
|
}
|
|
|
|
|
|
HB_FUNC( WIN_MESSAGEBOX )
|
|
{
|
|
hb_retni( MessageBox( ( HWND ) HB_PARHANDLE( 1 ), hb_parcx( 2 ), hb_parcx( 3 ), HB_ISNIL( 4 ) ? MB_OK : hb_parni( 4 ) ) );
|
|
}
|
|
|
|
|
|
HB_FUNC( WIN_INVALIDATERECT )
|
|
{
|
|
InvalidateRect( ( HWND ) HB_PARHANDLE( 1 ), NULL, TRUE );
|
|
}
|
|
|
|
/*
|
|
*
|
|
* win_LoadIcon( ncIcon )
|
|
*/
|
|
|
|
HB_FUNC( WIN_LOADICON )
|
|
{
|
|
HICON hIcon;
|
|
|
|
if( HB_ISNUM( 1 ) )
|
|
hIcon = LoadIcon( hb_getWvwData()->hInstance, MAKEINTRESOURCE( hb_parni( 1 ) ) );
|
|
else
|
|
hIcon = ( HICON ) LoadImage( ( HINSTANCE ) NULL, hb_parc( 1 ), IMAGE_ICON, 0, 0, LR_LOADFROMFILE );
|
|
|
|
hb_retnl( ( ULONG ) hIcon );
|
|
}
|
|
|
|
/*
|
|
*
|
|
* win_LoadImage( ncImage, nSource ) -> hImage
|
|
* nSource == 0 ResourceIdByNumber
|
|
* nSource == 0 ResourceIdByName
|
|
* nSource == 0 ImageFromDiskFile
|
|
*/
|
|
|
|
HB_FUNC( WIN_LOADIMAGE )
|
|
{
|
|
HBITMAP hImage = NULL;
|
|
int iSource = hb_parni( 2 );
|
|
|
|
switch( iSource )
|
|
{
|
|
case 0:
|
|
hImage = LoadBitmap( hb_getWvwData()->hInstance, MAKEINTRESOURCE( hb_parni( 1 ) ) );
|
|
break;
|
|
|
|
case 1:
|
|
hImage = LoadBitmap( hb_getWvwData()->hInstance, hb_parc( 1 ) );
|
|
break;
|
|
|
|
case 2:
|
|
hImage = ( HBITMAP ) LoadImage( ( HINSTANCE ) NULL, hb_parc( 1 ), IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE );
|
|
break;
|
|
}
|
|
|
|
hb_retnl( ( ULONG ) hImage );
|
|
}
|
|
|
|
|
|
HB_FUNC( WIN_GETCLIENTRECT )
|
|
{
|
|
RECT rc = { 0 };
|
|
PHB_ITEM info = hb_itemArrayNew( 4 );
|
|
|
|
GetClientRect( ( HWND ) HB_PARHANDLE( 1 ), &rc );
|
|
|
|
hb_arraySetNI( info, 1, rc.left );
|
|
hb_arraySetNI( info, 2, rc.top );
|
|
hb_arraySetNI( info, 3, rc.right );
|
|
hb_arraySetNI( info, 4, rc.bottom );
|
|
|
|
hb_itemReturnRelease( info );
|
|
}
|
|
|
|
/*
|
|
*
|
|
* Win_DrawImage( hdc, nLeft, nTop, nWidth, nHeight, cImage ) in Pixels
|
|
*/
|
|
|
|
/* sorry, not supported in GTWVW
|
|
HB_FUNC( WIN_DRAWIMAGE )
|
|
{
|
|
hb_retl( hb_wvt_DrawImage( ( HDC ) hb_parni( 1 ), hb_parni( 2 ), hb_parni( 3 ),
|
|
hb_parni( 4 ), hb_parni( 5 ), hb_parc( 6 ) ) );
|
|
}
|
|
*/
|
|
|
|
|
|
HB_FUNC( WIN_GETDC )
|
|
{
|
|
HB_RETHANDLE( GetDC( ( HWND ) HB_PARHANDLE( 1 ) ) );
|
|
}
|
|
|
|
|
|
HB_FUNC( WIN_RELEASEDC )
|
|
{
|
|
hb_retl( ReleaseDC( ( HWND ) HB_PARHANDLE( 1 ), ( HDC ) HB_PARHANDLE( 2 ) ) );
|
|
}
|
|
|
|
|
|
HB_FUNC( WVW_RECTANGLE )
|
|
{
|
|
Rectangle( ( HDC ) HB_PARHANDLE( 1 ), hb_parni( 2 ), hb_parni( 3 ), hb_parni( 4 ), hb_parni( 5 ) );
|
|
}
|
|
|
|
|
|
HB_FUNC( WIN_CREATEBRUSH )
|
|
{
|
|
LOGBRUSH lb = { 0 };
|
|
|
|
lb.lbStyle = hb_parni( 1 );
|
|
lb.lbColor = HB_ISNIL( 2 ) ? RGB( 0, 0, 0 ) : ( COLORREF ) hb_parnl( 2 );
|
|
lb.lbHatch = HB_ISNIL( 3 ) ? 0 : hb_parni( 3 );
|
|
|
|
hb_retnl( ( ULONG ) CreateBrushIndirect( &lb ) );
|
|
}
|
|
|
|
/*
|
|
*
|
|
* win_DrawText( hDC, cText, aRect, nFormat )
|
|
*/
|
|
|
|
HB_FUNC( WIN_DRAWTEXT )
|
|
{
|
|
RECT rc = { 0 };
|
|
|
|
rc.left = hb_parvni( 3, 1 );
|
|
rc.top = hb_parvni( 3, 2 );
|
|
rc.right = hb_parvni( 3, 3 );
|
|
rc.bottom = hb_parvni( 3, 4 );
|
|
|
|
hb_retl( DrawText( ( HDC ) HB_PARHANDLE( 1 ), hb_parc( 2 ), strlen( hb_parc( 2 ) ), &rc, hb_parni( 4 ) ) );
|
|
}
|
|
|
|
|
|
/* Adiciones a GtWVW desarrolladas por SOLUCIONES PERCEPTIVAS... */
|
|
|
|
HB_FUNC( WVW_GBCREATE )
|
|
{
|
|
UINT usWinNum = WVW_WHICH_WINDOW;
|
|
int iOffTop, iOffLeft, iOffBottom, iOffRight;
|
|
/* int iStyle; */
|
|
UINT uiPBid;
|
|
USHORT usTop = ( USHORT ) hb_parni( 2 ),
|
|
usLeft = ( USHORT ) hb_parni( 3 ),
|
|
usBottom = ( USHORT ) hb_parni( 4 ),
|
|
usRight = ( USHORT ) hb_parni( 5 );
|
|
LPCTSTR lpszCaption = HB_ISCHAR( 6 ) ? hb_parcx( 6 ) : NULL;
|
|
char * szBitmap = HB_ISCHAR( 7 ) ? ( char * ) hb_parcx( 7 ) : NULL;
|
|
UINT uiBitmap = HB_ISNUM( 7 ) ? ( UINT ) hb_parni( 7 ) : 0;
|
|
double dStretch = ! HB_ISNIL( 10 ) ? hb_parnd( 10 ) : 1;
|
|
BOOL bMap3Dcolors = HB_ISLOG( 11 ) ? ( BOOL ) hb_parl( 11 ) : FALSE;
|
|
|
|
iOffTop = ! HB_ISNIL( 9 ) ? hb_parvni( 9, 1 ) : -1;
|
|
iOffLeft = ! HB_ISNIL( 9 ) ? hb_parvni( 9, 2 ) : -1;
|
|
iOffBottom = ! HB_ISNIL( 9 ) ? hb_parvni( 9, 3 ) : +1;
|
|
iOffRight = ! HB_ISNIL( 9 ) ? hb_parvni( 9, 4 ) : +1;
|
|
|
|
uiPBid = ButtonCreate( usWinNum, usTop, usLeft, usBottom, usRight, lpszCaption,
|
|
szBitmap, uiBitmap, hb_param( 8, HB_IT_BLOCK ),
|
|
iOffTop, iOffLeft, iOffBottom, iOffRight,
|
|
dStretch, bMap3Dcolors,
|
|
BS_TEXT | BS_GROUPBOX | WS_CHILD | WS_OVERLAPPED | WS_VISIBLE );
|
|
hb_retnl( ( LONG ) uiPBid );
|
|
}
|
|
|
|
/* BS_TEXT | BS_GROUPBOX | WS_CHILD | WS_OVERLAPPED | WS_VISIBLE
|
|
BS_GROUPBOX | WS_GROUP | BS_TEXT | WS_OVERLAPPED */
|
|
|
|
HB_FUNC( WVW_RBCREATE )
|
|
{
|
|
UINT usWinNum = WVW_WHICH_WINDOW;
|
|
int iOffTop, iOffLeft, iOffBottom, iOffRight;
|
|
/* int iStyle; */
|
|
UINT uiPBid;
|
|
USHORT usTop = ( USHORT ) hb_parni( 2 ),
|
|
usLeft = ( USHORT ) hb_parni( 3 ),
|
|
usBottom = ( USHORT ) hb_parni( 4 ),
|
|
usRight = ( USHORT ) hb_parni( 5 );
|
|
LPCTSTR lpszCaption = HB_ISCHAR( 6 ) ? hb_parcx( 6 ) : NULL;
|
|
char * szBitmap = HB_ISCHAR( 7 ) ? ( char * ) hb_parcx( 7 ) : NULL;
|
|
UINT uiBitmap = HB_ISNUM( 7 ) ? ( UINT ) hb_parni( 7 ) : 0;
|
|
double dStretch = ! HB_ISNIL( 10 ) ? hb_parnd( 10 ) : 1;
|
|
BOOL bMap3Dcolors = HB_ISLOG( 11 ) ? ( BOOL ) hb_parl( 11 ) : FALSE;
|
|
|
|
if( ! HB_ISBLOCK( 8 ) )
|
|
{
|
|
hb_retnl( 0 );
|
|
return;
|
|
}
|
|
|
|
iOffTop = ! HB_ISNIL( 9 ) ? hb_parvni( 9, 1 ) : -2;
|
|
iOffLeft = ! HB_ISNIL( 9 ) ? hb_parvni( 9, 2 ) : -2;
|
|
iOffBottom = ! HB_ISNIL( 9 ) ? hb_parvni( 9, 3 ) : +2;
|
|
iOffRight = ! HB_ISNIL( 9 ) ? hb_parvni( 9, 4 ) : +2;
|
|
|
|
uiPBid = ButtonCreate( usWinNum, usTop, usLeft, usBottom, usRight, lpszCaption,
|
|
szBitmap, uiBitmap, hb_param( 8, HB_IT_BLOCK ),
|
|
iOffTop, iOffLeft, iOffBottom, iOffRight,
|
|
dStretch, bMap3Dcolors,
|
|
BS_AUTORADIOBUTTON /*| WS_GROUP*/ );
|
|
hb_retnl( ( LONG ) uiPBid );
|
|
}
|
|
|
|
HB_FUNC( WVW_SETCONTROLTEXT )
|
|
{
|
|
UINT usWinNum = WVW_WHICH_WINDOW;
|
|
UINT uiCtrlId = HB_ISNIL( 2 ) ? 0 : hb_parni( 2 );
|
|
byte bStyle;
|
|
HWND hWndPB = FindControlHandle( usWinNum, WVW_CONTROL_PUSHBUTTON, uiCtrlId, &bStyle );
|
|
|
|
if( uiCtrlId == 0 || hWndPB == NULL )
|
|
return;
|
|
SetWindowText( hWndPB, hb_parcx( 3 ) );
|
|
hb_retl( TRUE );
|
|
}
|
|
|
|
HB_FUNC( WVW_PBVISIBLE )
|
|
{
|
|
UINT usWinNum = WVW_WHICH_WINDOW;
|
|
UINT uiCtrlId = HB_ISNIL( 2 ) ? 0 : hb_parni( 2 );
|
|
BOOL bEnable = HB_ISNIL( 3 ) ? TRUE : hb_parl( 3 );
|
|
byte bStyle;
|
|
HWND hWndPB = FindControlHandle( usWinNum, WVW_CONTROL_PUSHBUTTON, uiCtrlId, &bStyle );
|
|
int iCmdShow;
|
|
|
|
if( uiCtrlId == 0 || hWndPB == NULL )
|
|
{
|
|
hb_retl( FALSE );
|
|
return;
|
|
}
|
|
|
|
if( bEnable )
|
|
iCmdShow = SW_SHOW;
|
|
else
|
|
iCmdShow = SW_HIDE;
|
|
hb_retl( ShowWindow( hWndPB, iCmdShow ) == 0 );
|
|
}
|
|
|
|
HB_FUNC( WVW_CBVISIBLE )
|
|
{
|
|
UINT usWinNum = WVW_WHICH_WINDOW;
|
|
UINT uiCtrlId = HB_ISNIL( 2 ) ? 0 : hb_parni( 2 );
|
|
BOOL bEnable = HB_ISNIL( 3 ) ? TRUE : hb_parl( 3 );
|
|
byte bStyle;
|
|
HWND hWndCB = FindControlHandle( usWinNum, WVW_CONTROL_COMBOBOX, uiCtrlId, &bStyle );
|
|
int iCmdShow;
|
|
|
|
if( hWndCB )
|
|
{
|
|
if( bEnable )
|
|
iCmdShow = SW_SHOW;
|
|
else
|
|
iCmdShow = SW_HIDE;
|
|
hb_retl( ShowWindow( hWndCB, iCmdShow ) == 0 );
|
|
}
|
|
else
|
|
hb_retl( FALSE );
|
|
}
|
|
|
|
HB_FUNC( WVW_CXVISIBLE )
|
|
{
|
|
UINT usWinNum = WVW_WHICH_WINDOW;
|
|
UINT uiCtrlId = HB_ISNIL( 2 ) ? 0 : hb_parni( 2 );
|
|
BOOL bEnable = HB_ISNIL( 3 ) ? TRUE : hb_parl( 3 );
|
|
byte bStyle;
|
|
HWND hWndPB = FindControlHandle( usWinNum, WVW_CONTROL_PUSHBUTTON, uiCtrlId, &bStyle );
|
|
int iCmdShow;
|
|
|
|
if( uiCtrlId == 0 || hWndPB == NULL )
|
|
{
|
|
hb_retl( FALSE );
|
|
return;
|
|
}
|
|
|
|
if( bEnable )
|
|
iCmdShow = SW_SHOW;
|
|
else
|
|
iCmdShow = SW_HIDE;
|
|
hb_retl( ShowWindow( hWndPB, iCmdShow ) == 0 );
|
|
}
|
|
|
|
/* wvw_xbVisible( [nWinNum], nXBid, lShow )
|
|
* show/hide scrollbar nXBid in window nWinNum (default to topmost window)
|
|
* nWinNum better be NIL
|
|
* nXBid is the handle of the scrolbar
|
|
* lShow: .T. shows the scrolbar (default)
|
|
* .F. hides the scrolbar
|
|
* returns .t. if successful
|
|
*/
|
|
HB_FUNC( WVW_XBVISIBLE )
|
|
{
|
|
UINT usWinNum = WVW_WHICH_WINDOW;
|
|
UINT uiXBid = ( UINT ) ( HB_ISNIL( 2 ) ? 0 : hb_parni( 2 ) );
|
|
BOOL bShow = ( BOOL ) ( HB_ISLOG( 3 ) ? hb_parl( 3 ) : TRUE );
|
|
byte bStyle;
|
|
HWND hWndXB = uiXBid == 0 ? NULL : FindControlHandle( usWinNum, WVW_CONTROL_SCROLLBAR, uiXBid, &bStyle );
|
|
|
|
if( uiXBid == 0 || hWndXB == NULL )
|
|
{
|
|
hb_retl( FALSE );
|
|
return;
|
|
}
|
|
|
|
hb_retl( ShowScrollBar( hWndXB, SB_CTL, bShow ) );
|
|
}
|
|
|
|
|
|
HB_FUNC( WVW_MOUSE_COL )
|
|
{
|
|
WVW_DATA * pData = hb_getWvwData();
|
|
|
|
if( pData )
|
|
{
|
|
if( hb_gt_wvw_GetMainCoordMode() )
|
|
hb_retni( hb_gt_wvwGetMouseX( pData->s_pWindows[ pData->s_usNumWindows - 1 ] ) + hb_gt_wvwColOfs( pData->s_usNumWindows - 1 ) );
|
|
else
|
|
hb_retni( hb_gt_wvwGetMouseX( pData->s_pWindows[ pData->s_usCurWindow ] ) );
|
|
}
|
|
else
|
|
hb_retni( 0 );
|
|
}
|
|
|
|
|
|
HB_FUNC( WVW_MOUSE_ROW )
|
|
{
|
|
WVW_DATA * pData = hb_getWvwData();
|
|
|
|
if( pData )
|
|
{
|
|
if( hb_gt_wvw_GetMainCoordMode() )
|
|
hb_retni( hb_gt_wvwGetMouseY( pData->s_pWindows[ pData->s_usNumWindows - 1 ] ) + hb_gt_wvwRowOfs( pData->s_usNumWindows - 1 ) );
|
|
else
|
|
hb_retni( hb_gt_wvwGetMouseY( pData->s_pWindows[ pData->s_usCurWindow ] ) );
|
|
}
|
|
else
|
|
hb_retni( 0 );
|
|
}
|
|
|
|
HB_FUNC( SENDMESSAGE )
|
|
{
|
|
|
|
hb_retnl( ( LONG ) SendMessage(
|
|
( HWND ) HB_PARHANDLE( 1 ), /* handle of destination window */
|
|
( UINT ) hb_parni( 2 ), /* message to send */
|
|
( WPARAM ) hb_parnl( 3 ), /* first message parameter */
|
|
( HB_ISCHAR( 4 ) ) ? ( LPARAM ) hb_parc( 4 ) :
|
|
( LPARAM ) hb_parnl( 4 ) /* second message parameter */
|
|
) );
|
|
}
|
|
|
|
HB_FUNC( SETPARENT )
|
|
{
|
|
UINT usWinNum = WVW_WHICH_WINDOW;
|
|
UINT usWinNum1 = HB_ISNIL( 2 ) ? ( hb_gt_wvw_GetMainCoordMode() ? ( ( hb_gt_wvw_GetNumWindows() ) - 1 ) : hb_gt_wvw_GetCurWindow() ) : ( ( USHORT ) hb_parni( 2 ) );
|
|
WIN_DATA * pWindowData = hb_gt_wvw_GetWindowsData( usWinNum );
|
|
WIN_DATA * pWindowData1 = hb_gt_wvw_GetWindowsData( usWinNum1 );
|
|
HWND hWndParent = pWindowData->hWnd;
|
|
HWND hWndParent1 = pWindowData1->hWnd;
|
|
|
|
if( usWinNum1 != 0 )
|
|
SetParent( hWndParent, hWndParent1 );
|
|
}
|
|
|
|
|
|
HB_FUNC( BRINGTOTOP1 )
|
|
{
|
|
HWND hWnd = ( HWND ) HB_PARHANDLE( 1 );
|
|
|
|
#if 0
|
|
DWORD ForegroundThreadID;
|
|
DWORD ThisThreadID;
|
|
DWORD timeout;
|
|
#endif
|
|
|
|
if( IsIconic( hWnd ) )
|
|
{
|
|
ShowWindow( hWnd, SW_RESTORE );
|
|
hb_retl( TRUE );
|
|
return;
|
|
}
|
|
BringWindowToTop( hWnd ); /* IE 5.5 related hack */
|
|
SetForegroundWindow( hWnd );
|
|
}
|
|
|
|
HB_FUNC( ISWINDOW )
|
|
{
|
|
hb_retl( IsWindow( ( HWND ) HB_PARHANDLE( 1 ) ) );
|
|
}
|
|
|
|
|
|
HB_FUNC( ADDTOOLTIPEX ) /* changed by MAG */
|
|
{
|
|
/* HWND hWnd = ( HWND ) hb_parnl( 1 ); */
|
|
UINT usWinNum = WVW_WHICH_WINDOW;
|
|
WIN_DATA * pWindowData = hb_gt_wvw_GetWindowsData( usWinNum );
|
|
WVW_DATA * pData = hb_getWvwData();
|
|
|
|
int iStyle = TTS_ALWAYSTIP;
|
|
INITCOMMONCONTROLSEX icex = { 0 };
|
|
TOOLINFO ti = { 0 };
|
|
|
|
/* Load the tooltip class from the DLL.
|
|
*/
|
|
icex.dwSize = sizeof( icex );
|
|
icex.dwICC = ICC_BAR_CLASSES;
|
|
|
|
if( ! InitCommonControlsEx( &icex ) )
|
|
{
|
|
}
|
|
|
|
#if 0
|
|
if( lToolTipBalloon )
|
|
{
|
|
iStyle = iStyle | TTS_BALLOON;
|
|
}
|
|
#endif
|
|
|
|
if( ! pData->hWndTT )
|
|
pData->hWndTT = CreateWindow( TOOLTIPS_CLASS, ( LPSTR ) NULL, iStyle,
|
|
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
|
|
NULL, ( HMENU ) NULL, GetModuleHandle( NULL ), NULL );
|
|
if( ! pData->hWndTT )
|
|
{
|
|
hb_retnl( 0 );
|
|
return;
|
|
}
|
|
ti.uFlags = TTF_SUBCLASS | TTF_IDISHWND;
|
|
ti.hwnd = pWindowData->hWnd;
|
|
ti.uId = ( UINT ) hb_parnl( 2 );
|
|
/* ti.uId = ( UINT ) GetDlgItem( hWnd, hb_parni( 2 ) ); */
|
|
ti.hinst = GetModuleHandle( NULL );
|
|
ti.lpszText = ( LPSTR ) hb_parc( 3 );
|
|
|
|
hb_retl( SendMessage( pData->hWndTT, TTM_ADDTOOL, 0, ( LPARAM ) ( LPTOOLINFO ) &ti ) );
|
|
}
|
|
|
|
|
|
/*
|
|
* CreateImageList( array, cx, cy, nGrow, flags )
|
|
*/
|
|
HB_FUNC( CREATEIMAGELIST )
|
|
{
|
|
PHB_ITEM pArray = hb_param( 1, HB_IT_ARRAY );
|
|
UINT flags = HB_ISNIL( 5 ) ? ILC_COLOR : hb_parni( 5 );
|
|
HIMAGELIST himl;
|
|
ULONG ul, ulLen = hb_arrayLen( pArray );
|
|
HBITMAP hbmp;
|
|
|
|
himl = ImageList_Create( hb_parni( 2 ), hb_parni( 3 ), flags,
|
|
ulLen, hb_parni( 4 ) );
|
|
|
|
for( ul = 1; ul <= ulLen; ul++ )
|
|
{
|
|
hbmp = ( HBITMAP ) hb_arrayGetNL( pArray, ul );
|
|
ImageList_Add( himl, hbmp, ( HBITMAP ) NULL );
|
|
DeleteObject( hbmp );
|
|
}
|
|
|
|
HB_RETHANDLE( himl );
|
|
}
|
|
|
|
HB_FUNC( IMAGELIST_ADD )
|
|
{
|
|
hb_retnl( ImageList_Add( ( HIMAGELIST ) HB_PARHANDLE( 1 ), ( HBITMAP ) HB_PARHANDLE( 2 ), ( HBITMAP ) NULL ) );
|
|
}
|
|
|
|
HB_FUNC( IMAGELIST_ADDMASKED )
|
|
{
|
|
hb_retnl( ImageList_AddMasked( ( HIMAGELIST ) HB_PARHANDLE( 1 ), ( HBITMAP ) HB_PARHANDLE( 2 ), ( COLORREF ) hb_parnl( 3 ) ) );
|
|
}
|
|
|
|
|
|
HB_FUNC( GETBITMAPSIZE )
|
|
{
|
|
BITMAP bitmap;
|
|
PHB_ITEM aMetr = hb_itemArrayNew( 3 );
|
|
|
|
GetObject( ( HBITMAP ) HB_PARHANDLE( 1 ), sizeof( BITMAP ), ( LPVOID ) &bitmap );
|
|
|
|
hb_arraySetNL( aMetr, 1, bitmap.bmWidth );
|
|
hb_arraySetNL( aMetr, 2, bitmap.bmHeight );
|
|
hb_arraySetNL( aMetr, 3, bitmap.bmBitsPixel );
|
|
|
|
hb_itemReturnRelease( aMetr );
|
|
}
|
|
|
|
HB_FUNC( GETICONSIZE )
|
|
{
|
|
ICONINFO iinfo;
|
|
PHB_ITEM aMetr = hb_itemArrayNew( 2 );
|
|
|
|
GetIconInfo( ( HICON ) HB_PARHANDLE( 1 ), &iinfo );
|
|
|
|
hb_arraySetNL( aMetr, 1, iinfo.xHotspot * 2 );
|
|
hb_arraySetNL( aMetr, 2, iinfo.yHotspot * 2 );
|
|
|
|
hb_itemReturnRelease( aMetr );
|
|
}
|
|
|
|
|
|
HB_FUNC( LOADIMAGE )
|
|
{
|
|
if( HB_ISNUM( 2 ) )
|
|
hb_retnl( ( LONG )
|
|
LoadImage( hb_getWvwData()->hInstance, /* HB_ISNIL( 1 ) ? GetModuleHandle(NULL) : (HINSTANCE) hb_parnl( 1 ), handle of the instance that contains the image */
|
|
( LPCTSTR ) MAKEINTRESOURCE( hb_parnl( 2 ) ), /* name or identifier of image */
|
|
( UINT ) hb_parni( 3 ), /* type of image */
|
|
hb_parni( 4 ), /* desired width */
|
|
hb_parni( 5 ), /* desired height */
|
|
( UINT ) hb_parni( 6 ) /* load flags */
|
|
) );
|
|
|
|
else
|
|
HB_RETHANDLE(
|
|
LoadImage( ( HINSTANCE ) hb_parnl( 1 ), /* handle of the instance that contains the image */
|
|
( LPCTSTR ) hb_parc( 2 ), /* name or identifier of image */
|
|
( UINT ) hb_parni( 3 ), /* type of image */
|
|
hb_parni( 4 ), /* desired width */
|
|
hb_parni( 5 ), /* desired height */
|
|
( UINT ) hb_parni( 6 ) /* load flags */
|
|
) );
|
|
|
|
}
|
|
|
|
HB_FUNC( LOADBITMAP )
|
|
{
|
|
if( HB_ISNUM( 1 ) )
|
|
{
|
|
if( ! HB_ISNIL( 2 ) && hb_parl( 2 ) )
|
|
/* hb_retnl( (LONG) LoadBitmap( GetModuleHandle( NULL ), MAKEINTRESOURCE(hb_parnl( 1 ) )) ); */
|
|
HB_RETHANDLE( LoadBitmap( NULL, ( LPCTSTR ) hb_parnl( 1 ) ) );
|
|
else
|
|
HB_RETHANDLE( LoadBitmap( GetModuleHandle( NULL ), ( LPCTSTR ) hb_parnl( 1 ) ) );
|
|
}
|
|
else
|
|
HB_RETHANDLE( LoadBitmap( GetModuleHandle( NULL ), ( LPCTSTR ) hb_parc( 1 ) ) );
|
|
}
|
|
|
|
HB_FUNC( LOADBITMAPEX )
|
|
{
|
|
HINSTANCE h = HB_ISNUM( 1 ) ? ( HINSTANCE ) hb_parnl( 1 ) : GetModuleHandle( NULL );
|
|
|
|
if( HB_ISNUM( 1 ) && HB_ISNUM( 2 ) )
|
|
{
|
|
if( ! HB_ISNIL( 3 ) && hb_parl( 3 ) )
|
|
/* hb_retnl( (LONG) LoadBitmap( h, MAKEINTRESOURCE(hb_parnl( 2 ) )) ); */
|
|
HB_RETHANDLE( LoadBitmap( h, ( LPCTSTR ) hb_parnl( 3 ) ) );
|
|
else
|
|
HB_RETHANDLE( LoadBitmap( ( HINSTANCE ) h, ( LPCTSTR ) hb_parnl( 2 ) ) );
|
|
}
|
|
else
|
|
HB_RETHANDLE( LoadBitmap( h, ( LPCTSTR ) hb_parc( 2 ) ) );
|
|
}
|
|
|
|
|
|
HB_FUNC( OPENIMAGE )
|
|
{
|
|
const char * cFileName = hb_parc( 1 );
|
|
BOOL lString = HB_ISNIL( 2 ) ? 0 : hb_parl( 2 );
|
|
int iFileSize;
|
|
FILE * fp;
|
|
/* IPicture * pPic; */
|
|
LPPICTURE pPic;
|
|
IStream * pStream;
|
|
HGLOBAL hG;
|
|
HBITMAP hBitmap = 0;
|
|
|
|
if( lString )
|
|
{
|
|
iFileSize = hb_parclen( 1 );
|
|
hG = GlobalAlloc( GPTR, iFileSize );
|
|
if( ! hG )
|
|
{
|
|
hb_retnl( 0 );
|
|
return;
|
|
}
|
|
memcpy( ( void * ) hG, ( void * ) cFileName, iFileSize );
|
|
}
|
|
else
|
|
{
|
|
fp = fopen( cFileName, "rb" );
|
|
if( ! fp )
|
|
{
|
|
hb_retnl( 0 );
|
|
return;
|
|
}
|
|
|
|
fseek( fp, 0, SEEK_END );
|
|
iFileSize = ftell( fp );
|
|
hG = GlobalAlloc( GPTR, iFileSize );
|
|
if( ! hG )
|
|
{
|
|
fclose( fp );
|
|
hb_retnl( 0 );
|
|
return;
|
|
}
|
|
fseek( fp, 0, SEEK_SET );
|
|
fread( ( void * ) hG, 1, iFileSize, fp );
|
|
fclose( fp );
|
|
}
|
|
|
|
CreateStreamOnHGlobal( hG, 0, &pStream );
|
|
|
|
if( ! pStream )
|
|
{
|
|
GlobalFree( hG );
|
|
hb_retnl( 0 );
|
|
return;
|
|
}
|
|
|
|
#if 0
|
|
#if defined( __cplusplus )
|
|
OleLoadPicture( pStream, 0, 0, &IID_IPicture, ( void ** ) &pPic );
|
|
pStream->Release();
|
|
#else
|
|
OleLoadPicture( pStream, 0, 0, &IID_IPicture, ( void ** ) &pPic );
|
|
pStream->lpVtbl->Release( pStream );
|
|
#endif
|
|
#endif
|
|
|
|
GlobalFree( hG );
|
|
|
|
if( ! pPic )
|
|
{
|
|
hb_retnl( 0 );
|
|
return;
|
|
}
|
|
|
|
#if 0
|
|
#if defined( __cplusplus )
|
|
pPic->get_Handle( ( OLE_HANDLE * ) &hBitmap );
|
|
#else
|
|
pPic->lpVtbl->get_Handle( pPic, ( OLE_HANDLE * ) &hBitmap );
|
|
#endif
|
|
#endif
|
|
|
|
hb_retnl( ( LONG ) CopyImage( hBitmap, IMAGE_BITMAP, 0, 0, LR_COPYRETURNORG ) );
|
|
|
|
#if 0
|
|
#if defined( __cplusplus )
|
|
pPic->Release();
|
|
#else
|
|
pPic->lpVtbl->Release( pPic );
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
HB_FUNC( OPENBITMAP )
|
|
{
|
|
BITMAPFILEHEADER bmfh;
|
|
BITMAPINFOHEADER bmih;
|
|
LPBITMAPINFO lpbmi;
|
|
DWORD dwRead;
|
|
LPVOID lpvBits;
|
|
HGLOBAL hmem1, hmem2;
|
|
HBITMAP hbm;
|
|
HDC hDC = ( hb_pcount() > 1 && ! HB_ISNIL( 2 ) ) ? ( HDC ) HB_PARHANDLE( 2 ) : NULL;
|
|
HANDLE hfbm = CreateFile( hb_parc( 1 ), GENERIC_READ, FILE_SHARE_READ,
|
|
( LPSECURITY_ATTRIBUTES ) NULL, OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_READONLY, ( HANDLE ) NULL );
|
|
|
|
if( ( ( long int ) hfbm ) <= 0 )
|
|
{
|
|
HB_RETHANDLE( NULL );
|
|
return;
|
|
}
|
|
/* Retrieve the BITMAPFILEHEADER structure. */
|
|
ReadFile( hfbm, &bmfh, sizeof( BITMAPFILEHEADER ), &dwRead, NULL );
|
|
|
|
/* Retrieve the BITMAPFILEHEADER structure. */
|
|
ReadFile( hfbm, &bmih, sizeof( BITMAPINFOHEADER ), &dwRead, NULL );
|
|
|
|
/* Allocate memory for the BITMAPINFO structure. */
|
|
|
|
hmem1 = GlobalAlloc( GHND, sizeof( BITMAPINFOHEADER ) +
|
|
( ( 1 << bmih.biBitCount ) * sizeof( RGBQUAD ) ) );
|
|
lpbmi = ( LPBITMAPINFO ) GlobalLock( hmem1 );
|
|
|
|
/* Load BITMAPINFOHEADER into the BITMAPINFO structure. */
|
|
lpbmi->bmiHeader.biSize = bmih.biSize;
|
|
lpbmi->bmiHeader.biWidth = bmih.biWidth;
|
|
lpbmi->bmiHeader.biHeight = bmih.biHeight;
|
|
lpbmi->bmiHeader.biPlanes = bmih.biPlanes;
|
|
|
|
lpbmi->bmiHeader.biBitCount = bmih.biBitCount;
|
|
lpbmi->bmiHeader.biCompression = bmih.biCompression;
|
|
lpbmi->bmiHeader.biSizeImage = bmih.biSizeImage;
|
|
lpbmi->bmiHeader.biXPelsPerMeter = bmih.biXPelsPerMeter;
|
|
lpbmi->bmiHeader.biYPelsPerMeter = bmih.biYPelsPerMeter;
|
|
lpbmi->bmiHeader.biClrUsed = bmih.biClrUsed;
|
|
lpbmi->bmiHeader.biClrImportant = bmih.biClrImportant;
|
|
|
|
/* Retrieve the color table.
|
|
* 1 << bmih.biBitCount == 2 ^ bmih.biBitCount
|
|
*/
|
|
switch( bmih.biBitCount )
|
|
{
|
|
case 1:
|
|
case 4:
|
|
case 8:
|
|
ReadFile( hfbm, lpbmi->bmiColors,
|
|
( ( 1 << bmih.biBitCount ) * sizeof( RGBQUAD ) ),
|
|
&dwRead, ( LPOVERLAPPED ) NULL );
|
|
break;
|
|
|
|
case 16:
|
|
case 32:
|
|
if( bmih.biCompression == BI_BITFIELDS )
|
|
ReadFile( hfbm, lpbmi->bmiColors,
|
|
( 3 * sizeof( RGBQUAD ) ),
|
|
&dwRead, ( LPOVERLAPPED ) NULL );
|
|
break;
|
|
|
|
case 24:
|
|
break;
|
|
}
|
|
|
|
/* Allocate memory for the required number of bytes. */
|
|
hmem2 = GlobalAlloc( GHND, ( bmfh.bfSize - bmfh.bfOffBits ) );
|
|
lpvBits = GlobalLock( hmem2 );
|
|
|
|
/* Retrieve the bitmap data. */
|
|
|
|
ReadFile( hfbm, lpvBits, ( bmfh.bfSize - bmfh.bfOffBits ), &dwRead, NULL );
|
|
|
|
if( ! hDC )
|
|
hDC = GetDC( 0 );
|
|
|
|
/* Create a bitmap from the data stored in the .BMP file. */
|
|
hbm = CreateDIBitmap( hDC, &bmih, CBM_INIT, lpvBits, lpbmi, DIB_RGB_COLORS );
|
|
|
|
if( hb_pcount() < 2 || HB_ISNIL( 2 ) )
|
|
ReleaseDC( 0, hDC );
|
|
|
|
/* Unlock the global memory objects and close the .BMP file. */
|
|
GlobalUnlock( hmem1 );
|
|
GlobalUnlock( hmem2 );
|
|
GlobalFree( hmem1 );
|
|
GlobalFree( hmem2 );
|
|
CloseHandle( hfbm );
|
|
|
|
HB_RETHANDLE( hbm );
|
|
}
|
|
|
|
|
|
HB_FUNC( SETTEXTCOLOR )
|
|
{
|
|
COLORREF crColor = SetTextColor(
|
|
( HDC ) HB_PARHANDLE( 1 ), /* handle of device context */
|
|
( COLORREF ) hb_parnl( 2 ) /* text color */
|
|
);
|
|
|
|
hb_retnl( ( LONG ) crColor );
|
|
}
|
|
|
|
HB_FUNC( SETBKCOLOR )
|
|
{
|
|
COLORREF crColor = SetBkColor(
|
|
( HDC ) HB_PARHANDLE( 1 ), /* handle of device context */
|
|
( COLORREF ) hb_parnl( 2 ) /* text color */
|
|
);
|
|
|
|
hb_retnl( ( LONG ) crColor );
|
|
}
|
|
|
|
HB_FUNC( CREATESOLIDBRUSH )
|
|
{
|
|
HB_RETHANDLE( CreateSolidBrush(
|
|
( COLORREF ) hb_parnl( 1 ) /* brush color */
|
|
) );
|
|
}
|
|
|
|
HB_FUNC( CREATEHATCHBRUSH )
|
|
{
|
|
HB_RETHANDLE( CreateHatchBrush(
|
|
hb_parni( 1 ), ( COLORREF ) hb_parnl( 2 ) ) );
|
|
}
|
|
HB_FUNC( RGB )
|
|
{
|
|
hb_retnl( RGB( hb_parni( 1 ), hb_parni( 2 ), hb_parni( 3 ) ) );
|
|
}
|
|
|
|
HB_FUNC( GETSYSCOLOR )
|
|
{
|
|
hb_retnl( ( LONG ) GetSysColor( hb_parni( 1 ) ) );
|
|
}
|
|
|
|
HB_FUNC( REDRAWWINDOW )
|
|
{
|
|
RedrawWindow(
|
|
( HWND ) HB_PARHANDLE( 1 ), /* handle of window */
|
|
NULL, /* address of structure with update rectangle */
|
|
NULL, /* handle of update region */
|
|
( UINT ) hb_parni( 2 ) /* array of redraw flags */
|
|
);
|
|
}
|
|
|
|
/* CreateFont( fontName, nWidth, hHeight [,fnWeight] [,fdwCharSet],
|
|
[,fdwItalic] [,fdwUnderline] [,fdwStrikeOut] )
|
|
*/
|
|
HB_FUNC( CREATEFONT )
|
|
{
|
|
HFONT hFont;
|
|
int fnWeight = HB_ISNIL( 4 ) ? 0 : hb_parni( 4 );
|
|
DWORD fdwCharSet = HB_ISNIL( 5 ) ? 0 : hb_parnl( 5 );
|
|
DWORD fdwItalic = HB_ISNIL( 6 ) ? 0 : hb_parnl( 6 );
|
|
DWORD fdwUnderline = HB_ISNIL( 7 ) ? 0 : hb_parnl( 7 );
|
|
DWORD fdwStrikeOut = HB_ISNIL( 8 ) ? 0 : hb_parnl( 8 );
|
|
|
|
hFont = CreateFont(
|
|
hb_parni( 3 ), /* logical height of font */
|
|
hb_parni( 2 ), /* logical average character width */
|
|
0, /* angle of escapement */
|
|
0, /* base-line orientation angle */
|
|
fnWeight, /* font weight */
|
|
fdwItalic, /* italic attribute flag */
|
|
fdwUnderline, /* underline attribute flag */
|
|
fdwStrikeOut, /* strikeout attribute flag */
|
|
fdwCharSet, /* character set identifier */
|
|
0, /* output precision */
|
|
0, /* clipping precision */
|
|
0, /* output quality */
|
|
0, /* pitch and family */
|
|
( LPCTSTR ) hb_parc( 1 ) /* pointer to typeface name string */
|
|
);
|
|
HB_RETHANDLE( hFont );
|
|
}
|
|
|
|
|
|
HB_FUNC( SELECTFONT )
|
|
{
|
|
|
|
CHOOSEFONT cf;
|
|
LOGFONT lf;
|
|
HFONT hfont;
|
|
PHB_ITEM pObj = HB_ISNIL( 1 ) ? NULL : hb_param( 1, HB_IT_OBJECT );
|
|
/* PHB_ITEM temp1; */
|
|
PHB_ITEM aMetr = hb_itemArrayNew( 9 );
|
|
|
|
cf.lStructSize = sizeof( CHOOSEFONT );
|
|
cf.hwndOwner = ( HWND ) NULL;
|
|
cf.hDC = ( HDC ) NULL;
|
|
cf.lpLogFont = &lf;
|
|
cf.iPointSize = 0;
|
|
cf.Flags = CF_SCREENFONTS | ( ( pObj ) ? CF_INITTOLOGFONTSTRUCT : 0 );
|
|
cf.rgbColors = RGB( 0, 0, 0 );
|
|
cf.lCustData = 0L;
|
|
cf.lpfnHook = ( LPCFHOOKPROC ) NULL;
|
|
cf.lpTemplateName = ( LPSTR ) NULL;
|
|
|
|
cf.hInstance = ( HINSTANCE ) NULL;
|
|
cf.lpszStyle = ( LPSTR ) NULL;
|
|
cf.nFontType = SCREEN_FONTTYPE;
|
|
cf.nSizeMin = 0;
|
|
cf.nSizeMax = 0;
|
|
|
|
/* Display the CHOOSEFONT common-dialog box. */
|
|
|
|
if( ! ChooseFont( &cf ) )
|
|
{
|
|
hb_itemRelease( aMetr );
|
|
hb_ret();
|
|
return;
|
|
}
|
|
|
|
/* Create a logical font based on the user's */
|
|
/* selection and return a handle identifying */
|
|
/* that font. */
|
|
|
|
hfont = CreateFontIndirect( cf.lpLogFont );
|
|
|
|
hb_arraySetNInt( aMetr, 1, ( HB_PTRUINT ) hfont );
|
|
hb_arraySetC( aMetr, 2, lf.lfFaceName );
|
|
hb_arraySetNL( aMetr, 3, lf.lfWidth );
|
|
hb_arraySetNL( aMetr, 4, lf.lfHeight );
|
|
hb_arraySetNL( aMetr, 5, lf.lfWeight );
|
|
hb_arraySetNI( aMetr, 6, lf.lfCharSet );
|
|
hb_arraySetNI( aMetr, 7, lf.lfItalic );
|
|
hb_arraySetNI( aMetr, 8, lf.lfUnderline );
|
|
hb_arraySetNI( aMetr, 9, lf.lfStrikeOut );
|
|
|
|
hb_itemReturnRelease( aMetr );
|
|
|
|
}
|
|
|
|
HB_FUNC( INVALIDATERECT )
|
|
{
|
|
RECT rc;
|
|
|
|
if( hb_pcount() > 2 )
|
|
{
|
|
rc.left = hb_parni( 3 );
|
|
rc.top = hb_parni( 4 );
|
|
rc.right = hb_parni( 5 );
|
|
rc.bottom = hb_parni( 6 );
|
|
}
|
|
|
|
InvalidateRect(
|
|
( HWND ) HB_PARHANDLE( 1 ), /* handle of window with changed update region */
|
|
( hb_pcount() > 2 ) ? &rc : NULL, /* address of rectangle coordinates */
|
|
hb_parni( 2 ) /* erase-background flag */
|
|
);
|
|
}
|
|
|
|
HB_FUNC( TOOLBARADDBUTTONS )
|
|
{
|
|
|
|
UINT usWinNum = WVW_WHICH_WINDOW;
|
|
WIN_DATA * pWindowData = hb_gt_wvw_GetWindowsData( usWinNum );
|
|
|
|
HWND hWndCtrl = ( HWND ) HB_PARHANDLE( 2 );
|
|
/* HWND hToolTip = ( HWND ) hb_parnl( 5 ) ; */
|
|
PHB_ITEM pArray = hb_param( 3, HB_IT_ARRAY );
|
|
int iButtons = hb_parni( 4 );
|
|
TBBUTTON * tb = ( struct _TBBUTTON * ) hb_xgrab( iButtons * sizeof( TBBUTTON ) );
|
|
PHB_ITEM pTemp;
|
|
/* BOOL bSystem; */
|
|
|
|
ULONG ulCount;
|
|
ULONG ulID;
|
|
DWORD style = GetWindowLong( hWndCtrl, GWL_STYLE );
|
|
USHORT usOldHeight;
|
|
|
|
SetWindowLong( hWndCtrl, GWL_STYLE, style | TBSTYLE_TOOLTIPS | TBSTYLE_FLAT );
|
|
|
|
SendMessage( hWndCtrl, TB_BUTTONSTRUCTSIZE, sizeof( TBBUTTON ), 0L );
|
|
usOldHeight = pWindowData->usTBHeight;
|
|
for( ulCount = 0; ( ulCount < hb_arrayLen( pArray ) ); ulCount++ )
|
|
{
|
|
|
|
pTemp = hb_arrayGetItemPtr( pArray, ulCount + 1 );
|
|
ulID = hb_arrayGetNI( pTemp, 1 );
|
|
/* bSystem = hb_arrayGetL( pTemp, 9 ); */
|
|
|
|
#if 0
|
|
if( bSystem )
|
|
if( ulID > 0 && ulID < 31 )
|
|
{
|
|
tb[ ulCount ].iBitmap = ulID > 0 ? ( int ) ulID : -1;
|
|
}
|
|
else
|
|
{
|
|
tb[ ulCount ].iBitmap = ulID > 0 ? ( int ) ulCount : -1;
|
|
}
|
|
#endif
|
|
tb[ ulCount ].idCommand = hb_arrayGetNI( pTemp, 2 );
|
|
tb[ ulCount ].fsState = ( BYTE ) hb_arrayGetNI( pTemp, 3 );
|
|
tb[ ulCount ].fsStyle = ( BYTE ) hb_arrayGetNI( pTemp, 4 );
|
|
tb[ ulCount ].dwData = hb_arrayGetNI( pTemp, 5 );
|
|
tb[ ulCount ].iString = hb_arrayGetCLen( pTemp, 6 ) > 0 ? ( int ) hb_arrayGetCPtr( pTemp, 6 ) : 0;
|
|
|
|
}
|
|
|
|
SendMessage( hWndCtrl, TB_ADDBUTTONS, ( WPARAM ) iButtons, ( LPARAM ) ( LPTBBUTTON ) tb );
|
|
SendMessage( hWndCtrl, TB_AUTOSIZE, 0, 0 );
|
|
hb_gt_wvwTBinitSize( pWindowData, hWndCtrl );
|
|
|
|
if( pWindowData->usTBHeight != usOldHeight )
|
|
hb_gt_wvwResetWindow( usWinNum );
|
|
|
|
hb_xfree( tb );
|
|
}
|
|
|
|
HB_FUNC( SETBITMAPRESOURCEID )
|
|
{
|
|
UINT usWinNum = WVW_WHICH_WINDOW;
|
|
WIN_DATA * pWindowData = hb_gt_wvw_GetWindowsData( usWinNum );
|
|
TBADDBITMAP tbab;
|
|
HBITMAP hBitmap = ( HBITMAP ) HB_PARHANDLE( 3 );
|
|
UINT uiBitmap = ( UINT ) hb_parni( 4 );
|
|
HWND hWndToolbar = pWindowData->hToolBar;
|
|
int iNewBitmap;
|
|
int iBitmapType = hb_parni( 2 );
|
|
int iOffset;
|
|
|
|
|
|
switch( iBitmapType )
|
|
{
|
|
case 0:
|
|
iOffset = 0;
|
|
break;
|
|
case 1:
|
|
iOffset = pWindowData->iStartStdBitmap;
|
|
break;
|
|
case 2:
|
|
iOffset = pWindowData->iStartViewBitmap;
|
|
break;
|
|
case 3:
|
|
iOffset = pWindowData->iStartHistBitmap;
|
|
break;
|
|
default:
|
|
iOffset = 0;
|
|
break;
|
|
}
|
|
|
|
if( iBitmapType == 0 )
|
|
{
|
|
|
|
|
|
tbab.hInst = NULL;
|
|
tbab.nID = ( UINT ) hBitmap;
|
|
iNewBitmap = SendMessage( hWndToolbar, TB_ADDBITMAP, ( WPARAM ) 1, ( WPARAM ) &tbab );
|
|
|
|
}
|
|
else /* system bitmap */
|
|
iNewBitmap = ( int ) uiBitmap + iOffset;
|
|
hb_retni( iNewBitmap );
|
|
|
|
}
|
|
|
|
|
|
HB_FUNC( DRAWICON )
|
|
{
|
|
DrawIcon( ( HDC ) HB_PARHANDLE( 1 ), hb_parni( 3 ), hb_parni( 4 ), ( HICON ) HB_PARHANDLE( 2 ) );
|
|
}
|
|
|
|
HB_FUNC( LOADICON )
|
|
{
|
|
if( HB_ISNUM( 1 ) )
|
|
HB_RETHANDLE( LoadIcon( NULL, ( LPCTSTR ) hb_parnl( 1 ) ) );
|
|
else
|
|
HB_RETHANDLE( LoadIcon( GetModuleHandle( NULL ), ( LPCTSTR ) hb_parc( 1 ) ) );
|
|
}
|
|
HB_FUNC( DRAWBITMAP )
|
|
{
|
|
HDC hDC = ( HDC ) HB_PARHANDLE( 1 );
|
|
HDC hDCmem = CreateCompatibleDC( hDC );
|
|
DWORD dwraster = HB_ISNIL( 3 ) ? SRCCOPY : hb_parnl( 3 );
|
|
HBITMAP hBitmap = ( HBITMAP ) HB_PARHANDLE( 2 );
|
|
BITMAP bitmap;
|
|
int nWidthDest = ( hb_pcount() >= 5 && ! HB_ISNIL( 6 ) ) ? hb_parni( 6 ) : 0;
|
|
int nHeightDest = ( hb_pcount() >= 6 && ! HB_ISNIL( 7 ) ) ? hb_parni( 7 ) : 0;
|
|
|
|
SelectObject( hDCmem, hBitmap );
|
|
GetObject( hBitmap, sizeof( BITMAP ), ( LPVOID ) &bitmap );
|
|
if( nWidthDest && ( nWidthDest != bitmap.bmWidth || nHeightDest != bitmap.bmHeight ) )
|
|
StretchBlt( hDC, hb_parni( 4 ), hb_parni( 5 ), nWidthDest, nHeightDest, hDCmem,
|
|
0, 0, bitmap.bmWidth, bitmap.bmHeight, dwraster );
|
|
else
|
|
BitBlt( hDC, hb_parni( 4 ), hb_parni( 5 ), bitmap.bmWidth, bitmap.bmHeight, hDCmem, 0, 0, dwraster );
|
|
|
|
DeleteDC( hDCmem );
|
|
}
|
|
HB_FUNC( WINDOW2BITMAP )
|
|
{
|
|
HWND hWnd = ( HWND ) HB_PARHANDLE( 1 );
|
|
BOOL lFull = HB_ISNIL( 2 ) ? 0 : ( BOOL ) hb_parl( 2 );
|
|
HDC hDC = lFull ? GetWindowDC( hWnd ) : GetDC( hWnd );
|
|
HDC hDCmem = CreateCompatibleDC( hDC );
|
|
HBITMAP hBitmap;
|
|
RECT rc;
|
|
|
|
if( lFull )
|
|
GetWindowRect( hWnd, &rc );
|
|
else
|
|
GetClientRect( hWnd, &rc );
|
|
|
|
hBitmap = CreateCompatibleBitmap( hDC, rc.right - rc.left, rc.bottom - rc.top );
|
|
SelectObject( hDCmem, hBitmap );
|
|
|
|
BitBlt( hDCmem, 0, 0, rc.right - rc.left, rc.bottom - rc.top, hDC, 0, 0, SRCCOPY );
|
|
|
|
DeleteDC( hDCmem );
|
|
DeleteDC( hDC );
|
|
HB_RETHANDLE( hBitmap );
|
|
}
|
|
|
|
|
|
/* wvw_SetMaxBMCache([nMax])
|
|
Get/Set maximum user-bitmap cache (default is 20, minimum is 1).
|
|
Returns old setting of maximum user-bitmap cache.
|
|
|
|
Description:
|
|
To minimize bitmap loading operation, wvw_drawimage caches bitmap once
|
|
it reads from disk.
|
|
Ie., subsequent wvw_drawimage will use the bitmap from the memory.
|
|
When the maximum number of cache is used, the least recently opened bitmap
|
|
will be discarded from the cache.
|
|
|
|
Remarks:
|
|
There is no way to discard a specific bitmap from the cache.
|
|
If you want to control bitmap caching manually, use wvw_LoadPicture()
|
|
instead.
|
|
|
|
Example:
|
|
wvw_SetMaxBMCache(1) :: this will cache one bitmap only
|
|
wvw_SetMaxBMCache(50) :: allows up to 50 bitmap stored in the cache
|
|
*/
|
|
HB_FUNC( WVW_SETMAXBMCACHE )
|
|
{
|
|
WVW_DATA * p = hb_getWvwData();
|
|
UINT uiOldMaxBMcache = 0;
|
|
|
|
if( p )
|
|
{
|
|
uiOldMaxBMcache = p->s_sApp->uiMaxBMcache;
|
|
|
|
if( ! HB_ISNIL( 1 ) )
|
|
p->s_sApp->uiMaxBMcache = ( UINT ) hb_parni( 1 );
|
|
}
|
|
|
|
hb_retni( uiOldMaxBMcache );
|
|
}
|
|
|
|
/* wvw_NumBMCache()
|
|
Returns current number of user-bitmap cache.
|
|
*/
|
|
HB_FUNC( WVW_NUMBMCACHE )
|
|
{
|
|
WVW_DATA * p = hb_getWvwData();
|
|
|
|
hb_retni( p ? p->s_sApp->uiBMcache : 0 );
|
|
}
|
|
|
|
|
|
/* */
|
|
/* Miscellaneous xHarbour callable functions */
|
|
/* Budyanto Dj. <budyanto@centrin.net.id> */
|
|
/* */
|
|
|
|
|
|
/* TIMER */
|
|
|
|
|
|
/*wvw_SetTimer([nWinNum], nInterval)
|
|
* set timer event for every nInterval millisec
|
|
*(effective only if WVW_TIMER() function exists)
|
|
* eg. it can be usefull to update clock on status bar
|
|
* returns .t. if successfull
|
|
*/
|
|
/*20040602: WARNING: WVT is slightly different*/
|
|
HB_FUNC( WVW_SETTIMER )
|
|
{
|
|
WVW_DATA * p = hb_getWvwData();
|
|
|
|
if( p && p->s_sApp->pSymWVW_TIMER )
|
|
{
|
|
UINT usWinNum = WVW_WHICH_WINDOW;
|
|
WIN_DATA * pWindowData = hb_gt_wvw_GetWindowsData( usWinNum );
|
|
|
|
SetTimer( pWindowData->hWnd, WVW_ID_BASE_TIMER + usWinNum, ( UINT ) hb_parni( 2 ), NULL );
|
|
|
|
hb_retl( TRUE );
|
|
}
|
|
else
|
|
hb_retl( FALSE );
|
|
}
|
|
|
|
/*wvw_KillTimer([nWinNum])
|
|
* kill the timer event handler for window nWinNum
|
|
* returns .t. if successfull
|
|
*/
|
|
/*20040602: WARNING: WVT is slightly different */
|
|
HB_FUNC( WVW_KILLTIMER )
|
|
{
|
|
WVW_DATA * p = hb_getWvwData();
|
|
|
|
if( p && p->s_sApp->pSymWVW_TIMER )
|
|
{
|
|
UINT usWinNum = WVW_WHICH_WINDOW;
|
|
WIN_DATA * pWindowData = hb_gt_wvw_GetWindowsData( usWinNum );
|
|
|
|
KillTimer( pWindowData->hWnd, WVW_ID_BASE_TIMER + usWinNum );
|
|
hb_retl( TRUE );
|
|
}
|
|
else
|
|
hb_retl( FALSE );
|
|
}
|
|
|
|
|
|
/*wvw_GetPaintRect( nWinNum ) nWinNum is 0 based */
|
|
/*returns array of paint pending rect {top, left, bottom, right} */
|
|
/*WARNING: */
|
|
/*unlike WVT, top maybe > bottom */
|
|
/* left maybe > right */
|
|
/*in these cases, no paint request is pending */
|
|
/*(in WVT these is reflected in {0,0,0,0}) */
|
|
HB_FUNC( WVW_GETPAINTRECT )
|
|
{
|
|
UINT usWinNum = WVW_WHICH_WINDOW;
|
|
|
|
WIN_DATA * pWindowData = hb_gt_wvw_GetWindowsData( usWinNum );
|
|
RECT rPaintRect = pWindowData->rPaintPending;
|
|
PHB_ITEM info = hb_itemArrayNew( 4 );
|
|
|
|
hb_arraySetNI( info, 1, rPaintRect.top );
|
|
hb_arraySetNI( info, 2, rPaintRect.left );
|
|
hb_arraySetNI( info, 3, rPaintRect.bottom );
|
|
hb_arraySetNI( info, 4, rPaintRect.right );
|
|
|
|
hb_itemReturnRelease( info );
|
|
}
|
|
|
|
|
|
HB_FUNC( WVW_SETPOINTER )
|
|
{
|
|
UINT usWinNum = WVW_WHICH_WINDOW;
|
|
WIN_DATA * pWindowData = hb_gt_wvw_GetWindowsData( usWinNum );
|
|
int iCursor = hb_parni( 2 );
|
|
HCURSOR hCursor;
|
|
|
|
switch( iCursor )
|
|
{
|
|
case 1:
|
|
hCursor = LoadCursor( NULL, IDC_ARROW );
|
|
break;
|
|
|
|
case 2:
|
|
hCursor = LoadCursor( NULL, IDC_IBEAM );
|
|
break;
|
|
|
|
case 3:
|
|
hCursor = LoadCursor( NULL, IDC_WAIT );
|
|
break;
|
|
|
|
case 4:
|
|
hCursor = LoadCursor( NULL, IDC_CROSS );
|
|
break;
|
|
|
|
case 5:
|
|
hCursor = LoadCursor( NULL, IDC_UPARROW );
|
|
break;
|
|
|
|
case 6:
|
|
hCursor = LoadCursor( NULL, IDC_SIZE );
|
|
break;
|
|
|
|
case 7:
|
|
hCursor = LoadCursor( NULL, IDC_ICON );
|
|
break;
|
|
|
|
case 8:
|
|
hCursor = LoadCursor( NULL, IDC_SIZENWSE );
|
|
break;
|
|
|
|
case 9:
|
|
hCursor = LoadCursor( NULL, IDC_SIZENESW );
|
|
break;
|
|
|
|
case 10:
|
|
hCursor = LoadCursor( NULL, IDC_SIZEWE );
|
|
break;
|
|
|
|
case 11:
|
|
hCursor = LoadCursor( NULL, IDC_SIZENS );
|
|
break;
|
|
|
|
case 12:
|
|
hCursor = LoadCursor( NULL, IDC_SIZEALL );
|
|
break;
|
|
|
|
case 13:
|
|
hCursor = LoadCursor( NULL, IDC_NO );
|
|
break;
|
|
|
|
case 14:
|
|
hCursor = LoadCursor( NULL, IDC_HAND );
|
|
break;
|
|
|
|
case 15:
|
|
hCursor = LoadCursor( NULL, IDC_APPSTARTING );
|
|
break;
|
|
|
|
case 16:
|
|
hCursor = LoadCursor( NULL, IDC_HELP );
|
|
break;
|
|
|
|
default:
|
|
hCursor = LoadCursor( NULL, IDC_ARROW );
|
|
break;
|
|
}
|
|
|
|
SetClassLongPtr( pWindowData->hWnd, GCLP_HCURSOR, ( LONG_PTR ) hCursor );
|
|
}
|
|
|
|
|
|
/* */
|
|
/* wvw_LoadPicture( nSlot, cFilePic ) */
|
|
/* */
|
|
HB_FUNC( WVW_LOADPICTURE )
|
|
{
|
|
BOOL bResult = FALSE;
|
|
|
|
WVW_DATA * p = hb_getWvwData();
|
|
IPicture * iPicture = hb_gt_wvwLoadPicture( hb_parcx( 2 ) );
|
|
|
|
if( p && iPicture )
|
|
{
|
|
int iSlot = hb_parni( 1 ) - 1;
|
|
|
|
if( p->s_sApp->iPicture[ iSlot ] )
|
|
hb_gt_wvwDestroyPicture( p->s_sApp->iPicture[ iSlot ] );
|
|
|
|
p->s_sApp->iPicture[ iSlot ] = iPicture;
|
|
|
|
bResult = TRUE;
|
|
}
|
|
|
|
hb_retl( bResult );
|
|
}
|
|
|
|
|
|
/* */
|
|
/* wvw_LoadFont( nSlotFont, cFontFace, nHeight, nWidth, nWeight, lItalic, lUnderline, lStrikeout, */
|
|
/* nCharSet, nQuality, nEscapement ) */
|
|
/* */
|
|
HB_FUNC( WVW_LOADFONT )
|
|
{
|
|
WVW_DATA * p = hb_getWvwData();
|
|
|
|
if( p )
|
|
{
|
|
UINT usWinNum = p->s_usNumWindows - 1;
|
|
WIN_DATA * pWindowData = hb_gt_wvw_GetWindowsData( usWinNum );
|
|
LOGFONT logfont;
|
|
int iSlot = hb_parni( 1 ) - 1;
|
|
HFONT hFont;
|
|
|
|
logfont.lfEscapement = HB_ISNIL( 11 ) ? 0 : ( hb_parni( 11 ) * 10 );
|
|
logfont.lfOrientation = 0;
|
|
logfont.lfWeight = HB_ISNIL( 5 ) ? 0 : hb_parni( 5 );
|
|
logfont.lfItalic = HB_ISNIL( 6 ) ? 0 : ( BYTE ) hb_parl( 6 );
|
|
logfont.lfUnderline = HB_ISNIL( 7 ) ? 0 : ( BYTE ) hb_parl( 7 );
|
|
logfont.lfStrikeOut = HB_ISNIL( 8 ) ? 0 : ( BYTE ) hb_parl( 8 );
|
|
logfont.lfCharSet = HB_ISNIL( 9 ) ? ( BYTE ) pWindowData->CodePage : ( BYTE ) hb_parni( 9 );
|
|
logfont.lfOutPrecision = 0;
|
|
logfont.lfClipPrecision = 0;
|
|
logfont.lfQuality = HB_ISNIL( 10 ) ? ( BYTE ) DEFAULT_QUALITY : ( BYTE ) hb_parni( 10 );
|
|
logfont.lfPitchAndFamily = FF_DONTCARE;
|
|
logfont.lfHeight = HB_ISNIL( 3 ) ? pWindowData->fontHeight : hb_parni( 3 );
|
|
logfont.lfWidth = HB_ISNIL( 4 ) ? ( pWindowData->fontWidth < 0 ? -pWindowData->fontWidth : pWindowData->fontWidth ) : hb_parni( 4 );
|
|
|
|
strcpy( logfont.lfFaceName, HB_ISNIL( 2 ) ? pWindowData->fontFace : hb_parcx( 2 ) );
|
|
|
|
hFont = CreateFontIndirect( &logfont );
|
|
if( hFont )
|
|
{
|
|
if( p->s_sApp->hUserFonts[ iSlot ] )
|
|
DeleteObject( ( HFONT ) p->s_sApp->hUserFonts[ iSlot ] );
|
|
p->s_sApp->hUserFonts[ iSlot ] = hFont;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* */
|
|
/* wvw_LoadPen( nSlot, nStyle, nWidth, nRGBColor ) */
|
|
/* */
|
|
HB_FUNC( WVW_LOADPEN )
|
|
{
|
|
WVW_DATA * p = hb_getWvwData();
|
|
int iPenWidth, iPenStyle;
|
|
COLORREF crColor;
|
|
HPEN hPen;
|
|
int iSlot = hb_parni( 1 ) - 1;
|
|
|
|
iPenStyle = HB_ISNIL( 2 ) ? 0 : hb_parni( 2 );
|
|
iPenWidth = HB_ISNIL( 3 ) ? 0 : hb_parni( 3 );
|
|
crColor = HB_ISNIL( 4 ) ? RGB( 0, 0, 0 ) : ( COLORREF ) hb_parnl( 4 );
|
|
|
|
hPen = CreatePen( iPenStyle, iPenWidth, crColor );
|
|
|
|
if( hPen )
|
|
{
|
|
if( p->s_sApp->hUserPens[ iSlot ] )
|
|
DeleteObject( ( HPEN ) p->s_sApp->hUserPens[ iSlot ] );
|
|
p->s_sApp->hUserPens[ iSlot ] = hPen;
|
|
|
|
hb_retl( TRUE );
|
|
}
|
|
else
|
|
hb_retl( FALSE );
|
|
}
|
|
|
|
|
|
HB_FUNC( WVW_MESSAGEBOX )
|
|
{
|
|
UINT usWinNum = WVW_WHICH_WINDOW;
|
|
WIN_DATA * pWindowData = hb_gt_wvw_GetWindowsData( usWinNum );
|
|
|
|
hb_retni( MessageBox( pWindowData->hWnd, hb_parcx( 2 ), hb_parcx( 3 ), HB_ISNIL( 4 ) ? MB_OK : hb_parni( 4 ) ) );
|
|
}
|
|
|
|
|
|
/* End of Drawing Primitives */
|
|
|
|
/* */
|
|
/* Utility Functions . A Natural Extension */
|
|
/* copied and modified from gtwvt */
|
|
|
|
|
|
/* */
|
|
/* wvw_ChooseFont( cFontName, nHeight, nWidth, nWeight, nQuality, ; */
|
|
/* lItalic, lUnderline, lStrikeout ) */
|
|
/* */
|
|
|
|
HB_FUNC( WVW_CHOOSEFONT )
|
|
{
|
|
|
|
CHOOSEFONT cf = { 0 };
|
|
LOGFONT lf = { 0 };
|
|
LONG PointSize = 0;
|
|
WVW_DATA * p = hb_getWvwData();
|
|
|
|
if( ! HB_ISNIL( 2 ) )
|
|
PointSize = -MulDiv( ( LONG ) hb_parnl( 2 ), GetDeviceCaps( p->s_pWindows[ p->s_usNumWindows - 1 ]->hdc, LOGPIXELSY ), 72 );
|
|
|
|
lf.lfHeight = PointSize;
|
|
lf.lfWidth = HB_ISNIL( 3 ) ? 0 : hb_parni( 3 );
|
|
lf.lfWeight = HB_ISNIL( 4 ) ? 0 : hb_parni( 4 );
|
|
lf.lfItalic = HB_ISNIL( 6 ) ? 0 : ( BYTE ) hb_parl( 6 );
|
|
lf.lfUnderline = HB_ISNIL( 7 ) ? 0 : ( BYTE ) hb_parl( 7 );
|
|
lf.lfStrikeOut = HB_ISNIL( 8 ) ? 0 : ( BYTE ) hb_parl( 8 );
|
|
lf.lfCharSet = DEFAULT_CHARSET;
|
|
lf.lfQuality = HB_ISNIL( 5 ) ? DEFAULT_QUALITY : ( BYTE ) hb_parni( 5 );
|
|
lf.lfPitchAndFamily = FF_DONTCARE;
|
|
if( HB_ISCHAR( 1 ) )
|
|
strcpy( lf.lfFaceName, hb_parcx( 1 ) );
|
|
|
|
cf.lStructSize = sizeof( CHOOSEFONT );
|
|
cf.hwndOwner = p->s_pWindows[ p->s_usNumWindows - 1 ]->hWnd;
|
|
cf.hDC = ( HDC ) NULL;
|
|
cf.lpLogFont = &lf;
|
|
cf.iPointSize = 0;
|
|
cf.Flags = CF_SCREENFONTS | CF_EFFECTS | CF_SHOWHELP | CF_INITTOLOGFONTSTRUCT;
|
|
cf.rgbColors = RGB( 0, 0, 0 );
|
|
cf.lCustData = 0L;
|
|
cf.lpfnHook = ( LPCFHOOKPROC ) NULL;
|
|
cf.lpTemplateName = ( LPSTR ) NULL;
|
|
cf.hInstance = ( HINSTANCE ) NULL;
|
|
cf.lpszStyle = ( LPSTR ) NULL;
|
|
cf.nFontType = SCREEN_FONTTYPE;
|
|
cf.nSizeMin = 0;
|
|
cf.nSizeMax = 0;
|
|
|
|
if( ChooseFont( &cf ) )
|
|
{
|
|
PointSize = -MulDiv( lf.lfHeight, 72, GetDeviceCaps( p->s_pWindows[ p->s_usNumWindows - 1 ]->hdc, LOGPIXELSY ) );
|
|
|
|
hb_reta( 8 );
|
|
|
|
hb_storvc( lf.lfFaceName, -1, 1 );
|
|
hb_storvnl( ( LONG ) PointSize, -1, 2 );
|
|
hb_storvni( lf.lfWidth, -1, 3 );
|
|
hb_storvni( lf.lfWeight, -1, 4 );
|
|
hb_storvni( lf.lfQuality, -1, 5 );
|
|
hb_storvl( lf.lfItalic, -1, 6 );
|
|
hb_storvl( lf.lfUnderline, -1, 7 );
|
|
hb_storvl( lf.lfStrikeOut, -1, 8 );
|
|
}
|
|
else
|
|
{
|
|
hb_reta( 8 );
|
|
|
|
hb_storvc( "", -1, 1 );
|
|
hb_storvnl( ( LONG ) 0, -1, 2 );
|
|
hb_storvni( 0, -1, 3 );
|
|
hb_storvni( 0, -1, 4 );
|
|
hb_storvni( 0, -1, 5 );
|
|
hb_storvl( 0, -1, 6 );
|
|
hb_storvl( 0, -1, 7 );
|
|
hb_storvl( 0, -1, 8 );
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/* */
|
|
/* wvw_ChooseColor( nRGBInit, aRGB16, nFlags ) => nRGBSelected */
|
|
/* */
|
|
|
|
HB_FUNC( WVW_CHOOSECOLOR )
|
|
{
|
|
|
|
CHOOSECOLOR cc;
|
|
COLORREF crCustClr[ 16 ];
|
|
int i;
|
|
WVW_DATA * p = hb_getWvwData();
|
|
|
|
for( i = 0; i < 16; i++ )
|
|
crCustClr[ i ] = HB_ISARRAY( 2 ) ? ( COLORREF ) hb_parvnl( 2, i + 1 ) : GetSysColor( COLOR_BTNFACE );
|
|
|
|
cc.lStructSize = sizeof( CHOOSECOLOR );
|
|
cc.hwndOwner = p->s_pWindows[ p->s_usNumWindows - 1 ]->hWnd;
|
|
cc.rgbResult = HB_ISNIL( 1 ) ? 0 : ( COLORREF ) hb_parnl( 1 );
|
|
cc.lpCustColors = crCustClr;
|
|
|
|
cc.Flags = ( WORD ) ( HB_ISNIL( 3 ) ? CC_ANYCOLOR | CC_RGBINIT | CC_FULLOPEN : hb_parnl( 3 ) );
|
|
|
|
if( ChooseColor( &cc ) )
|
|
hb_retnl( cc.rgbResult );
|
|
else
|
|
hb_retnl( -1 );
|
|
}
|
|
|
|
|
|
/*wvw_SetMousePos( nWinNum, nRow, nCol ) nWinNum is 0 based */
|
|
/*WHAT'S the difference with GT_FUNC( mouse_SetPos ) ??? */
|
|
/*this func is able to position cursor on any window */
|
|
|
|
/*NOTE: consider using 'standard' SetMouse() instead: */
|
|
/* SetMouse(.t., nRow, nCol) */
|
|
/* This will treat (nRow,nCol) according to current s_pWvwData->s_bMainCoordMode setting */
|
|
|
|
HB_FUNC( WVW_SETMOUSEPOS )
|
|
{
|
|
POINT xy = { 0 };
|
|
UINT usWinNum = WVW_WHICH_WINDOW;
|
|
WIN_DATA * pWindowData = hb_gt_wvw_GetWindowsData( usWinNum );
|
|
USHORT usRow = ( USHORT ) hb_parni( 2 ),
|
|
usCol = ( USHORT ) hb_parni( 3 );
|
|
|
|
if( hb_gt_wvw_GetMainCoordMode() )
|
|
hb_wvw_HBFUNCPrologue( usWinNum, &usRow, &usCol, NULL, NULL );
|
|
|
|
xy = hb_gt_wvwGetXYFromColRow( pWindowData, usCol, usRow );
|
|
|
|
if( ClientToScreen( pWindowData->hWnd, &xy ) )
|
|
hb_retl( SetCursorPos( xy.x, xy.y + ( pWindowData->PTEXTSIZE.y / 2 ) ) );
|
|
else
|
|
hb_retl( FALSE );
|
|
}
|
|
|
|
|
|
/*by bdj */
|
|
/*none in gtwvt */
|
|
/* wvw_FillRectangle( nWinNum, nTop, nLeft, nBottom, nRight, nRGBcolor/hBrush, */
|
|
/* lTight, lUseBrush, aOffSet ) */
|
|
/* */
|
|
/* if lTight, rect is drawn inside the character region */
|
|
/* AND top and left lines are lower two pixel down to make room for above/left object */
|
|
/* WARNING: gui object of this type subject to be overwritten by chars */
|
|
/* NOTE that these lines are to be overwritten by displayed char, */
|
|
/* we are depending on the fact that gui object will be painted last */
|
|
/* */
|
|
/* if lUseBrush, nRGBcolor is treated as a BRUSH handle */
|
|
/* */
|
|
|
|
HB_FUNC( WVW_FILLRECTANGLE )
|
|
{
|
|
UINT usWinNum = WVW_WHICH_WINDOW;
|
|
WVW_DATA * p = hb_getWvwData();
|
|
WIN_DATA * pWindowData = hb_gt_wvw_GetWindowsData( usWinNum );
|
|
POINT xy = { 0 };
|
|
int iTop, iLeft, iBottom, iRight;
|
|
int iOffTop, iOffLeft, iOffBottom, iOffRight;
|
|
USHORT usTop = ( USHORT ) hb_parni( 2 ),
|
|
usLeft = ( USHORT ) hb_parni( 3 ),
|
|
usBottom = ( USHORT ) hb_parni( 4 ),
|
|
usRight = ( USHORT ) hb_parni( 5 );
|
|
COLORREF crRGBcolor = HB_ISNIL( 6 ) ? 0 : hb_parnl( 6 );
|
|
BOOL bTight = HB_ISNIL( 7 ) ? FALSE : hb_parl( 7 );
|
|
BOOL bUseBrush = HB_ISNIL( 8 ) ? FALSE : hb_parl( 8 );
|
|
LOGBRUSH lb = { 0 };
|
|
HBRUSH hBrush;
|
|
RECT xyRect = { 0 };
|
|
|
|
if( hb_gt_wvw_GetMainCoordMode() )
|
|
hb_wvw_HBFUNCPrologue( usWinNum, &usTop, &usLeft, &usBottom, &usRight );
|
|
|
|
iOffTop = ! HB_ISNIL( 9 ) ? hb_parvni( 9, 1 ) : 0;
|
|
iOffLeft = ! HB_ISNIL( 9 ) ? hb_parvni( 9, 2 ) : 0;
|
|
iOffBottom = ! HB_ISNIL( 9 ) ? hb_parvni( 9, 3 ) : 0;
|
|
iOffRight = ! HB_ISNIL( 9 ) ? hb_parvni( 9, 4 ) : 0;
|
|
|
|
xy = hb_gt_wvwGetXYFromColRow( pWindowData, usLeft, usTop );
|
|
iTop = bTight ? xy.y + 2 : xy.y;
|
|
iLeft = bTight ? xy.x + 2 : xy.x;
|
|
|
|
xy = hb_gt_wvwGetXYFromColRow( pWindowData, usRight + 1, usBottom + 1 );
|
|
|
|
xy.y -= pWindowData->byLineSpacing;
|
|
|
|
iBottom = xy.y - 1;
|
|
iRight = xy.x - 1;
|
|
|
|
/* Aplica OffSet */
|
|
iTop += iOffTop;
|
|
iLeft += iOffLeft;
|
|
iBottom += iOffBottom;
|
|
iRight += iOffRight;
|
|
|
|
xyRect.left = iLeft;
|
|
xyRect.top = iTop;
|
|
xyRect.right = iRight + 1;
|
|
xyRect.bottom = iBottom + 1;
|
|
|
|
lb.lbStyle = BS_SOLID;
|
|
lb.lbColor = crRGBcolor;
|
|
lb.lbHatch = 0;
|
|
|
|
hBrush = ! bUseBrush ? CreateBrushIndirect( &lb ) : ( HBRUSH ) HB_PARHANDLE( 6 );
|
|
|
|
FillRect( pWindowData->hdc, &xyRect, hBrush );
|
|
|
|
if( ! bUseBrush )
|
|
{
|
|
SelectObject( p->s_pWindows[ 0 ]->hdc, ( HBRUSH ) p->s_sApp->OriginalBrush );
|
|
DeleteObject( hBrush );
|
|
}
|
|
|
|
hb_retl( TRUE );
|
|
}
|
|
|
|
|
|
HB_FUNC( WVW_LBADDSTRING )
|
|
{
|
|
SendMessage( GetDlgItem( ( HWND ) HB_PARHANDLE( 1 ), hb_parni( 2 ) ), LB_ADDSTRING, 0, ( LPARAM ) ( LPSTR ) hb_parcx( 3 ) );
|
|
}
|
|
|
|
HB_FUNC( WVW_LBSETCURSEL )
|
|
{
|
|
SendMessage( GetDlgItem( ( HWND ) HB_PARHANDLE( 1 ), hb_parni( 2 ) ), LB_SETCURSEL, hb_parni( 3 ), 0 );
|
|
}
|
|
|
|
/* WARNING!!! this function is not member of WVW_CB* group of functions */
|
|
HB_FUNC( WVW_CBADDSTRING )
|
|
{
|
|
SendMessage( GetDlgItem( ( HWND ) HB_PARHANDLE( 1 ), hb_parni( 2 ) ), CB_ADDSTRING, 0, ( LPARAM ) ( LPSTR ) hb_parcx( 3 ) );
|
|
}
|
|
|
|
/* WARNING!!! this function is not member of WVW_CB* group of functions */
|
|
HB_FUNC( WVW_CBSETCURSEL )
|
|
{
|
|
SendMessage( GetDlgItem( ( HWND ) HB_PARHANDLE( 1 ), hb_parni( 2 ) ), CB_SETCURSEL, hb_parni( 3 ), 0 );
|
|
}
|
|
|
|
HB_FUNC( WVW_DLGSETICON )
|
|
{
|
|
HICON hIcon;
|
|
|
|
if( HB_ISNUM( 2 ) )
|
|
hIcon = LoadIcon( hb_getWvwData()->hInstance, MAKEINTRESOURCE( hb_parni( 2 ) ) );
|
|
else
|
|
hIcon = ( HICON ) LoadImage( ( HINSTANCE ) NULL, hb_parc( 2 ), IMAGE_ICON, 0, 0, LR_LOADFROMFILE );
|
|
|
|
if( hIcon )
|
|
{
|
|
SendMessage( ( HWND ) HB_PARHANDLE( 1 ), WM_SETICON, ICON_SMALL, ( LPARAM ) hIcon ); /* Set Title Bar ICON */
|
|
SendMessage( ( HWND ) HB_PARHANDLE( 1 ), WM_SETICON, ICON_BIG, ( LPARAM ) hIcon ); /* Set Task List Icon */
|
|
}
|
|
|
|
if( hIcon )
|
|
hb_retnl( ( ULONG ) hIcon );
|
|
}
|
|
|
|
|
|
/* */
|
|
/* GUI Drawing Functions */
|
|
/* Pritpal Bedi <pritpal@vouchcac.com> */
|
|
/* */
|
|
|
|
|
|
/* */
|
|
/* wvw_SetPen( nPenStyle, nWidth, nColor ) */
|
|
/* */
|
|
|
|
/* IMPORTANT: in prev release this functions has nWinNum parameter
|
|
PENs are now application-wide.
|
|
*/
|
|
|
|
HB_FUNC( WVW_SETPEN )
|
|
{
|
|
|
|
int iPenWidth, iPenStyle;
|
|
COLORREF crColor;
|
|
HPEN hPen;
|
|
WVW_DATA * p = hb_getWvwData();
|
|
|
|
if( HB_ISNIL( 1 ) )
|
|
hb_retl( FALSE );
|
|
|
|
iPenStyle = hb_parni( 1 );
|
|
iPenWidth = HB_ISNIL( 2 ) ? 0 : hb_parni( 2 );
|
|
crColor = HB_ISNIL( 3 ) ? RGB( 0, 0, 0 ) : ( COLORREF ) hb_parnl( 3 );
|
|
|
|
hPen = CreatePen( iPenStyle, iPenWidth, crColor );
|
|
|
|
if( hPen )
|
|
{
|
|
/* 20040923, was:
|
|
if ( s_pWvwData->s_pWindows[usWinNum]->currentPen )
|
|
{
|
|
DeleteObject( (HPEN) s_pWvwData->s_pWindows[usWinNum]->currentPen );
|
|
}
|
|
s_pWvwData->s_pWindows[usWinNum]->currentPen = hPen;
|
|
*/
|
|
|
|
if( p->s_sApp->currentPen )
|
|
DeleteObject( ( HPEN ) p->s_sApp->currentPen );
|
|
|
|
p->s_sApp->currentPen = hPen;
|
|
|
|
hb_retl( TRUE );
|
|
}
|
|
else
|
|
hb_retl( FALSE );
|
|
}
|
|
|
|
|
|
/* */
|
|
/* wvw_SetBrush( nStyle, nColor, [ nHatch ] ) */
|
|
/* */
|
|
|
|
/* IMPORTANT: in prev release this functions has nWinNum parameter
|
|
BRUSHes are now application-wide.
|
|
*/
|
|
|
|
HB_FUNC( WVW_SETBRUSH )
|
|
{
|
|
|
|
HBRUSH hBrush;
|
|
LOGBRUSH lb = { 0 };
|
|
WVW_DATA * p = hb_getWvwData();
|
|
|
|
if( HB_ISNIL( 1 ) )
|
|
hb_retl( FALSE );
|
|
|
|
lb.lbStyle = hb_parnl( 1 );
|
|
lb.lbColor = HB_ISNIL( 2 ) ? RGB( 0, 0, 0 ) : ( COLORREF ) hb_parnl( 2 );
|
|
lb.lbHatch = HB_ISNIL( 3 ) ? 0 : hb_parnl( 3 );
|
|
|
|
hBrush = CreateBrushIndirect( &lb );
|
|
|
|
if( hBrush )
|
|
{
|
|
/* 20040923,was:
|
|
if ( s_pWvwData->s_pWindows[usWinNum]->currentBrush )
|
|
{
|
|
DeleteObject( (HBRUSH) s_pWvwData->s_pWindows[usWinNum]->currentBrush );
|
|
}
|
|
s_pWvwData->s_pWindows[usWinNum]->currentBrush = hBrush;
|
|
*/
|
|
|
|
if( p->s_sApp->currentBrush )
|
|
{
|
|
SelectObject( p->s_pWindows[ 0 ]->hdc, ( HBRUSH ) p->s_sApp->OriginalBrush );
|
|
DeleteObject( ( HBRUSH ) p->s_sApp->currentBrush );
|
|
}
|
|
p->s_sApp->currentBrush = hBrush;
|
|
|
|
hb_retl( TRUE );
|
|
}
|
|
else
|
|
hb_retl( FALSE );
|
|
}
|
|
|
|
|
|
HB_FUNC( WVW__MAKEDLGTEMPLATE )
|
|
{
|
|
WORD * p, * pdlgtemplate;
|
|
WORD nItems = ( WORD ) hb_parvni( 1, 4 );
|
|
int i, nchar;
|
|
DWORD lStyle;
|
|
|
|
pdlgtemplate = p = ( PWORD ) LocalAlloc( LPTR, 65534 );
|
|
|
|
lStyle = hb_parvnl( 1, 3 );
|
|
|
|
*p++ = 1;
|
|
*p++ = 0xFFFF;
|
|
*p++ = LOWORD( hb_parvnl( 1, 1 ) );
|
|
*p++ = HIWORD( hb_parvnl( 1, 1 ) );
|
|
|
|
*p++ = LOWORD( hb_parvnl( 1, 2 ) );
|
|
*p++ = HIWORD( hb_parvnl( 1, 2 ) );
|
|
|
|
*p++ = LOWORD( lStyle );
|
|
*p++ = HIWORD( lStyle );
|
|
|
|
*p++ = ( WORD ) nItems;
|
|
*p++ = ( short ) hb_parvni( 1, 5 );
|
|
*p++ = ( short ) hb_parvni( 1, 6 );
|
|
*p++ = ( short ) hb_parvni( 1, 7 );
|
|
*p++ = ( short ) hb_parvni( 1, 8 );
|
|
*p++ = ( short ) 0;
|
|
*p++ = ( short ) 0x00;
|
|
|
|
if( hb_parinfa( 1, 11 ) == HB_IT_STRING )
|
|
{
|
|
nchar = nCopyAnsiToWideChar( p, TEXT( ( char * ) hb_parvcx( 1, 11 ) ) );
|
|
p += nchar;
|
|
}
|
|
else
|
|
*p++ = 0;
|
|
|
|
if( ( lStyle & DS_SETFONT ) )
|
|
{
|
|
*p++ = ( short ) hb_parvni( 1, 12 );
|
|
*p++ = ( short ) hb_parvni( 1, 13 );
|
|
*p++ = ( short ) hb_parvni( 1, 14 );
|
|
|
|
nchar = nCopyAnsiToWideChar( p, TEXT( ( char * ) hb_parvcx( 1, 15 ) ) );
|
|
p += nchar;
|
|
}
|
|
|
|
for( i = 1; i <= nItems; i++ )
|
|
{
|
|
|
|
p = lpwAlign( p );
|
|
|
|
*p++ = LOWORD( hb_parvnl( 2, i ) );
|
|
*p++ = HIWORD( hb_parvnl( 2, i ) );
|
|
|
|
*p++ = LOWORD( hb_parvnl( 3, i ) );
|
|
*p++ = HIWORD( hb_parvnl( 3, i ) );
|
|
|
|
*p++ = LOWORD( hb_parvnl( 4, i ) );
|
|
*p++ = HIWORD( hb_parvnl( 4, i ) );
|
|
|
|
*p++ = ( short ) hb_parvni( 5, i );
|
|
*p++ = ( short ) hb_parvni( 6, i );
|
|
*p++ = ( short ) hb_parvni( 7, i );
|
|
*p++ = ( short ) hb_parvni( 8, i );
|
|
|
|
*p++ = LOWORD( hb_parvnl( 9, i ) );
|
|
*p++ = HIWORD( hb_parvnl( 9, i ) );
|
|
|
|
if( hb_parinfa( 10, i ) == HB_IT_STRING )
|
|
{
|
|
nchar = nCopyAnsiToWideChar( p, TEXT( ( char * ) hb_parvcx( 10, i ) ) );
|
|
p += nchar;
|
|
}
|
|
else
|
|
{
|
|
*p++ = 0xFFFF;
|
|
*p++ = ( WORD ) hb_parvni( 10, i );
|
|
}
|
|
|
|
if( hb_parinfa( 11, i ) == HB_IT_STRING )
|
|
{
|
|
nchar = nCopyAnsiToWideChar( p, ( LPSTR ) hb_parvcx( 11, i ) );
|
|
p += nchar;
|
|
}
|
|
else
|
|
{
|
|
*p++ = 0xFFFF;
|
|
*p++ = ( WORD ) hb_parvni( 11, i );
|
|
}
|
|
|
|
*p++ = 0x00;
|
|
}
|
|
|
|
p = lpwAlign( p );
|
|
|
|
hb_retclen( ( LPSTR ) pdlgtemplate, ( ( ULONG ) p - ( ULONG ) pdlgtemplate ) );
|
|
|
|
LocalFree( LocalHandle( pdlgtemplate ) );
|
|
}
|
|
|
|
|
|
HB_FUNC( WVW_GETCURSORPOS )
|
|
{
|
|
POINT xy = { 0 };
|
|
PHB_ITEM info = hb_itemArrayNew( 2 );
|
|
|
|
GetCursorPos( &xy );
|
|
|
|
hb_arraySetNI( info, 1, xy.x );
|
|
hb_arraySetNI( info, 2, xy.y );
|
|
|
|
hb_itemReturnRelease( info );
|
|
}
|
|
|
|
|
|
/* wvw_ShowWindow( [nWinNum], nCmdShow ) */
|
|
HB_FUNC( WVW_SHOWWINDOW )
|
|
{
|
|
UINT usWinNum = WVW_WHICH_WINDOW;
|
|
WIN_DATA * pWindowData = hb_gt_wvw_GetWindowsData( usWinNum );
|
|
int iCmdShow = HB_ISNUM( 2 ) ? hb_parni( 2 ) : SW_SHOWNORMAL;
|
|
|
|
ShowWindow( pWindowData->hWnd, iCmdShow );
|
|
}
|
|
|
|
|
|
/* wvw_UpdateWindow( [nWinNum] ) */
|
|
HB_FUNC( WVW_UPDATEWINDOW )
|
|
{
|
|
UINT usWinNum = WVW_WHICH_WINDOW;
|
|
|
|
WIN_DATA * pWindowData = hb_gt_wvw_GetWindowsData( usWinNum );
|
|
|
|
UpdateWindow( pWindowData->hWnd );
|
|
}
|
|
|
|
/*
|
|
*
|
|
* Dialogs
|
|
* original work by Pritpal Bedi in WVTUTILS.C
|
|
*/
|
|
|
|
HB_FUNC( WVW_CREATEDIALOGDYNAMIC )
|
|
{
|
|
PHB_ITEM pFirst = hb_param( 3, HB_IT_ANY );
|
|
PHB_ITEM pFunc = NULL;
|
|
PHB_DYNS pExecSym;
|
|
WVW_DATA * p = hb_getWvwData();
|
|
HWND hDlg = NULL;
|
|
int iIndex;
|
|
int iType = 0;
|
|
int iResource = hb_parni( 4 );
|
|
|
|
/* check if we still have room for a new dialog */
|
|
|
|
for( iIndex = 0; iIndex < WVW_DLGML_MAX; iIndex++ )
|
|
if( p->s_sApp->hDlgModeless[ iIndex ] == NULL )
|
|
break;
|
|
|
|
if( iIndex >= WVW_DLGML_MAX )
|
|
{
|
|
/* no more room */
|
|
hb_retnl( ( ULONG ) NULL );
|
|
return;
|
|
}
|
|
|
|
if( HB_IS_BLOCK( pFirst ) )
|
|
{
|
|
|
|
/* pFunc is pointing to stored code block (later) */
|
|
pFunc = hb_itemNew( pFirst );
|
|
iType = 2;
|
|
}
|
|
else if( HB_IS_STRING( pFirst ) == HB_IT_STRING )
|
|
{
|
|
pExecSym = hb_dynsymFindName( hb_itemGetCPtr( pFirst ) );
|
|
if( pExecSym )
|
|
pFunc = ( PHB_ITEM ) pExecSym;
|
|
iType = 1;
|
|
}
|
|
|
|
{
|
|
|
|
if( HB_ISNUM( 3 ) )
|
|
hDlg = CreateDialogIndirect( hb_getWvwData()->hInstance,
|
|
( LPDLGTEMPLATE ) hb_parc( 1 ),
|
|
hb_parl( 2 ) ? p->s_pWindows[ 0 ]->hWnd : NULL,
|
|
( DLGPROC ) hb_parnl( 3 ) );
|
|
else
|
|
{
|
|
|
|
switch( iResource )
|
|
{
|
|
case 0:
|
|
hDlg = CreateDialog( hb_getWvwData()->hInstance,
|
|
hb_parc( 1 ),
|
|
hb_parl( 2 ) ? p->s_pWindows[ 0 ]->hWnd : NULL,
|
|
( DLGPROC ) hb_gt_wvwDlgProcMLess );
|
|
break;
|
|
|
|
case 1:
|
|
hDlg = CreateDialog( hb_getWvwData()->hInstance,
|
|
MAKEINTRESOURCE( ( WORD ) hb_parni( 1 ) ),
|
|
hb_parl( 2 ) ? p->s_pWindows[ 0 ]->hWnd : NULL,
|
|
( DLGPROC ) hb_gt_wvwDlgProcMLess );
|
|
break;
|
|
|
|
case 2:
|
|
hDlg = CreateDialogIndirect( hb_getWvwData()->hInstance,
|
|
( LPDLGTEMPLATE ) hb_parc( 1 ),
|
|
hb_parl( 2 ) ? p->s_pWindows[ 0 ]->hWnd : NULL,
|
|
( DLGPROC ) hb_gt_wvwDlgProcMLess );
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( hDlg )
|
|
{
|
|
p->s_sApp->hDlgModeless[ iIndex ] = hDlg;
|
|
if( pFunc )
|
|
{
|
|
|
|
/* if codeblock, store the codeblock and lock it there */
|
|
if( HB_IS_BLOCK( pFirst ) )
|
|
p->s_sApp->pcbFunc[ iIndex ] = pFunc;
|
|
|
|
|
|
p->s_sApp->pFunc[ iIndex ] = pFunc;
|
|
p->s_sApp->iType[ iIndex ] = iType;
|
|
}
|
|
else
|
|
{
|
|
p->s_sApp->pFunc[ iIndex ] = NULL;
|
|
p->s_sApp->iType[ iIndex ] = 0;
|
|
}
|
|
SendMessage( hDlg, WM_INITDIALOG, 0, 0 );
|
|
}
|
|
else
|
|
{
|
|
|
|
if( iType == 2 && pFunc )
|
|
hb_itemRelease( pFunc );
|
|
|
|
p->s_sApp->hDlgModeless[ iIndex ] = NULL;
|
|
}
|
|
}
|
|
|
|
hb_retnl( ( ULONG ) hDlg );
|
|
}
|
|
|
|
|
|
HB_FUNC( WVW_CREATEDIALOGMODAL )
|
|
{
|
|
PHB_ITEM pFirst = hb_param( 3, HB_IT_ANY );
|
|
PHB_ITEM pFunc = NULL;
|
|
PHB_DYNS pExecSym;
|
|
WVW_DATA * p = hb_getWvwData();
|
|
int iIndex;
|
|
int iResource = hb_parni( 4 );
|
|
int iResult = 0;
|
|
HWND hParent = HB_ISNIL( 5 ) ? p->s_pWindows[ 0 ]->hWnd : ( HWND ) HB_PARHANDLE( 5 );
|
|
|
|
/* check if we still have room for a new dialog */
|
|
for( iIndex = 0; iIndex < WVW_DLGMD_MAX; iIndex++ )
|
|
if( p->s_sApp->hDlgModal[ iIndex ] == NULL )
|
|
break;
|
|
|
|
if( iIndex >= WVW_DLGMD_MAX )
|
|
{
|
|
/* no more room */
|
|
hb_retni( ( int ) NULL );
|
|
return;
|
|
}
|
|
|
|
if( HB_IS_BLOCK( pFirst ) )
|
|
{
|
|
/* pFunc is pointing to stored code block (later) */
|
|
|
|
p->s_sApp->pcbFuncModal[ iIndex ] = hb_itemNew( pFirst );
|
|
|
|
pFunc = p->s_sApp->pcbFuncModal[ iIndex ];
|
|
p->s_sApp->pFuncModal[ iIndex ] = pFunc;
|
|
p->s_sApp->iTypeModal[ iIndex ] = 2;
|
|
}
|
|
else if( HB_IS_STRING( pFirst ) == HB_IT_STRING )
|
|
{
|
|
pExecSym = hb_dynsymFindName( hb_itemGetCPtr( pFirst ) );
|
|
if( pExecSym )
|
|
pFunc = ( PHB_ITEM ) pExecSym;
|
|
p->s_sApp->pFuncModal[ iIndex ] = pFunc;
|
|
p->s_sApp->iTypeModal[ iIndex ] = 1;
|
|
}
|
|
|
|
switch( iResource )
|
|
{
|
|
case 0:
|
|
iResult = DialogBoxParam( hb_getWvwData()->hInstance,
|
|
hb_parc( 1 ),
|
|
hParent,
|
|
( DLGPROC ) hb_gt_wvwDlgProcModal,
|
|
( LPARAM ) ( DWORD ) iIndex + 1 );
|
|
break;
|
|
|
|
case 1:
|
|
iResult = DialogBoxParam( hb_getWvwData()->hInstance,
|
|
MAKEINTRESOURCE( ( WORD ) hb_parni( 1 ) ),
|
|
hParent,
|
|
( DLGPROC ) hb_gt_wvwDlgProcModal,
|
|
( LPARAM ) ( DWORD ) iIndex + 1 );
|
|
break;
|
|
|
|
case 2:
|
|
iResult = DialogBoxIndirectParam( hb_getWvwData()->hInstance,
|
|
( LPDLGTEMPLATE ) hb_parc( 1 ),
|
|
hParent,
|
|
( DLGPROC ) hb_gt_wvwDlgProcModal,
|
|
( LPARAM ) ( DWORD ) iIndex + 1 );
|
|
break;
|
|
}
|
|
|
|
hb_retni( iResult );
|
|
}
|
|
/* removed from GTWVT, so we remove it from here also. I really don;t like doing it... */
|
|
HB_FUNC( WVW_DELETEOBJECT )
|
|
{
|
|
hb_retl( DeleteObject( ( HGDIOBJ ) HB_PARHANDLE( 1 ) ) );
|
|
}
|
|
|
|
|
|
HB_FUNC( WVW_SETONTOP )
|
|
{
|
|
UINT usWinNum = WVW_WHICH_WINDOW;
|
|
WIN_DATA * pWindowData = hb_gt_wvw_GetWindowsData( usWinNum );
|
|
RECT rect = { 0 };
|
|
|
|
GetWindowRect( pWindowData->hWnd, &rect );
|
|
|
|
hb_retl( SetWindowPos( pWindowData->hWnd, HWND_TOPMOST,
|
|
rect.left,
|
|
rect.top,
|
|
0,
|
|
0,
|
|
SWP_NOSIZE + SWP_NOMOVE + SWP_NOACTIVATE ) );
|
|
}
|
|
|
|
|
|
HB_FUNC( WVW_SETASNORMAL )
|
|
{
|
|
UINT usWinNum = WVW_WHICH_WINDOW;
|
|
WIN_DATA * pWindowData = hb_gt_wvw_GetWindowsData( usWinNum );
|
|
RECT rect = { 0 };
|
|
|
|
GetWindowRect( pWindowData->hWnd, &rect );
|
|
|
|
hb_retl( SetWindowPos( pWindowData->hWnd, HWND_NOTOPMOST,
|
|
rect.left,
|
|
rect.top,
|
|
0,
|
|
0,
|
|
SWP_NOSIZE + SWP_NOMOVE + SWP_NOACTIVATE ) );
|
|
}
|
|
|
|
|
|
/* */
|
|
/* aScr := wvw_SaveScreen( nWinNum, nTop, nLeft, nBottom, nRight ) */
|
|
/* */
|
|
|
|
/*TODO: reconsider, is it really needed? is it better to be handled by application?
|
|
* besides, with Windowing feature, it seems not needed anymore
|
|
*/
|
|
|
|
HB_FUNC( WVW_SAVESCREEN )
|
|
{
|
|
UINT usWinNum = WVW_WHICH_WINDOW;
|
|
WIN_DATA * pWindowData = hb_gt_wvw_GetWindowsData( usWinNum );
|
|
|
|
HBITMAP hBmp, oldBmp;
|
|
POINT xy = { 0 };
|
|
int iTop, iLeft, iBottom, iRight, iWidth, iHeight;
|
|
PHB_ITEM info = hb_itemArrayNew( 3 );
|
|
|
|
USHORT usTop = ( USHORT ) hb_parni( 2 ),
|
|
usLeft = ( USHORT ) hb_parni( 3 ),
|
|
usBottom = ( USHORT ) hb_parni( 4 ),
|
|
usRight = ( USHORT ) hb_parni( 5 );
|
|
|
|
if( hb_gt_wvw_GetMainCoordMode() )
|
|
hb_wvw_HBFUNCPrologue( usWinNum, &usTop, &usLeft, &usBottom, &usRight );
|
|
|
|
xy = hb_gt_wvwGetXYFromColRow( pWindowData, usLeft, usTop );
|
|
iTop = xy.y;
|
|
iLeft = xy.x;
|
|
|
|
xy = hb_gt_wvwGetXYFromColRow( pWindowData, usRight + 1, usBottom + 1 );
|
|
iBottom = xy.y - 1;
|
|
iRight = xy.x - 1;
|
|
|
|
iWidth = iRight - iLeft + 1;
|
|
iHeight = iBottom - iTop + 1;
|
|
|
|
hBmp = CreateCompatibleBitmap( pWindowData->hdc, iWidth, iHeight );
|
|
|
|
oldBmp = ( HBITMAP ) SelectObject( pWindowData->hCompDC, hBmp );
|
|
BitBlt( pWindowData->hCompDC, 0, 0, iWidth, iHeight, pWindowData->hdc, iLeft, iTop, SRCCOPY );
|
|
SelectObject( pWindowData->hCompDC, oldBmp );
|
|
|
|
hb_arraySetNI( info, 1, iWidth );
|
|
hb_arraySetNI( info, 2, iHeight );
|
|
hb_arraySetNInt( info, 3, ( HB_PTRUINT ) hBmp );
|
|
|
|
hb_itemReturnRelease( info );
|
|
}
|
|
|
|
|
|
/* */
|
|
/* wvw_RestScreen( nWinNum, nTop, nLeft, nBottom, nRight, aScr, lDoNotDestroyBMP )*/
|
|
/* */
|
|
|
|
/*TODO: reconsider, is it really needed? is it better to be handled by application?
|
|
* besides, with Windowing feature, it seems not needed anymore
|
|
*/
|
|
|
|
HB_FUNC( WVW_RESTSCREEN )
|
|
{
|
|
UINT usWinNum = WVW_WHICH_WINDOW;
|
|
|
|
WIN_DATA * pWindowData = hb_gt_wvw_GetWindowsData( usWinNum );
|
|
POINT xy = { 0 };
|
|
int iTop, iLeft, iBottom, iRight, iWidth, iHeight;
|
|
|
|
HBITMAP hBmp;
|
|
|
|
BOOL bResult = FALSE;
|
|
BOOL bDoNotDestroyBMP = HB_ISNIL( 7 ) ? FALSE : hb_parl( 7 );
|
|
USHORT usTop = ( USHORT ) hb_parni( 2 ),
|
|
usLeft = ( USHORT ) hb_parni( 3 ),
|
|
usBottom = ( USHORT ) hb_parni( 4 ),
|
|
usRight = ( USHORT ) hb_parni( 5 );
|
|
|
|
if( hb_gt_wvw_GetMainCoordMode() )
|
|
hb_wvw_HBFUNCPrologue( usWinNum, &usTop, &usLeft, &usBottom, &usRight );
|
|
|
|
xy = hb_gt_wvwGetXYFromColRow( pWindowData, usLeft, usTop );
|
|
iTop = xy.y;
|
|
iLeft = xy.x;
|
|
|
|
xy = hb_gt_wvwGetXYFromColRow( pWindowData, usRight + 1, usBottom + 1 );
|
|
iBottom = xy.y - 1;
|
|
iRight = xy.x - 1;
|
|
|
|
iWidth = iRight - iLeft + 1;
|
|
iHeight = iBottom - iTop + 1;
|
|
|
|
hBmp = ( HBITMAP ) SelectObject( pWindowData->hCompDC, ( HBITMAP ) hb_parvnl( 6, 3 ) );
|
|
if( hBmp )
|
|
{
|
|
if( ( iWidth == hb_parvni( 6, 1 ) ) && ( iHeight == hb_parvni( 6, 2 ) ) )
|
|
{
|
|
if( BitBlt( pWindowData->hdc,
|
|
iLeft,
|
|
iTop,
|
|
iWidth,
|
|
iHeight,
|
|
pWindowData->hCompDC,
|
|
0,
|
|
0,
|
|
SRCCOPY ) )
|
|
bResult = TRUE;
|
|
}
|
|
else if( StretchBlt( pWindowData->hdc,
|
|
iLeft,
|
|
iTop,
|
|
iWidth,
|
|
iHeight,
|
|
pWindowData->hCompDC,
|
|
0,
|
|
0,
|
|
hb_parvni( 6, 1 ),
|
|
hb_parvni( 6, 2 ),
|
|
SRCCOPY ) )
|
|
bResult = TRUE;
|
|
|
|
}
|
|
|
|
SelectObject( pWindowData->hCompDC, hBmp );
|
|
|
|
if( ! bDoNotDestroyBMP )
|
|
DeleteObject( ( HBITMAP ) hb_parvnl( 6, 3 ) );
|
|
|
|
hb_retl( bResult );
|
|
}
|
|
|
|
|
|
/* */
|
|
/* wvw_CreateFont( cFontFace, nHeight, nWidth, nWeight, lItalic, lUnderline,*/
|
|
/* lStrikeout, nCharSet, nQuality, nEscapement ) */
|
|
/* */
|
|
HB_FUNC( WVW_CREATEFONT )
|
|
{
|
|
WVW_DATA * p = hb_getWvwData();
|
|
UINT usWinNum = p->s_usNumWindows - 1;
|
|
|
|
WIN_DATA * pWindowData = hb_gt_wvw_GetWindowsData( usWinNum );
|
|
|
|
|
|
LOGFONT logfont;
|
|
HFONT hFont;
|
|
|
|
logfont.lfEscapement = HB_ISNIL( 10 ) ? 0 : ( hb_parni( 10 ) * 10 );
|
|
logfont.lfOrientation = 0;
|
|
logfont.lfWeight = HB_ISNIL( 4 ) ? 0 : hb_parni( 4 );
|
|
logfont.lfItalic = HB_ISNIL( 5 ) ? 0 : ( BYTE ) hb_parl( 5 );
|
|
logfont.lfUnderline = HB_ISNIL( 6 ) ? 0 : ( BYTE ) hb_parl( 6 );
|
|
logfont.lfStrikeOut = HB_ISNIL( 7 ) ? 0 : ( BYTE ) hb_parl( 7 );
|
|
logfont.lfCharSet = HB_ISNIL( 8 ) ? ( BYTE ) pWindowData->CodePage : ( BYTE ) hb_parni( 8 );
|
|
logfont.lfOutPrecision = 0;
|
|
logfont.lfClipPrecision = 0;
|
|
logfont.lfQuality = HB_ISNIL( 9 ) ? ( BYTE ) DEFAULT_QUALITY : ( BYTE ) hb_parni( 9 );
|
|
logfont.lfPitchAndFamily = FF_DONTCARE;
|
|
logfont.lfHeight = HB_ISNIL( 2 ) ? pWindowData->fontHeight : hb_parni( 2 );
|
|
logfont.lfWidth = HB_ISNIL( 3 ) ? ( pWindowData->fontWidth < 0 ? -pWindowData->fontWidth : pWindowData->fontWidth ) : hb_parni( 3 );
|
|
|
|
strcpy( logfont.lfFaceName, HB_ISNIL( 1 ) ? pWindowData->fontFace : hb_parcx( 1 ) );
|
|
|
|
hFont = CreateFontIndirect( &logfont );
|
|
if( hFont )
|
|
hb_retnl( ( ULONG ) hFont );
|
|
else
|
|
hb_retnl( 0 );
|
|
}
|
|
|
|
HB_FUNC( WVW_GETKEYSTATE )
|
|
{
|
|
hb_retni( GetKeyState( hb_parni( 1 ) ) );
|
|
}
|
|
|
|
HB_FUNC( WVW_LOWORD )
|
|
{
|
|
hb_retni( ( int ) ( hb_parnl( 1 ) & 0xFFFF ) );
|
|
}
|
|
|
|
HB_FUNC( WVW_HIWORD )
|
|
{
|
|
hb_retni( ( int ) ( ( hb_parnl( 1 ) >> 16 ) & 0xFFFF ) );
|
|
}
|