071fef7612
* harbour/contrib/rdd_ads/adsfunc.c
* harbour/source/rdd/workarea.c
* formatting
* harbour/include/hbapi.h
* harbour/source/vm/extend.c
+ added missing hb_storptrGC()
* harbour/include/hbapicdp.h
* harbour/source/rtl/cdpapi.c
+ added parameter to unicode translation function to protect control
code translation
* formatting
* harbour/source/rtl/gtsln/kbsln.c
* harbour/source/rtl/gtxwc/gtxwc.c
* use new unicode translation function format. It also fixes problem
with space translation in GTLSN used in UTF8 mode
* harbour/include/hbapiitm.h
* harbour/source/vm/itemapi.c
+ added hb_itemCopyToRef(), hb_itemMoveToRef(), hb_itemMoveRef(),
hb_itemUnRefWrite()
* harbour/include/hbexprb.c
! use HB_P_DUPLUNREF instead of HB_P_DUPLICATE when assign is used in
push context - Clipper compatible behavior, see:
x:=10
f(y:=iif(.t.,@x,))
? x, y
func f(x)
x+=100
return nil
* harbour/include/hbver.h
* harbour/source/common/hbver.c
* changed status to "devel"
* harbour/source/common/expropt2.c
* disabled setting NIL when iif(.t.,,sth()) is optimized to avoid
warning when iif() is used as statement - to fix number of parameters
passed to function in code like f(iif(.t.,,sth())) we will need a
little bit deeper modification
* harbour/source/compiler/complex.c
* added hack for potential problems caused by WITH OBJECT syntax, f.e.
in code like:
proc p(obj,x)
case:=myCaseClass():new()
retu:=myCaseClass():new()
WITH OBJECT obj
do case
case x==nil
case:value()
case:action()
retu:sth()
end
END
case:action()
retu:sth()
return
case:action(), case:value(), retu:sth() can means two different things
and compiler cannot guess which one should use. It cannot be fixed
because it's caused by bad WITH OBJECT syntax. In xHarbour constractions
like case:value() or retu:sth() are always used as in WITH OBJECT
context what is not Clipper compatible. I do not want to introduce
such limitations. We have two choices: change WITH OBJECT syntax or
add some hack to "hide" the problem a little bit. Now I intorduce
ugly hack which check number of spaces between ':' so
case :action()
is compiled as case condition using WITH OBJECT message and
case:action() as sending message to object in case variable
* harbour/source/compiler/harbour.y
* harbour/source/compiler/harbour.yyc
+ added support for passing base value to FOR EACH by reference.
* harbour/source/vm/arrays.c
* use hb_itemMoveRef() in AINS()/ADEL() to avoid creation of cyclic
reference chains
* harbour/source/vm/debug.c
* harbour/source/vm/memvars.c
* use hb_itemCopyToRef() to avoid creation of cyclic reference chains
* harbour/source/vm/classes.c
* harbour/source/vm/hvm.c
* use hb_itemMoveToRef() to avoid creation of cyclic reference chains
+ added support for for writable string enumerators, f.e.:
proc main()
local s, c
s:="abcdefghijklmnopqrst"
for each c in @s
if c$"aeio"
c:="*"
endif
next
? s // "*bcd*fgh*jklmn*pqrst"
return
534 lines
16 KiB
C
534 lines
16 KiB
C
/*
|
|
* $Id$
|
|
*/
|
|
|
|
/*
|
|
* Harbour Project source code:
|
|
* Keyboard subsystem based on Slang screen library.
|
|
*
|
|
* Copyright 2000 Marek Paliwoda <paliwoda@inetia.pl>
|
|
* www - http://www.harbour-project.org
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2, or (at your option)
|
|
* any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this software; see the file COPYING. If not, write to
|
|
* the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
|
|
* Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/).
|
|
*
|
|
* As a special exception, the Harbour Project gives permission for
|
|
* additional uses of the text contained in its release of Harbour.
|
|
*
|
|
* The exception is that, if you link the Harbour libraries with other
|
|
* files to produce an executable, this does not by itself cause the
|
|
* resulting executable to be covered by the GNU General Public License.
|
|
* Your use of that executable is in no way restricted on account of
|
|
* linking the Harbour library code into it.
|
|
*
|
|
* This exception does not however invalidate any other reasons why
|
|
* the executable file might be covered by the GNU General Public License.
|
|
*
|
|
* This exception applies only to the code released by the Harbour
|
|
* Project under the name Harbour. If you copy code from other
|
|
* Harbour Project or Free Software Foundation releases into a copy of
|
|
* Harbour, as the General Public License permits, the exception does
|
|
* not apply to the code that you add in this way. To avoid misleading
|
|
* anyone as to the status of such modified files, you must delete
|
|
* this exception notice from them.
|
|
*
|
|
* If you write modifications of your own for Harbour, it is your choice
|
|
* whether to permit this exception to apply to your modifications.
|
|
* If you do not wish that, delete this exception notice.
|
|
*
|
|
*/
|
|
|
|
/* NOTE: User programs should never call this layer directly! */
|
|
|
|
/* *********************************************************************** */
|
|
|
|
#include "gtsln.h"
|
|
#include <sys/ioctl.h>
|
|
|
|
#ifdef M_UNIX
|
|
#include <sys/termio.h>
|
|
#include <sys/vtkd.h>
|
|
#endif
|
|
|
|
/* we're assuming target has termios - should be better done */
|
|
#include <termios.h>
|
|
|
|
/* *********************************************************************** */
|
|
|
|
/* keyboard states - these should be taken
|
|
from system includes, not be hard coded */
|
|
#if defined(__linux__)
|
|
#define SHIFT_PRESSED 1
|
|
#define ALTR_PRESSED 2
|
|
#define CONTROL_PRESSED 4
|
|
#define ALTL_PRESSED 8
|
|
#define ALT_PRESSED ALTL_PRESSED
|
|
#elif defined(M_UNIX) /* SCO */
|
|
#define SHIFT_PRESSED 1
|
|
#define ALTR_PRESSED 8
|
|
#define CONTROL_PRESSED 2
|
|
#define ALTL_PRESSED 4
|
|
#define ALT_PRESSED ALTL_PRESSED
|
|
#else /* we don't know how to do this */
|
|
#define SHIFT_PRESSED 0
|
|
#define ALTR_PRESSED 0
|
|
#define CONTROL_PRESSED 0
|
|
#define ALTL_PRESSED 0
|
|
#define ALT_PRESSED ALTL_PRESSED
|
|
#endif
|
|
#define HB_GT_KBD_MODIF_MASK \
|
|
( ( SHIFT_PRESSED | CONTROL_PRESSED | ALTL_PRESSED ) << 16 )
|
|
|
|
#define MOUSE_ALL_EVENTS_MASK \
|
|
( INKEY_MOVE | INKEY_LDOWN | INKEY_LUP | INKEY_RDOWN | INKEY_RUP )
|
|
|
|
/* extra keysyms definitions */
|
|
#define SL_KEY_NUM_5 SL_KEY_B2 /* this is checked explicitly */
|
|
#define SL_KEY_MAX ( ( unsigned int ) 0x2000 )
|
|
#define SL_KEY_ESC ( SL_KEY_MAX + 1 )
|
|
#define SL_KEY_MOU ( SL_KEY_ESC + 1 )
|
|
#define SL_KEY_ALT( ch ) ( SL_KEY_MAX + ( ( unsigned int ) ch ) )
|
|
|
|
/* we choose Ctrl+\ as an abort key on Unixes where it is a SIGQUIT key by default */
|
|
/* abort key is Ctrl+\ on Unix ( but Ctrl+@ on Linux console ) */
|
|
static int s_hb_sln_Abort_key = 28;
|
|
|
|
/* *********************************************************************** */
|
|
|
|
/* DeadKey definition's ENVVAR name. This EnvVar contains */
|
|
/* an ASCII value of a key, which serves as a DeadKey */
|
|
static char *hb_DeadKeyEnvName = "HRBNATIONDEADKEY";
|
|
|
|
/* a table for Keys work with a Dead key. The first
|
|
element contains a number of defined keys */
|
|
unsigned char hb_sln_convKDeadKeys[ 257 ]; /* it should be allocated by hb_xalloc() */
|
|
|
|
/* contains an integer value of a DeadKey or -1 */
|
|
int hb_DeadKey = -1;
|
|
|
|
/* escape key delay */
|
|
#ifdef HB_SLANG_ONE_ESC
|
|
int hb_sln_escDelay = 250;
|
|
#else
|
|
int hb_sln_escDelay = 0;
|
|
#endif
|
|
|
|
BOOL hb_sln_UnderLinuxConsole = FALSE;
|
|
BOOL hb_sln_UnderXterm = FALSE;
|
|
|
|
static int hb_sln_try_get_Kbd_State( void );
|
|
|
|
/* key translations tables - notice problems with compilation after changes */
|
|
#include "keytrans.c"
|
|
|
|
/* *********************************************************************** */
|
|
|
|
static void hb_sln_Init_TermType()
|
|
{
|
|
char * Env;
|
|
|
|
/* an uncertain way to check if we run under linux console */
|
|
Env = hb_getenv( "TERM" );
|
|
if( Env )
|
|
{
|
|
hb_sln_UnderLinuxConsole = *Env && ( strncmp( Env, "linux", 5 ) == 0 );
|
|
hb_xfree( ( void * ) Env );
|
|
}
|
|
/* an uncertain way to check if we run under xterm */
|
|
Env = hb_getenv( "TERM" );
|
|
if( Env )
|
|
{
|
|
hb_sln_UnderXterm = *Env && ( strstr( Env, "xterm" ) != NULL ||
|
|
strncmp( Env, "rxvt", 4 ) == 0 );
|
|
hb_xfree( ( void * ) Env );
|
|
}
|
|
}
|
|
|
|
/* *********************************************************************** */
|
|
|
|
static void hb_sln_Init_KeyTranslations()
|
|
{
|
|
char ch, keyname[ SLANG_MAX_KEYMAP_KEY_SEQ + 1 ];
|
|
int keynum, i;
|
|
char * keyseq;
|
|
|
|
/* for defining ^[<Key> sequences - this simulates Alt+Keys */
|
|
char AltChars[][ 2 ] =
|
|
{
|
|
{ '0', '9' },
|
|
{ 'A', 'Z' },
|
|
{ 'a', 'z' }
|
|
};
|
|
|
|
/* on Unix systems ESC is a special key so let
|
|
assume ESC is a doble pressed ESC key */
|
|
SLkp_define_keysym( "^[^[", SL_KEY_ESC );
|
|
|
|
/* try to define Shft-Fn and Ctrl-Fn keys.
|
|
Because we assume terminal has only 10 Fkeys
|
|
so F11-F30 is generated with Shift & Ctrl.
|
|
This is not guaranteed to work in all cases */
|
|
keynum = 11;
|
|
keyname[ 0 ] = 'F';
|
|
keyname[ 2 ] = 0;
|
|
|
|
/* Shft & Ctrl FKeys definition takes place in two
|
|
phases : from '1' to '9' and from 'A' to 'K' */
|
|
for( i = 1; i <= 2; i++ )
|
|
{
|
|
for( ch = ( i == 1 ? '1' : 'A' ); ch <= ( i == 1 ? '9' : 'K' ); ch++ )
|
|
{
|
|
keyname[ 1 ] = ch;
|
|
keyseq = SLtt_tgetstr( keyname );
|
|
if( keyseq != NULL && keyseq[ 0 ] != 0 )
|
|
SLkp_define_keysym( keyseq, SL_KEY_F( keynum ) );
|
|
keynum++;
|
|
}
|
|
}
|
|
|
|
/* We assume Esc key is a Meta key which is treated as an Alt key.
|
|
Also pressing Alt+Key on linux console and linux xterm gives the
|
|
same key sequences as with Meta key so we are happy */
|
|
|
|
keyname[ 0 ] = 033;
|
|
keyname[ 2 ] = 0;
|
|
|
|
/* Alt+Letter & Alt+digit definition takes place in three phases :
|
|
from '0' to '9', from 'A' to 'Z' and from 'a' to 'z' */
|
|
for( i = 0; i < 3; i++ )
|
|
{
|
|
for( ch = AltChars[ i ][ 0 ]; ch <= AltChars[ i ][ 1 ]; ch++ )
|
|
{
|
|
/* fprintf( stderr, "%d %c\n", i, ch ); */
|
|
keyname[ 1 ] = ch;
|
|
|
|
/* QUESTION: why Slang reports error for defining Alt+O ???.
|
|
Have I any hidden error in key definitiions ??? */
|
|
if( ch != 'O' )
|
|
SLkp_define_keysym( keyname, SL_KEY_ALT( ch ) );
|
|
}
|
|
}
|
|
|
|
/* mouse events under xterm */
|
|
if( hb_sln_UnderXterm )
|
|
{
|
|
keyseq = SLtt_tgetstr( "Km" );
|
|
if( ( keyseq != NULL ) && ( keyseq[ 0 ] != 0 ) )
|
|
{
|
|
/* fprintf( stderr, "%s\r\n", keyseq ); */
|
|
SLkp_define_keysym( keyseq, SL_KEY_MOU );
|
|
}
|
|
}
|
|
|
|
/* five on numeric console */
|
|
/* SLkp_define_keysym( "^[[G", SL_KEY_NUM_5 ); */
|
|
}
|
|
|
|
/* *********************************************************************** */
|
|
|
|
int hb_sln_Init_Terminal( int phase )
|
|
{
|
|
struct termios newTTY;
|
|
unsigned char * p;
|
|
int ret = 0;
|
|
|
|
/* first time init phase - we don't want this after
|
|
return from system command ( see run.c ) */
|
|
if( phase == 0 )
|
|
{
|
|
/* check if we run under linux console or under xterm */
|
|
hb_sln_Init_TermType();
|
|
|
|
#ifdef HB_OS_LINUX
|
|
/* for Linux console */
|
|
if( hb_sln_UnderLinuxConsole )
|
|
s_hb_sln_Abort_key = 0;
|
|
#endif
|
|
|
|
/* get Dead key definition */
|
|
p = ( unsigned char * ) hb_getenv( hb_DeadKeyEnvName );
|
|
|
|
if( p && p[ 0 ] != '\0' )
|
|
{
|
|
int len = strlen( ( char * ) p );
|
|
if( len > 0 )
|
|
hb_DeadKey = ( int ) *p;
|
|
}
|
|
if( p )
|
|
hb_xfree( ( void * ) p );
|
|
|
|
/* number of keys dealing with a Dead key */
|
|
hb_sln_convKDeadKeys[ 0 ] = 0;
|
|
}
|
|
|
|
/* Ctrl+\ to abort, no flow-control, no output processing */
|
|
if( SLang_init_tty( s_hb_sln_Abort_key, 0, 0 ) != -1 )
|
|
{
|
|
/* do missing disable of start/stop processing */
|
|
if( tcgetattr( SLang_TT_Read_FD, &newTTY ) == 0 )
|
|
{
|
|
newTTY.c_cc[ VSTOP ] = 255; /* disable ^S start/stop processing */
|
|
newTTY.c_cc[ VSTART ] = 255; /* disable ^Q start/stop processing */
|
|
newTTY.c_cc[ VSUSP ] = 255; /* disable ^Z suspend processing */
|
|
/* already done in Slang library */
|
|
/* newTTY.c_cc[ VDSUSP ] = 255; */ /* disable ^Y delayed suspend processing */
|
|
|
|
if( tcsetattr( SLang_TT_Read_FD, TCSADRAIN, &newTTY ) == 0 )
|
|
/* everything looks ok so far */
|
|
ret = 1;
|
|
}
|
|
}
|
|
|
|
/* first time init phase - we don't want this after
|
|
return from system command ( see run.c ) */
|
|
if( ret && ( phase == 0 ) )
|
|
{
|
|
/* define keyboard translations */
|
|
hb_sln_Init_KeyTranslations();
|
|
|
|
/* for binary search of key translations */
|
|
hb_sln_SortKeyTranslationTable();
|
|
}
|
|
|
|
return( ret );
|
|
}
|
|
|
|
/* *********************************************************************** */
|
|
|
|
int hb_gt_sln_ReadKey( int iEventMask )
|
|
{
|
|
static int InDeadState = FALSE;
|
|
unsigned int ch, tmp, kbdflags;
|
|
BOOL fInput;
|
|
int iKey;
|
|
|
|
HB_TRACE(HB_TR_DEBUG, ("hb_gt_sln_ReadKey(%d)", (int) iEventMask));
|
|
|
|
/* user AbortKey break */
|
|
if( SLKeyBoard_Quit == 1 )
|
|
return HB_BREAK_FLAG;
|
|
|
|
/* has screen size changed ? */
|
|
if( hb_sln_bScreen_Size_Changed )
|
|
{
|
|
hb_sln_bScreen_Size_Changed = FALSE;
|
|
SLtt_get_screen_size();
|
|
#if SLANG_VERSION > 10202
|
|
SLsmg_reinit_smg();
|
|
#endif
|
|
|
|
/* TODO: we need here some kind of screen redrawing */
|
|
/*SLsmg_refresh();*/
|
|
hb_gt_Resize( SLtt_Screen_Rows, SLtt_Screen_Cols );
|
|
}
|
|
|
|
fInput = SLang_input_pending( 0 ) != 0;
|
|
iKey = hb_gt_sln_mouse_Inkey( iEventMask, !fInput );
|
|
if( !fInput || iKey != 0 )
|
|
return iKey;
|
|
|
|
#if HB_GT_KBD_MODIF_MASK
|
|
kbdflags = hb_sln_try_get_Kbd_State();
|
|
#else
|
|
kbdflags = 0;
|
|
#endif
|
|
|
|
/* ------- one key ESC handling ----------------- */
|
|
/* NOTE: This will probably not work on slow terminals
|
|
or on very busy lines (i.e. modem lines ) */
|
|
ch = SLang_getkey();
|
|
if( ch == 033 ) /* escape char received, check for any pending chars */
|
|
{
|
|
if( hb_sln_escDelay == 0 )
|
|
{
|
|
/* standard acction, wait a 1 second for next char and if not then exit */
|
|
if( 0 == SLang_input_pending( 10 ) )
|
|
return( 0 );
|
|
}
|
|
else
|
|
{
|
|
/* wait hb_sln_escDelay milisec for next char and in not return ESC keycode */
|
|
if( 0 == SLang_input_pending( - HB_MAX( hb_sln_escDelay, 0 ) ) )
|
|
return( 033 );
|
|
}
|
|
}
|
|
|
|
/* user AbortKey break */
|
|
if( (int) ch == s_hb_sln_Abort_key )
|
|
return HB_BREAK_FLAG;
|
|
|
|
SLang_ungetkey( ch );
|
|
/* ------------------------------------------------- */
|
|
|
|
ch = SLkp_getkey();
|
|
|
|
/* unrecognized character */
|
|
if( ch == SL_KEY_ERR )
|
|
return( 0 );
|
|
|
|
/* Dead key handling */
|
|
if( InDeadState )
|
|
{
|
|
InDeadState = FALSE;
|
|
if( (int) ch == hb_DeadKey ) /* double press Dead key */
|
|
return( ch );
|
|
if( ch < 256 ) /* is this needed ??? */
|
|
{
|
|
int i;
|
|
for( i=0; i < ( int ) hb_sln_convKDeadKeys[ 0 ]; i++ )
|
|
if( ( int ) hb_sln_convKDeadKeys[ 2 * i + 1 ] == (int) ch )
|
|
return( ( int ) hb_sln_convKDeadKeys[ 2 * i + 2 ] );
|
|
}
|
|
return( 0 );
|
|
}
|
|
else if( (int) ch == hb_DeadKey )
|
|
{
|
|
/* entering Dead key state */
|
|
InDeadState = TRUE;
|
|
return( 0 );
|
|
}
|
|
|
|
/* any special key ? */
|
|
if( ( tmp = ( ch | ( kbdflags << 16 ) ) ) > 256 )
|
|
{
|
|
if( tmp == SL_KEY_MOU )
|
|
{
|
|
hb_gt_sln_mouse_ProcessTerminalEvent();
|
|
return hb_gt_sln_mouse_Inkey( iEventMask, FALSE );
|
|
}
|
|
|
|
if( ( iEventMask & INKEY_RAW ) != 0 )
|
|
return tmp;
|
|
|
|
tmp = hb_sln_FindKeyTranslation( tmp );
|
|
if( tmp != 0 )
|
|
return tmp;
|
|
|
|
/* TOFIX: this code is broken - needs a diffrent aproach */
|
|
tmp = hb_sln_FindKeyTranslation( ch );
|
|
if( tmp != 0 || ch > 256 )
|
|
return tmp;
|
|
}
|
|
|
|
#if !defined( HB_CDP_SUPPORT_OFF ) && ( defined( HB_SLN_UTF8 ) || defined( HB_SLN_UNICODE ) )
|
|
if ( hb_sln_Is_Unicode && ch < 256 )
|
|
{
|
|
int n = 0;
|
|
USHORT uc = 0;
|
|
|
|
if ( hb_cdpGetFromUTF8( hb_sln_cdpIN, FALSE, (BYTE) ch, &n, &uc ) )
|
|
{
|
|
unsigned int buf[ 10 ], i = 0;
|
|
|
|
while ( n > 0 )
|
|
{
|
|
if( SLang_input_pending( hb_sln_escDelay == 0 ? -100 :
|
|
- HB_MAX( hb_sln_escDelay, 0 ) ) == 0 )
|
|
break;
|
|
buf[ i++ ] = SLang_getkey();
|
|
if ( !hb_cdpGetFromUTF8( hb_sln_cdpIN, FALSE, (BYTE) buf[ i - 1 ], &n, &uc ) )
|
|
break;
|
|
}
|
|
if ( n > 0 )
|
|
{
|
|
while ( i > 0 )
|
|
SLang_ungetkey( buf[ --i ] );
|
|
}
|
|
else
|
|
ch = uc;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/* standard ASCII key */
|
|
return ch < 256 ? hb_sln_inputTab[ ch ] : ch;
|
|
}
|
|
|
|
/* *********************************************************************** */
|
|
|
|
static int hb_sln_try_get_Kbd_State( void )
|
|
{
|
|
#if defined(__linux__)
|
|
unsigned char modifiers = 6;
|
|
|
|
if( ioctl( 0, TIOCLINUX, &modifiers ) < 0 )
|
|
return 0;
|
|
|
|
return ( int ) modifiers;
|
|
|
|
#elif defined(M_UNIX)
|
|
|
|
int modifiers = 0;
|
|
int IOcommand = 0;
|
|
|
|
if( ioctl( 0, TCGETSC, &IOcommand ) >= 0 )
|
|
{
|
|
/* if keyboard is not in SCANCODE mode */
|
|
if( IOcommand == KB_XSCANCODE )
|
|
{
|
|
/* try to set it to SCANCODE mode */
|
|
IOcommand = KB_ISSCANCODE;
|
|
if( ioctl( 0, TCSETSC, &IOcommand ) >= 0 )
|
|
{
|
|
/* if SCANCODE mode is set corectly try get KBD state */
|
|
if( ioctl( 0, KDGKBSTATE, &modifiers ) < 0 )
|
|
modifiers = 0;
|
|
|
|
/* turn a keyboard to a normal mode ( translation mode ) */
|
|
IOcommand = KB_XSCANCODE;
|
|
( void ) ioctl( 0, TCSETSC, &IOcommand )
|
|
}
|
|
}
|
|
/* keyboard is already in SCANCODE mode */
|
|
else if( ioctl( 0, KDGKBSTATE, &modifiers ) < 0 )
|
|
modifiers = 0;
|
|
|
|
return modifiers;
|
|
}
|
|
#endif
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* *********************************************************************** */
|
|
|
|
int hb_sln_Shft_Pressed()
|
|
{
|
|
return ( hb_sln_try_get_Kbd_State() & SHIFT_PRESSED ) != 0;
|
|
}
|
|
|
|
/* *********************************************************************** */
|
|
|
|
int hb_sln_Ctrl_Pressed()
|
|
{
|
|
return ( hb_sln_try_get_Kbd_State() & CONTROL_PRESSED ) != 0;
|
|
}
|
|
|
|
/* *********************************************************************** */
|
|
|
|
int hb_sln_Alt_Pressed()
|
|
{
|
|
return ( hb_sln_try_get_Kbd_State() & ALT_PRESSED ) != 0;
|
|
}
|
|
|
|
/* *********************************************************************** */
|
|
|
|
int hb_sln_Kbd_State()
|
|
{
|
|
return hb_sln_try_get_Kbd_State();
|
|
}
|
|
|
|
/* *********************************************************************** */
|