diff --git a/harbour/ChangeLog b/harbour/ChangeLog index b60d882cc5..6e88bd6f96 100644 --- a/harbour/ChangeLog +++ b/harbour/ChangeLog @@ -16,6 +16,35 @@ The license applies to all entries newer than 2009-04-28. */ +2011-08-12 18:06 UTC-0800 Pritpal Bedi (bedipritpal@hotmail.com) + + contrib/hbcuied + + contrib/hbcuied/cu_achoi.prg + + contrib/hbcuied/cu_desgn.prg + + contrib/hbcuied/cu_field.prg + + contrib/hbcuied/cu_main.prg + + contrib/hbcuied/cu_menu.prg + + contrib/hbcuied/cu_outpt.prg + + contrib/hbcuied/cu_prpty.prg + + contrib/hbcuied/cu_utlty.prg + + contrib/hbcuied/hbcuied.ch + + contrib/hbcuied/hbcuied.hbp + + Added: initial commit of Harbour's CUI Forms Editor. + + NOTE: It is a work-in-progress and hence is subject + to heavy changes. For now you can just play with + it, though, it does not offer anything singnificant. + Only building blocks are set in place. + + This code has been pulled out from my application + sources which is a part of much larger reports + object. Hence, it contains some code which + eventually will be stripped out. Also sources + need to be formatted heavily per Harbour standards. + + During next several days I will be occupied with + this development. Any suggessions coming in way + will highly benefit this tool. + 2011-08-12 15:49 UTC-0800 Pritpal Bedi (bedipritpal@hotmail.com) * contrib/hbide/ideactions.prg * contrib/hbide/ideedit.prg diff --git a/harbour/contrib/hbcuied/cu_achoi.prg b/harbour/contrib/hbcuied/cu_achoi.prg new file mode 100644 index 0000000000..fd080e21f2 --- /dev/null +++ b/harbour/contrib/hbcuied/cu_achoi.prg @@ -0,0 +1,817 @@ +/* + * $Id$ + */ + +/* + * Harbour Project source code: + * CUI Forms Editor + * + * Copyright 2011 Pritpal Bedi + * http://harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ +/* + * EkOnkar + * ( The LORD is ONE ) + * + * Harbour CUI Editor Source + * + * Pritpal Bedi + * 13Aug2011 + */ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ + +#include "inkey.ch" +#include "setcurs.ch" +#include "set.ch" +#include "achoice.ch" +#include "common.ch" +#include "hbclass.ch" + +//----------------------------------------------------------------------// + +#define K_MOVING 1001 +#define K_LEFT_DOWN 1002 +#define K_LEFT_DBLCLICK 1006 +#define K_LEFT_UP 1003 +#define K_RIGHT_DOWN 1004 +#define K_RIGHT_DBLCLICK 1007 +#define K_RIGHT_UP 1005 + +//----------------------------------------------------------------------// + +#define INRANGE( xLo, xVal, xHi ) ( ( xVal >= xLo ) .AND. ( xVal <= xHi ) ) +#define BETWEEN( xLo, xVal, xHi ) min( max( xLo, xVal ), xHi ) + +/*----------------------------------------------------------------------*/ + +FUNCTION VouchAChoice( nTop, nLft, nBtm, nRgt, acItems, xSelect, cUserFunc, nPos, nHiLytRow, oWin, nLastKey, cargo_ ) + LOCAL nChoice, oChoice + LOCAL crs := SetCursor( 0 ) + + oChoice := AChoiceNew():New( nTop, nLft, nBtm, nRgt, acItems, xSelect, ; + cUserFunc, ; + nPos, nHiLytRow, oWin, nLastKey, cargo_ ) + oChoice:Exe() + nChoice := oChoice:nPos + nLastKey := oChoice:nKey + oChoice:Destroy() + + SetCursor( crs ) + + RETURN ( nChoice ) + +/*----------------------------------------------------------------------*/ + +CREATE CLASS AChoiceNew + + VAR nTop, nLeft, nBottom, nRight + VAR acItems + VAR xSelect + VAR cUserFunc + VAR nPos + VAR nHiLiteRow + VAR oWin + VAR cargo_ + VAR nNumCols + VAR nNumRows + VAR acCopy + VAR alSelect + VAR nNewPos + VAR lFinished + VAR nKey + VAR nMode + VAR nAtTop + VAR nAtBtm + VAR nItems + VAR bScan + VAR lUserFunc + VAR nUserFunc + VAR bUserFunc + VAR cLoClr + VAR cHiClr + VAR cUnClr + VAR nFrstItem + VAR nLastItem + VAR bAction + VAR mrc_ + + METHOD init + METHOD Destroy + METHOD DispPageNew + METHOD DispLineNew + METHOD Up + METHOD Down + METHOD PageUp + METHOD PageDown + METHOD GoTop + METHOD GoBottom + METHOD Top + METHOD Bottom + METHOD GoTo + METHOD Exe + METHOD DeHilite + METHOD HiLite + METHOD DispAtNew + +ENDCLASS + +//----------------------------------------------------------------------// + +METHOD AChoiceNew:Destroy() + + RETURN NIL + +//----------------------------------------------------------------------// + +METHOD AChoiceNew:init( nTop, nLft, nBtm, nRgt, acItems, xSelect, ; + cUserFunc, nPos, nHiLiteRow, oWin, nLastKey, cargo_ ) + LOCAL nCntr + + HB_SYMBOL_UNUSED( nLastKey ) + + DEFAULT nTop TO 0 // The topmost row of the window + DEFAULT nLft TO 0 // The leftmost column of the window + DEFAULT nBtm TO maxrow() + 1 // The bottommost row of the windows + DEFAULT nRgt TO maxcol() + 1 // The rightmost column of the window + DEFAULT acItems TO {} // The items FROM which TO choose + DEFAULT xSelect TO .T. // Array OR logical, what is selectable + DEFAULT cUserFunc TO NIL // Optional FUNCTION FOR key exceptions + DEFAULT nPos TO 1 // The number of the selected item + DEFAULT nHiLiteRow TO 0 // The row TO be highlighted + + ::nTop := nTop + ::nLeft := nLft + ::nBottom := nBtm + ::nRight := nRgt + ::acItems := acItems + ::xSelect := xSelect + ::cUserFunc := cUserFunc + ::nPos := nPos + ::nHiLiteRow := nHiLiteRow + ::oWin := oWin + ::cargo_ := cargo_ + + ::nNumCols := 0 // Number of columns IN the window + ::nNumRows := 0 // Number of rows IN the window + ::acCopy := {} // A padded copy of the items + ::alSelect := {} // Select permission + ::nNewPos := 0 // The NEXT item TO be selected + ::lFinished := .F. // Is processing finished? + ::nKey := 0 // The keystroke TO be processed + ::nMode := AC_IDLE // The current operating mode + ::nAtTop := 1 // The number of the item at the top + ::nAtBtm := 1 // The number of the item at the bottom + ::nItems := 0 // The number of items + ::bScan := { | cX | IF( left( cX, 1 ) == upper( chr( ::nKey ) ), .T., .F. ) } + ::lUserFunc := ( !empty( ::cUserFunc ) ) + ::nUserFunc := 0 // RETURN value FROM user FUNCTION + ::bUserFunc := { || AC_ABORT } // Block form of user FUNCTION + ::cLoClr := Before( ",", setcolor() ) + ::cHiClr := Before( ",", After( ",", setcolor() ) ) + ::cUnClr := After( ",", After( ",", After( ",", After( ",", setcolor() ) ) ) ) + ::nFrstItem := 0 + ::nLastItem := 0 + ::bAction := NIL + ::mrc_ := {} + + IF ::lUserFunc + ::bUserFunc := &( "{|nM,nP,nH,nK,aC|" + ::cUserFunc + "(nM,nP,nH,nK,aC)}" ) + ENDIF + + IF empty( ::cHiClr ) + ::cHiClr := After( "/", ::cLoClr ) + "/" + Before( "/", ::cLoClr ) + ENDIF + + IF empty( ::cUnClr ) + ::cUnClr := ::cLoClr + ENDIF + + ::nNumCols := ::nRight - ::nLeft + 1 + ::nNumRows := ::nBottom - ::nTop + 1 + + aeval( ::acItems, { | x | IF( valtype( x ) == "C", aadd( ::acCopy, padr( x, ::nNumCols ) ), .F. ) } ) + ::nItems := len( ::acCopy ) + + ::alSelect := array( ::nItems ) + + IF valtype( ::xSelect ) == "A" + afill( ::alSelect, .T. ) + FOR nCntr := 1 TO len( ::xSelect ) + IF nCntr <= ::nItems + IF valtype( ::xSelect[ nCntr ] ) == "C" + IF empty( ::xSelect[ nCntr ] ) + ::lFinished := .T. + ::nPos := 0 + ELSE + ::alSelect[ nCntr ] := &( ::xSelect[ nCntr ] ) + ENDIF + ELSE + ::alSelect[ nCntr ] := ::xSelect[ nCntr ] + ENDIF + ELSE + nCntr := len( ::xSelect ) + 1 + ENDIF + NEXT + ELSE + afill( ::alSelect, ::xSelect ) + ENDIF + + RETURN SELF + +//----------------------------------------------------------------------// + +METHOD AChoiceNew:Exe() + + IF !( ::lFinished ) + ::nFrstItem := ascan( ::alSelect, .T. ) // First valid item + + IF ::nFrstItem == 0 + ::nLastItem := 0 + ::nPos := 0 + ::nMode := AC_NOITEM + ELSE + ::nMode := AC_IDLE + ::nLastItem := ::nItems + DO WHILE ( !( ::alSelect[ ::nLastItem ] ) ) + ::nLastItem-- + ENDDO + ENDIF + + // Ensure hilighted item can be selected + ::nPos := BETWEEN( ::nFrstItem, ::nPos, ::nLastItem ) + ::nNewPos := ::nPos + IF !( ::alSelect[ ::nNewPos ] ) + IF ::nNewPos == ::nLastItem + ::nNewPos := ::nFrstItem + ENDIF + DO WHILE ( !( ::alSelect[ ::nNewPos ] ) ) + ::nNewPos++ + ENDDO + ENDIF + ::nPos := ::nNewPos + + // Force hilighted row TO be valid + // + ::nHiLiteRow := BETWEEN( 0, ::nHiLiteRow, ::nNumRows - 1 ) + + // Force the topmost item TO be a valid index of the array + // + ::nAtTop := BETWEEN( 1, max( 1, ::nPos - ::nHiLiteRow ), ::nItems ) + + // Ensure as much of the selection area as possible is covered + // + IF ( ::nAtTop + ::nNumRows - 1 ) > ::nItems + ::nAtTop := max( 1, ::nItems - ::nNumrows + 1 ) + ENDIF + + ::DispPageNew() + ENDIF + + DO WHILE ( !::lFinished ) + + IF ::nMode != AC_GOTO .AND. ::nMode != AC_NOITEM + ::nKey := inkey( , INKEY_ALL + HB_INKEY_GTEVENT ) + ::nMode := AC_IDLE + ::mrc_ := { 0, 0, mRow(), mCol(), 0, LastKey(), .f. } + ENDIF + + #ifdef __WVT__ + IF nLastPos <> ::nPos + Wvt_DrawFocusRect( ::nTop + ( ::nPos - ::nAtTop ), ::nLeft, ; + ::nTop + ( ::nPos - ::nAtTop ), ::nRight ) + nLastPos := ::nPos + ENDIF + #ENDIF + + DO CASE + CASE ( ::bAction := SetKey( ::nKey ) ) != NIL + eval( ::bAction, ProcName( 1 ), ProcLine( 1 ), '' ) + + CASE ::nKey == K_MOVING + ::nPos := ::DispAtNew() + + CASE ::nKey == K_MWFORWARD + ::Up() + + CASE ::nKey == K_MWBACKWARD + ::Down() + + CASE ::nKey == K_LDBLCLK + ::nPos := ::DispAtNew() + ::nMode := AC_SELECT + + CASE ::nKey == K_LEFT_DOWN + IF ::mrc_[ 3 ] >= ::nTop .AND. ::mrc_[ 3 ] <= ::nBottom .AND. ; + ::mrc_[ 4 ] >= ::nLeft .AND. ::mrc_[ 4 ] <= ::nRight + keyboard( chr( K_ENTER ) ) + ENDIF + + CASE ( ( ::nKey == K_ESC ) .OR. ( ::nMode == AC_NOITEM ) ) .AND. ( !::lUserFunc ) + ::nMode := AC_ABORT + ::nPos := 0 + ::lFinished := .T. + + CASE ::nKey == K_UP + ::Up() + + CASE ::nKey == K_DOWN + ::Down() + + CASE ::nKey == K_PGUP + ::PageUp() + + CASE ::nKey == K_PGDN + ::PageDown() + + CASE ::nKey == K_HOME + ::Top() + + CASE ::nKey == K_END + ::Bottom() + + CASE ( ::nKey == K_CTRL_HOME .OR. ::nKey == K_CTRL_PGUP ) + ::GoTop() + + CASE ( ::nKey == K_CTRL_END .OR. ::nKey == K_CTRL_PGDN ) + ::GoBottom() + + CASE ( ::nKey == K_ENTER ) .AND. ( !::lUserFunc ) + ::nMode := AC_SELECT + ::lFinished := .T. + + CASE ( ::nKey == K_RIGHT ) .AND. ( !::lUserFunc ) + ::nPos := 0 + ::lFinished := .T. + + CASE ( ::nKey == K_LEFT ) .AND. ( !::lUserFunc ) + ::nPos := 0 + ::lFinished := .T. + + CASE INRANGE( 32, ::nKey, 255 ) .AND. ( ( !::lUserFunc ) .OR. ( ::nMode == AC_GOTO ) ) + ::GoTo() + ::nMode := AC_IDLE + + CASE ::nMode == AC_GOTO + ::nMode := AC_IDLE + + OTHERWISE + IF ::nKey == 0 + ::nMode := AC_IDLE + ELSE + ::nMode := AC_EXCEPT + ENDIF + + ENDCASE + + IF ::lUserFunc + ::nUserFunc := eval( ::bUserFunc, ::nMode, ::nPos, ; + ::nPos - ::nAtTop, ::nKey, ::cargo_ ) + DO CASE + CASE ::nUserFunc == AC_ABORT + ::lFinished := .T. + ::nPos := 0 + + CASE ::nUserFunc == AC_SELECT + ::lFinished := .T. + + CASE ::nUserFunc == AC_CONT + + CASE ::nUserFunc == AC_GOTO + ::nMode := AC_GOTO + + ENDCASE + ENDIF + ENDDO + + RETURN SELF + +//----------------------------------------------------------------------// + +METHOD AChoiceNew:DispPageNew() + LOCAL nCntr + LOCAL nRow := row() + LOCAL nCol := col() + LOCAL nRowPos, nPos + + DispBegin() + + FOR nCntr := 1 TO ::nNumRows + nRowPos := ::nTop + nCntr - 1 + nPos := ::nAtTop + nCntr - 1 + + IF INRANGE( 1, nPos, ::nItems ) + ::DispLineNew( nPos, nRowPos, nPos == ::nPos ) + ELSE + DispOutAt( nRowPos, ::nLeft, space( len( ::acCopy[ 1 ] ) ), ::cLoClr, ::oWin ) + ENDIF + NEXT + + DispEnd() + + SetPos( nRow,nCol ) + + RETURN SELF + +//----------------------------------------------------------------------// + +METHOD AChoiceNew:DispLineNew( nPos, nRow, lHiLite ) + + DispOutAt( nRow, ::nLeft, ::acCopy[ nPos ],; + IF( ::alSelect[ nPos ], ; + IF( lHiLite, ::cHiClr, ::cLoClr ), ::cUnClr ), ::oWin ) + + RETURN SELF + +//----------------------------------------------------------------------// + +METHOD AChoiceNew:DeHilite() + + ::DispLineNew( ::nPos, ::nTop + ( ::nPos - ::nAtTop ), .F. ) + + RETURN SELF + +//----------------------------------------------------------------------// + +METHOD AChoiceNew:HiLite() + + ::DispLineNew( ::nPos, ::nTop + ( ::nPos - ::nAtTop ), .T. ) + + RETURN SELF + +//----------------------------------------------------------------------// + +METHOD AChoiceNew:Up() + LOCAL nScroll + + IF ::nPos == ::nFrstItem + ::nMode := AC_HITTOP + IF ::nAtTop > max( 1, ::nPos - ::nNumRows + 1 ) + ::nAtTop := max( 1, ::nPos - ::nNumRows + 1 ) + ::DispPageNew() + ENDIF + ELSE + ::nNewPos := ::nPos - 1 + DO WHILE !( ::alSelect[ ::nNewPos ] ) + ::nNewPos-- + ENDDO + + IF INRANGE( ::nAtTop, ::nNewPos, ::nAtTop + ::nNumRows - 1 ) + ::DeHilite() + ::nPos := ::nNewPos + ::HiLite() + ELSE + DispBegin() + + ::DeHilite() + + nScroll := max( -::nNumRows, ( ::nNewPos - ( ::nAtTop + ::nNumRows - 1 ) ) ) + Scroll( ::nTop, ::nLeft, ::nBottom, ::nRight, nScroll ) + + ::nAtTop := ::nNewPos + ::nPos := max( ::nPos, ::nAtTop + ::nNumRows - 1 ) + + DO WHILE ( ::nPos > ::nNewPos ) + ::DispLineNew( ::nPos, ::nTop + ( ::nPos - ::nAtTop ), .F. ) + ::nPos-- + ENDDO + + ::HiLite() + + Dispend() + ENDIF + ENDIF + + RETURN SELF + +//----------------------------------------------------------------------// + +METHOD AChoiceNew:Down() + LOCAL nScroll + + IF ::nPos == ::nLastItem + ::nMode := AC_HITBOTTOM + IF ::nAtTop < min( ::nPos, ::nItems - ::nNumRows + 1 ) + ::nAtTop := min( ::nPos, ::nItems - ::nNumRows + 1 ) + ::DispPageNew() + ENDIF + ELSE + ::nNewPos := ::nPos + 1 + DO WHILE !( ::alSelect[ ::nNewPos ] ) + ::nNewPos++ + ENDDO + + IF INRANGE( ::nAtTop, ::nNewPos, ::nAtTop + ::nNumRows - 1 ) + ::DeHilite() + ::nPos := ::nNewPos + ::HiLite() + ELSE + Dispbegin() + + ::DeHilite() + + nScroll := min( ::nNumRows, ( ::nNewPos - ( ::nAtTop + ::nNumRows - 1 ) ) ) + scroll( ::nTop, ::nLeft, ::nBottom, ::nRight, nScroll ) + + ::nAtTop := ::nNewPos - ::nNumRows + 1 + ::nPos := max( ::nPos, ::nAtTop ) + DO WHILE ( ::nPos < ::nNewPos ) + ::DispLineNew( ::nPos, ::nTop + ( ::nPos - ::nAtTop ), .F. ) + ::nPos ++ + ENDDO + + ::Hilite() + + Dispend() + ENDIF + ENDIF + + RETURN SELF + +//----------------------------------------------------------------------// + +METHOD AChoiceNew:PageUp() + + IF ::nPos == ::nFrstItem + ::nMode := AC_HITTOP + IF ::nAtTop > max( 1, ::nPos - ::nNumRows + 1 ) + ::nAtTop := max( 1, ::nPos - ::nNumRows + 1 ) + ::DispPageNew() + ENDIF + ELSE + IF INRANGE( ::nAtTop, ::nFrstItem, ::nAtTop + ::nNumRows - 1 ) + ::nPos := ::nFrstItem + ::nAtTop := max( ::nPos - ::nNumRows + 1, 1 ) + ::DispPageNew() + ELSE + IF ( ::nPos - ::nNumRows + 1 ) < ::nFrstItem + ::nPos := ::nFrstItem + ::nAtTop := ::nFrstItem + ELSE + ::nPos := max( ::nFrstItem, ::nPos - ::nNumRows + 1 ) + ::nAtTop := max( 1, ::nAtTop - ::nNumRows + 1 ) + DO WHILE ( ::nPos > ::nFrstItem ) .AND. ( !( ::alSelect[ ::nPos ] ) ) + ::nPos-- + ::nAtTop-- + ENDDO + ::nAtTop := max( 1, ::nAtTop ) + ENDIF + ::DispPageNew() + ENDIF + ENDIF + + RETURN SELF + +//----------------------------------------------------------------------// + +METHOD AChoiceNew:PageDown() + LOCAL nGap + + IF ::nPos == ::nLastItem + ::nMode := AC_HITBOTTOM + IF ::nAtTop < min( ::nPos, max( 1, ::nItems - ::nNumRows + 1 ) ) + ::nAtTop := min( ::nPos, max( 1, ::nItems - ::nNumRows + 1 ) ) + ::DispPageNew() + ENDIF + ELSE + IF INRANGE( ::nAtTop, ::nLastItem, ::nAtTop + ::nNumRows - 1 ) + ::DeHilite() + ::nPos := ::nLastItem + ::Hilite() + ELSE + nGap := ::nPos - ::nAtTop + ::nPos := min( ::nLastItem, ::nPos + ::nNumRows - 1 ) + IF ( ::nPos + ::nNumRows - 1 ) > ::nLastItem + ::nAtTop := ::nLastItem - ::nNumRows + 1 + ::nPos := min( ::nLastItem, ::nAtTop + nGap ) + ELSE + ::nAtTop := ::nPos - nGap + ENDIF + + DO WHILE ( ::nPos < ::nLastItem ) .AND. !( ::alSelect[ ::nPos ] ) + ::nPos++ + ::nAtTop++ + ENDDO + + DO WHILE ( ::nAtTop + ::nNumRows - 1 ) > ::nItems + ::nAtTop-- + ENDDO + ::DispPageNew() + ENDIF + ENDIF + + RETURN SELF + +//----------------------------------------------------------------------// + +METHOD AChoiceNew:Top() + + IF ::nPos == ::nFrstItem + IF ::nAtTop == max( 1, ::nPos - ::nNumRows + 1 ) + ::nMode := AC_HITTOP + ELSE + ::nAtTop := max( 1, ::nPos - ::nNumRows + 1 ) + ::DispPageNew() + ENDIF + ELSE + ::nNewPos := ::nAtTop + DO WHILE !( ::alSelect[ ::nNewPos ] ) + ::nNewPos++ + ENDDO + IF ::nNewPos != ::nPos + ::DeHilite() + ::nPos := ::nNewPos + ::HiLite() + ENDIF + ENDIF + + RETURN SELF + +//----------------------------------------------------------------------// + +METHOD AChoiceNew:Bottom() + + IF ::nPos == ::nLastItem + IF ::nAtTop == min( ::nPos, ::nItems - ::nNumRows + 1 ) + ::nMode := AC_HITBOTTOM + ELSE + ::nAtTop := min( ::nPos, ::nItems - ::nNumRows + 1 ) + ::DispPageNew() + ENDIF + ELSE + ::nNewPos := ::nAtTop + ::nNumRows - 1 + DO WHILE !( ::alSelect[ ::nNewPos ] ) + ::nNewPos-- + ENDDO + IF ::nNewPos != ::nPos + ::DeHilite() + ::nPos := ::nNewPos + ::HiLite() + ENDIF + ENDIF + + RETURN SELF + +//----------------------------------------------------------------------// + +METHOD AChoiceNew:GoTop() + + IF ::nPos == ::nFrstItem + IF ::nAtTop == max( 1, ::nPos - ::nNumRows + 1 ) + ::nMode := AC_HITTOP + ELSE + ::nAtTop := max( 1, ::nPos - ::nNumRows + 1 ) + ::DispPageNew() + ENDIF + ELSE + ::nPos := ::nFrstItem + ::nAtTop := ::nPos + ::DispPageNew() + ENDIF + + RETURN SELF + +//----------------------------------------------------------------------// + +METHOD AChoiceNew:GoBottom() + + IF ::nPos == ::nLastItem + IF ::nAtTop == min( ::nLastItem, ::nItems - ::nNumRows + 1 ) + ::nMode := AC_HITBOTTOM + ELSE + ::nAtTop := min( ::nLastItem, ::nItems - ::nNumRows + 1 ) + ::DispPageNew() + ENDIF + ELSE + IF INRANGE( ::nAtTop, ::nLastItem, ::nAtTop + ::nNumRows - 1 ) + ::DeHilite() + ::nPos := ::nLastItem + ::HiLite() + ELSE + ::nPos := ::nLastItem + ::nAtTop := max( 1, ::nPos - ::nNumRows + 1 ) + ::DispPageNew() + ENDIF + ENDIF + + RETURN SELF + +//----------------------------------------------------------------------// + +METHOD AChoiceNew:GoTo() + + ::nNewPos := ascan( ::acCopy, ::bScan, ::nPos + 1 ) + DO WHILE INRANGE( ::nPos, ::nNewPos, ::nLastItem ) .AND. !( ::alSelect[ ::nNewPos ] ) + ::nNewPos := ascan( ::acCopy, ::bScan, ::nNewPos + 1 ) + ENDDO + + IF ::nNewPos == 0 + ::nNewPos := ascan( ::acCopy, ::bScan ) + DO WHILE INRANGE( 1, ::nNewPos, ::nLastItem ) .AND. !( ::alSelect[ ::nNewPos ] ) + ::nNewPos := ascan( ::acCopy, ::bScan, ::nNewPos + 1 ) + ENDDO + ENDIF + + IF INRANGE( ::nFrstItem, ::nNewPos, ::nLastItem ) .AND. ::alSelect[ ::nNewPos ] + IF INRANGE( ::nAtTop, ::nNewPos, ::nAtTop + ::nNumRows - 1 ) + ::DeHilite() + ::nPos := ::nNewPos + ::HiLite() + ELSE + ::nPos := ::nNewPos + ::nAtTop := BETWEEN( 1, ::nPos - ::nNumRows + 1, ::nItems ) + ::DispPageNew() + ENDIF + ENDIF + + RETURN SELF + +//----------------------------------------------------------------------// + +METHOD AChoiceNew:DispAtNew() + LOCAL nNewPos + + IF ::mrc_[ 3 ] >= ::nTop .AND. ::mrc_[ 3 ] <= ::nTop + ::nNumRows - 1 ; + .AND. ; + ::mrc_[ 4 ] >= ::nLeft .AND. ::mrc_[ 4 ] <= ::nRight + + IF ( nNewPos := ::nAtTop + ( ::mrc_[ 3 ] - ::nTop ) ) <> ::nPos + IF ::alSelect[ nNewPos ] + ::DeHilite() + ::nPos := nNewPos + ::nNewPos := ::nPos + ::HiLite() + ENDIF + ENDIF + ENDIF + + RETURN ::nPos + +//----------------------------------------------------------------------// + +STATIC FUNCTION Before( cDelim, cValue ) + LOCAL cRetVal := cValue + + IF cDelim $ cValue + cRetVal := left( cValue, at( cDelim, cValue ) - 1 ) + ENDIF + + RETURN ( cRetVal ) + +//----------------------------------------------------------------------// + +STATIC FUNCTION After( cDelim, cValue ) + LOCAL cRetVal := '' + + IF cDelim $ cValue + cRetVal := substr( cValue, at( cDelim, cValue ) + 1 ) + ENDIF + + RETURN ( cRetVal ) + +//----------------------------------------------------------------------// + diff --git a/harbour/contrib/hbcuied/cu_desgn.prg b/harbour/contrib/hbcuied/cu_desgn.prg new file mode 100644 index 0000000000..e57521cba1 --- /dev/null +++ b/harbour/contrib/hbcuied/cu_desgn.prg @@ -0,0 +1,1410 @@ +/* + * $Id$ + */ + +/* + * Harbour Project source code: + * CUI Forms Editor + * + * Copyright 2011 Pritpal Bedi + * http://harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ +/* + * EkOnkar + * ( The LORD is ONE ) + * + * Harbour CUI Editor Source + * + * Pritpal Bedi + * 13Aug2011 + */ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ + +#include "hbcuied.ch" +#include "common.ch" +#include "inkey.ch" + +//----------------------------------------------------------------------// + +#define K_WVT_FULLSCREEN 299701 + +#define K_WVT_BITMAP 299705 +#define K_WVT_FRAME 299706 +#define K_WVT_ELLIPSE 299707 +#define K_WVT_LINE_H 299708 +#define K_WVT_LINE_V 299709 +#define K_WVT_GRID 299710 +#define K_WVT_BARCODE 299711 +#define K_WVT_TEXTBOX 299712 + +#define K_WVT_CARRY 299721 +#define K_WVT_BROUGHT 299722 +#define K_WVT_SUMMARY 299723 +#define K_WVT_GROUP 299724 +#define K_WVT_MATRIX 299725 + +//----------------------------------------------------------------------// + +FUNCTION Operate( obj_,scn_ ) + LOCAL nObj, bError + LOCAL grf_:= { 43,45,46,48,49,50,51,52,53,54,55,56,57 } + + readinsert( .t. ) + + scrDisplay( scn_ ) + scrMove( obj_,scn_ ) + scrStatus( obj_,scn_ ) + keyboard( chr( K_UP ) ) + + bError := errorblock( {|e| break( e ) } ) + BEGIN SEQUENCE + + DO WHILE .t. + scn_[SCN_ROW_PREV] := scn_[SCN_ROW_CUR] + scn_[SCN_COL_PREV] := scn_[SCN_COL_CUR] + scn_[SCN_REFRESH] := OBJ_REFRESH_NIL + + setCursor( .t. ) + setCursor( IF( readInsert(),2,1 ) ) + + DO WHILE .t. + scn_[ SCN_LASTKEY ] := inkey( 0, INKEY_ALL + HB_INKEY_GTEVENT ) + IF scn_[ SCN_LASTKEY ] <> K_MOUSEMOVE + EXIT + ENDIF + ENDDO + + DO CASE + CASE scn_[SCN_GRAPHICS] .AND. ascan( grf_,scn_[ SCN_LASTKEY ] ) > 0 + //processkey() + + CASE scrMouse( obj_, scn_, scn_[ SCN_LASTKEY ] ) +#IF 0 + CASE scn_[ SCN_LASTKEY ] == K_ALT_F6 + graphChar() + scn_[SCN_GRAPHICS] := !scn_[SCN_GRAPHICS] + scn_[SCN_REFRESH ] := OBJ_REFRESH_ALL +#ENDIF + /* Save Report */ + CASE scn_[ SCN_LASTKEY ] == K_ESC + //EXIT + Wvt_KeyBoard( K_CTRL_ENTER ) + CASE scn_[ SCN_LASTKEY ] == K_CTRL_ENTER + EXIT + + CASE scn_[ SCN_LASTKEY ] == K_RIGHT + scrMovRgt( scn_ ) + CASE scn_[ SCN_LASTKEY ] == K_LEFT + scrMovLft( scn_ ) + CASE scn_[ SCN_LASTKEY ] == K_UP + scrMovUp( scn_ ) + CASE scn_[ SCN_LASTKEY ] == K_DOWN + scrMovDn( scn_ ) + CASE scn_[ SCN_LASTKEY ] == K_MWBACKWARD + scrMovDn( scn_ ) + CASE scn_[ SCN_LASTKEY ] == K_MWFORWARD + scrMovUp( scn_ ) + CASE scn_[ SCN_LASTKEY ] == K_HOME + IF scn_[SCN_DESIGN] == DGN_MODULE .OR. scn_[SCN_DESIGN]==DGN_SCREEN + scn_[SCN_COL_REP] -= (scn_[SCN_COL_CUR] - scn_[SCN_LEFT] ) + scn_[SCN_COL_CUR] := scn_[SCN_LEFT] + ELSE + scn_[SCN_COL_REP] := 1 + scn_[SCN_COL_CUR] := scn_[SCN_LEFT] + scn_[SCN_COL_DIS] := scn_[SCN_LEFT]-1 + scn_[SCN_REFRESH] := OBJ_REFRESH_ALL + ENDIF + CASE scn_[ SCN_LASTKEY ] == K_END + IF scn_[SCN_DESIGN] == DGN_MODULE .OR. scn_[SCN_DESIGN]==DGN_SCREEN + scn_[SCN_COL_REP] += (scn_[SCN_RIGHT] - scn_[SCN_COL_CUR] ) + scn_[SCN_COL_CUR] := scn_[SCN_RIGHT] + ELSE + scn_[SCN_COL_REP] := scn_[SCN_COL_MAX] + scn_[SCN_COL_CUR] := scn_[SCN_RIGHT] + scn_[SCN_COL_DIS] := (scn_[SCN_LEFT]-1) - (scn_[SCN_COL_REP]-(scn_[SCN_RIGHT]-scn_[SCN_LEFT]+1)) + scn_[SCN_REFRESH] := OBJ_REFRESH_ALL + ENDIF + CASE scn_[ SCN_LASTKEY ] == K_PGUP + IF scn_[SCN_DESIGN] == DGN_MODULE .OR. scn_[SCN_DESIGN]==DGN_SCREEN + scn_[SCN_ROW_REP] -= ( scn_[ SCN_ROW_CUR ] - scn_[ SCN_TOP ] + 1 ) + scn_[SCN_ROW_CUR] := scn_[SCN_TOP] + ELSE + // scrMovPgUp(scn_) + scn_[SCN_ROW_REP] := 1 + scn_[SCN_ROW_CUR] := scn_[SCN_TOP] + scn_[SCN_ROW_DIS] := scn_[SCN_TOP] - 1 + scn_[SCN_REFRESH] := OBJ_REFRESH_ALL + ENDIF + CASE scn_[ SCN_LASTKEY ] == K_PGDN + IF scn_[SCN_DESIGN] == DGN_MODULE .OR. scn_[SCN_DESIGN]==DGN_SCREEN + scn_[SCN_ROW_REP] += (scn_[SCN_BOTTOM] - scn_[SCN_ROW_CUR] + 1) + scn_[SCN_ROW_CUR] := scn_[SCN_BOTTOM] + ELSE + // scn_[SCN_ROW_REP] := scn_[SCN_REP_LINES] + // scn_[SCN_ROW_CUR] := scn_[SCN_BOTTOM] + ENDIF + + CASE scn_[ SCN_LASTKEY ] == K_INS + readInsert( !readInsert() ) + setcursor( iif( readInsert(),2,1 ) ) + + CASE scn_[ SCN_LASTKEY ] == K_ENTER + IF scn_[ SCN_MODE ] == OBJ_MODE_SELECT .AND. scn_[ SCN_OBJ_SELECTED ] > 0 + obj_[ scn_[ SCN_OBJ_SELECTED ], OBJ_SECTION ] := scrSecCur( scn_, scn_[ SCN_ROW_REP ] ) + //IF scn_[SCN_DESIGN] <> DGN_SCREEN .OR. scn_[SCN_DESIGN] <> DGN_MODULE + scn_[ SCN_COL_MAX ] := max( scn_[ SCN_COL_MAX ], obj_[ scn_[ SCN_OBJ_SELECTED ], OBJ_TO_COL ] + 1 ) + //ENDIF + scn_[ SCN_MODE ] := OBJ_MODE_IDLE + scn_[ SCN_REFRESH ] := OBJ_REFRESH_LINE + scn_[ SCN_OBJ_SELECTED ] := 0 + scrMsg() + ENDIF + + CASE inRange( scn_[ SCN_LASTKEY ], K_SPACE, 254 ) .AND. scn_[ SCN_MODE ] <> OBJ_MODE_SELECT + scrAddTxt( obj_, scn_, scn_[ SCN_LASTKEY ], 1 ) + + CASE scn_[ SCN_LASTKEY ] == K_F1 // Help + help('NWREPORT') + + CASE scn_[ SCN_LASTKEY ] == K_F2 // Calculator + //calculate() + + CASE scn_[ SCN_LASTKEY ] == K_F3 // OBJECT + scrObject(obj_,scn_) + + CASE scn_[ SCN_LASTKEY ] == K_F4 // Properties + scrProperty(obj_,scn_) + + CASE scn_[ SCN_LASTKEY ] == K_F7 .OR. scn_[ SCN_LASTKEY ] == K_ALT_C // Copy + scrObjCopy(obj_,scn_) + + CASE scn_[ SCN_LASTKEY ] == K_F8 .OR. scn_[ SCN_LASTKEY ] == K_ALT_V // Paste + scrObjPas(obj_,scn_) + + CASE scn_[ SCN_LASTKEY ] == K_F9 // Box + scrAddBox( obj_,scn_,0 ) + + CASE scn_[ SCN_LASTKEY ] == K_F10 // Fields + scrAddFld( obj_,scn_,0 ) + + CASE scn_[ SCN_LASTKEY ] == K_DEL + IF ! empty( scn_[ SCN_TEXT_BLOCK_] ) + obj_:= scrTextDel(obj_,scn_) + scrOrdObj(obj_,scn_) + scn_[SCN_MODE] := 0 + scn_[SCN_OBJ_SELECTED] := 0 + scn_[SCN_OBJ_HILITE] := 0 + scn_[SCN_REFRESH] := OBJ_REFRESH_ALL + ELSEIF scrIsObjTxt( obj_,scn_ ) + scrAddTxt(obj_,scn_,scn_[ SCN_LASTKEY ],2) + ELSEIF scn_[SCN_MODE] == OBJ_MODE_SELECT + obj_:= scrObjDel( obj_, scn_, scn_[ SCN_OBJ_SELECTED ] ) + scn_[SCN_MODE] := 0 + scn_[SCN_OBJ_SELECTED] := 0 + ELSEIF scn_[ SCN_OBJ_HILITE ] > 0 + obj_:= scrObjDel( obj_, scn_, scn_[ SCN_OBJ_HILITE ] ) + scn_[ SCN_MODE ] := 0 + scn_[ SCN_OBJ_SELECTED ] := 0 + scn_[ SCN_OBJ_HILITE ] := 0 + scn_[ SCN_REFRESH ] := OBJ_REFRESH_ALL + ENDIF + + CASE scn_[ SCN_LASTKEY ] == K_BS + IF scn_[SCN_MODE] <> OBJ_MODE_SELECT + IF scrMovLft( scn_ ) + IF scrIsObjTxt( obj_,scn_ ) + scrAddTxt( obj_,scn_,scn_[ SCN_LASTKEY ], 3 ) + ENDIF + ENDIF + ENDIF + + CASE scn_[ SCN_LASTKEY ] == K_ALT_B + scrAddBox( obj_,scn_,0 ) + + CASE scn_[ SCN_LASTKEY ] == K_ALT_F + scrAddFld( obj_,scn_,0 ) + CASE scn_[ SCN_LASTKEY ] == K_ALT_E + scrAddExp( obj_,scn_,0 ) + CASE scn_[ SCN_LASTKEY ] == K_ALT_N + scrAddLine( obj_,scn_ ) + CASE scn_[ SCN_LASTKEY ] == K_ALT_O + scrDelLine( obj_,scn_ ) + CASE scn_[ SCN_LASTKEY ] == K_ALT_W + scrRepCol( obj_,scn_ ) + CASE scn_[ SCN_LASTKEY ] == K_ALT_M + //arview( { scn_,obj_ } ) + CASE scn_[ SCN_LASTKEY ] == K_CTRL_F6 // Selection of Block + scrTextBlock( obj_,scn_ ) + CASE scn_[ SCN_LASTKEY ] == K_CTRL_F7 // Move, Copy + obj_:= scrTextMove( obj_,scn_,1 ) + CASE scn_[ SCN_LASTKEY ] == K_CTRL_F8 // Move, Cut AND Paste + obj_:= scrTextMove( obj_,scn_,0 ) + CASE scn_[ SCN_LASTKEY ] == K_SH_F4 + scrForRows( obj_,scn_ ) + CASE scn_[ SCN_LASTKEY ] == K_CTRL_Z + scrExport( obj_,scn_ ) + CASE scn_[ SCN_LASTKEY ] == K_CTRL_W + scrImport( @obj_,@scn_ ) + CASE scn_[ SCN_LASTKEY ] == HB_K_RESIZE + ScrWvtConfig( obj_, scn_ ) + scrDisplay( scn_ ) + scrMove( obj_,scn_ ) + scrStatus( obj_,scn_ ) + CASE scn_[ SCN_LASTKEY ] == K_WVT_FRAME + scrAddBox( obj_, scn_, 0, 2 ) + + CASE scn_[ SCN_LASTKEY ] == K_WVT_MATRIX + arview({scn_,obj_}) + + ENDCASE + + IF scn_[SCN_MODE] == OBJ_MODE_SELECT + scn_[SCN_REFRESH] := iif( scn_[ SCN_REFRESH ] == OBJ_REFRESH_NIL,; + OBJ_REFRESH_LINE, scn_[ SCN_REFRESH ] ) + scrUpdObjRC( obj_,scn_ ) + ENDIF + + // Check on which OBJECT cursor is placed + // + nObj := scrChkObj( obj_,scn_ ) + + IF nObj > 0 .AND. scn_[ SCN_MODE ] <> OBJ_MODE_SELECT + scn_[ SCN_REFRESH ] := iif( scn_[ SCN_REFRESH ] == OBJ_REFRESH_NIL, OBJ_REFRESH_LINE, scn_[ SCN_REFRESH ] ) + scn_[ SCN_OBJ_HILITE ] := nObj + scrOnFirstCol( obj_, scn_, nObj, { OBJ_O_FIELD, OBJ_O_EXP } ) + + ELSEIF ! empty( scn_[ SCN_OBJ_HILITE ] ) + scn_[ SCN_REFRESH ] := iif( scn_[ SCN_REFRESH ] == OBJ_REFRESH_NIL, OBJ_REFRESH_LINE, scn_[ SCN_REFRESH ] ) + scn_[ SCN_OBJ_HILITE ] := 0 + + ENDIF + + IF nObj > 0 .AND. scn_[ SCN_LASTKEY ] == K_F5 // Edit + IF obj_[nObj,OBJ_TYPE] == OBJ_O_EXP + scrAddExp(obj_,scn_,nObj) + ELSEIF obj_[nObj,OBJ_TYPE] == OBJ_O_FIELD + scrAddFld(obj_,scn_,nObj) + ELSEIF obj_[nObj,OBJ_TYPE] == OBJ_O_TEXT + scrTxtProp(obj_,scn_,nObj) + ELSEIF obj_[nObj,OBJ_TYPE] == OBJ_O_BOX + scrAddBox(obj_,scn_,nObj) + ENDIF + ENDIF + + // Is the OBJECT selected + IF nObj > 0 .AND. scn_[ SCN_LASTKEY ] == K_F6 .AND. obj_[nObj,OBJ_TYPE] == OBJ_O_BOX + scn_[SCN_MODE] := OBJ_MODE_SELECT + scn_[SCN_OBJ_SELECTED] := nObj + scrOnFirstCol( obj_, scn_, nObj, { OBJ_O_BOX } ) + scrMsg( "Box is Selected. Use Arrow Keys TO Move, Enter TO Finished !" ) + + ELSEIF nObj > 0 .AND. scn_[ SCN_LASTKEY ] == K_F6 .AND. ! ( obj_[ nObj,OBJ_TYPE ] == OBJ_O_BOX ) + scn_[ SCN_MODE ] := OBJ_MODE_SELECT + scn_[ SCN_OBJ_SELECTED ] := nObj + scrOnFirstCol( obj_,scn_,nObj,{ OBJ_O_TEXT } ) + scrMsg( "OBJECT is Selected. Use Arrow Keys TO Move, Enter TO Finished" ) + + ENDIF + + IF scn_[SCN_REFRESH] == OBJ_REFRESH_ALL + scrMove( obj_,scn_ ) + ELSEIF scn_[SCN_REFRESH] == OBJ_REFRESH_LINE + IF scrIsBoxIn( obj_,scn_ ) + scrMove( obj_,scn_ ) + ELSE + scrMoveLine( obj_,scn_ ) + ENDIF + ENDIF + + scrStatus( obj_,scn_ ) // Status Line + + IF scn_[ SCN_GRAPHICS ] // Graphics Window + //grfRest() + ENDIF + ENDDO + + RECOVER + alert('ERROR has occured WHILE designing this document, save it anyway!') + END SEQUENCE + errorBlock( bError ) + + IF scn_[ SCN_GRAPHICS ] + //graphChar() + scn_[ SCN_GRAPHICS ] := .f. + ENDIF + + scrOrdObj( obj_ ) + + RETURN { obj_,scn_ } + +//----------------------------------------------------------------------// + +FUNCTION scrOrdObj(obj_) + + // Objects are ordered as per their type + asort( obj_,,, {|e_,f_| e_[ OBJ_TYPE ] < f_[ OBJ_TYPE ] } ) + + RETURN obj_ + +//----------------------------------------------------------------------// + +FUNCTION scrMovRgt( scn_ ) + LOCAL lMoved := .t. + + scn_[SCN_COL_CUR]++ + IF scn_[SCN_COL_CUR] > scn_[SCN_RIGHT] + IF scn_[SCN_COL_MAX] > scn_[SCN_COL_REP] + scn_[SCN_COL_DIS]-- + scn_[SCN_COL_CUR]-- + scn_[SCN_COL_REP]++ + scn_[SCN_REFRESH] := OBJ_REFRESH_ALL + ELSE + lMoved := .f. + tone( 100,1 ) + scn_[SCN_COL_CUR]-- + ENDIF + ELSE + scn_[SCN_COL_REP]++ + ENDIF + RETURN lMoved + +//----------------------------------------------------------------------// + +FUNCTION scrMovLft( scn_ ) + LOCAL lMoved := .t. + scn_[SCN_COL_CUR]-- + IF scn_[SCN_COL_CUR] < scn_[SCN_LEFT] + IF scn_[SCN_COL_REP] > 1 + scn_[SCN_COL_DIS]++ + scn_[SCN_COL_CUR]++ + scn_[SCN_COL_REP]-- + scn_[SCN_REFRESH] := OBJ_REFRESH_ALL + ELSE + lMoved := .f. + tone(200,1) + scn_[SCN_COL_CUR]++ + ENDIF + ELSE + scn_[SCN_COL_REP]-- + ENDIF + RETURN lMoved + +//----------------------------------------------------------------------// + +FUNCTION scrMovUp(scn_) + LOCAL lMoved := .t. + + scn_[SCN_ROW_CUR]-- + IF scn_[SCN_ROW_CUR] < scn_[SCN_TOP] + scn_[SCN_ROW_CUR] := scn_[SCN_TOP] + IF scn_[SCN_ROW_REP] > 1 + scn_[SCN_ROW_DIS]++ + scn_[SCN_ROW_REP]-- + scn_[SCN_REFRESH] := OBJ_REFRESH_ALL + ELSE + lMoved := .f. + tone(300,1) + ENDIF + ELSE + scn_[SCN_ROW_REP]-- + ENDIF + RETURN lMoved + +//----------------------------------------------------------------------// + +FUNCTION scrMovDn(scn_) + LOCAL lMoved := .t. + + scn_[SCN_ROW_CUR]++ + IF scn_[SCN_ROW_CUR] > scn_[SCN_BOTTOM] + scn_[SCN_ROW_CUR] := scn_[SCN_BOTTOM] + IF scn_[SCN_ROW_REP] < scn_[SCN_REP_LINES] + scn_[SCN_ROW_DIS]-- + scn_[SCN_ROW_REP]++ + scn_[SCN_REFRESH] := OBJ_REFRESH_ALL + ELSE + lMoved := .f. + tone(300,1) + ENDIF + ELSE + scn_[SCN_ROW_REP]++ + ENDIF + RETURN lMoved + +//----------------------------------------------------------------------// + +FUNCTION scrMovPgUp(scn_) + LOCAL lMoved := .f. + + IF scn_[SCN_ROW_CUR] == scn_[SCN_TOP] + IF scn_[SCN_ROW_REP] > 1 + scn_[SCN_ROW_CUR] := scn_[SCN_TOP] + scn_[SCN_ROW_REP] := 1 + scn_[SCN_ROW_DIS] := scn_[SCN_TOP] - 1 + lMoved := .t. + scn_[SCN_REFRESH] := OBJ_REFRESH_ALL + ENDIF + ELSE // IF scn_[SCN_ROW_CUR] == scn_[SCN_ROW_BOTTOM] + scn_[SCN_ROW_CUR] := scn_[SCN_TOP] + scn_[SCN_ROW_REP] := scn_[SCN_ROW_REP] - (scn_[SCN_ROW_CUR] - scn_[SCN_TOP]) + scn_[SCN_ROW_DIS] := scn_[SCN_ROW_DIS] - (scn_[SCN_ROW_CUR] - scn_[SCN_TOP]) + lMoved := .t. + ENDIF + + RETURN lMoved + +//----------------------------------------------------------------------// + +STATIC FUNCTION scrExtn(scn_) + RETURN IF(scn_[SCN_DESIGN]==DGN_MODULE,'VMD',; + IF(scn_[SCN_DESIGN]==DGN_REPORT,'VRP',; + IF(scn_[SCN_DESIGN]==DGN_LABEL, 'VLB',; + IF(scn_[SCN_DESIGN]==DGN_DOCUMENT,'VDC','VSC')))) + +//----------------------------------------------------------------------// + +STATIC FUNCTION scrIsObjTxt(obj_,scn_) + RETURN ascan(obj_, {|e_| e_[OBJ_TYPE]==OBJ_O_TEXT; + .AND. ; + inRange(scn_[SCN_ROW_REP],e_[OBJ_ROW],e_[OBJ_TO_ROW]) ; + .AND. ; + inRange(scn_[SCN_COL_REP],e_[OBJ_COL],e_[OBJ_TO_COL]) }) > 0 + +//----------------------------------------------------------------------// + +FUNCTION scrChkObj(obj_,scn_) + LOCAL n + n := ascan(obj_,{|e_| IF(e_[OBJ_TYPE]==OBJ_O_BOX .OR. e_[OBJ_TYPE]==OBJ_O_BMP,.f.,; + inRange(scn_[SCN_ROW_REP],e_[OBJ_ROW],e_[OBJ_TO_ROW]) ; + .AND. ; + inRange(scn_[SCN_COL_REP],e_[OBJ_COL],e_[OBJ_TO_COL])) }) + IF empty(n) // No OBJECT other than box, check box,BMP + n := ascan(obj_,{|e_| ; + inRange(scn_[SCN_ROW_REP],e_[OBJ_ROW],e_[OBJ_TO_ROW]) ; + .AND. ; + inRange(scn_[SCN_COL_REP],e_[OBJ_COL],e_[OBJ_TO_COL]) }) + ENDIF + RETURN n + +//----------------------------------------------------------------------// + +STATIC FUNCTION scrUpdObjRC(obj_,scn_) + LOCAL nW, nH + LOCAL nObj := scn_[ SCN_OBJ_SELECTED ] + + IF nObj > 0 + nH := obj_[ nObj,OBJ_TO_ROW ] - obj_[ nObj,OBJ_ROW ] + nW := obj_[ nObj,OBJ_TO_COL ] - obj_[ nObj,OBJ_COL ] + + obj_[ nObj,OBJ_ROW ] := scn_[SCN_ROW_REP] + obj_[ nObj,OBJ_COL ] := scn_[SCN_COL_REP] + + IF obj_[ nObj,OBJ_TYPE ] == OBJ_O_BOX + obj_[ nObj,OBJ_TO_ROW ] := obj_[ nObj,OBJ_ROW ] + nH + obj_[ nObj,OBJ_TO_COL ] := obj_[ nObj,OBJ_COL ] + nW + ELSE + obj_[ nObj,OBJ_TO_ROW ] := scn_[SCN_ROW_REP] + obj_[ nObj,OBJ_TO_COL ] := scn_[SCN_COL_REP] + ; + len( obj_[ nObj, iif( obj_[ nObj,OBJ_TYPE ] == OBJ_O_TEXT, OBJ_EQN, OBJ_TEXT ) ] ) - 1 + ENDIF + ENDIF + RETURN NIL + +//----------------------------------------------------------------------// + +STATIC FUNCTION scrRepCol( obj_,scn_ ) + LOCAL oCol := scn_[SCN_COL_MAX], nCol + + HB_SYMBOL_UNUSED( obj_ ) + + IF scn_[SCN_DESIGN] == DGN_MODULE .OR. scn_[SCN_DESIGN] == DGN_SCREEN + RETURN NIL + ENDIF + + nCol := VouchGetSome( 'Number of Columns?', oCol ) + + IF !empty( nCol ) // .AND. nCol <> oCol + nCol := max( 10,nCol ) + scn_[SCN_COL_MAX ] := nCol + scn_[SCN_RIGHT ] := min( maxCol(), scn_[SCN_LEFT]+nCol-1 ) + scn_[SCN_REFRESH ] := OBJ_REFRESH_ALL + scn_[ SCN_PROPERTY, REP_COLS ] := nCol + ENDIF + + RETURN NIL + +//----------------------------------------------------------------------// +/* + This is the routine FROM where row based equations can be implemented +*/ +STATIC FUNCTION scrAddLine(obj_,scn_) + LOCAL nRow := scn_[SCN_ROW_REP], nSct + + #IF 0 + IF scn_[SCN_DESIGN] == DGN_MODULE .OR. scn_[SCN_DESIGN] == DGN_SCREEN + RETURN NIL + ENDIF + #ENDIF + + scn_[SCN_REFRESH] := OBJ_REFRESH_ALL + scn_[SCN_BOTTOM ] := min(scn_[SCN_BOTTOM]+1,maxrow()-3) + + nSct := scrSecOrd(scn_,nRow /*scn_[SCN_ROW_REP]*/) + + scn_[SCN_SECTORS_,nSct,SCT_ROWS]++ + scn_[SCN_REP_LINES]++ + + aeval(obj_,{|e_,i| IF(e_[OBJ_ROW] >= nRow, obj_[i,OBJ_TO_ROW] += 1,'') }) + aeval(obj_,{|e_,i| IF(e_[OBJ_ROW] >= nRow, obj_[i,OBJ_ROW ] += 1,'') }) + + scn_[SCN_REFRESH] := OBJ_REFRESH_ALL + + RETURN NIL + +//----------------------------------------------------------------------// + +STATIC FUNCTION scrDelLine(obj_,scn_) + LOCAL nRow := scn_[SCN_ROW_REP] + LOCAL nSct,n,isLast + + #IF 0 + IF scn_[SCN_DESIGN] == DGN_MODULE .OR. scn_[SCN_DESIGN] == DGN_SCREEN + RETURN NIL + ENDIF + #ENDIF + + isLast := nRow == scn_[SCN_REP_LINES] + + nSct := scrSecOrd(scn_,nRow /*scn_[SCN_ROW_REP]*/) + IF scn_[SCN_SECTORS_,nSct,SCT_ROWS] == 1 // A Single Row Must remain IN one group + RETURN NIL + ENDIF + + scn_[SCN_SECTORS_,nSct,SCT_ROWS]-- + scn_[SCN_REP_LINES]-- + + IF scn_[SCN_REP_LINES] < (scn_[SCN_BOTTOM]-scn_[SCN_TOP]+1) + scn_[SCN_BOTTOM] := max(scn_[SCN_TOP],min(scn_[SCN_BOTTOM]-1,maxrow()-3)) + ENDIF + + DO WHILE .t. + IF (n := ascan(obj_,{|e_| e_[OBJ_ROW] == nRow })) == 0 + EXIT + ENDIF + aShrink(obj_,n) + ENDDO + IF empty(obj_) + aadd(obj_,scrObjBlank()) + ENDIF + + aeval(obj_,{|e_,i| IF(e_[OBJ_ROW] > nRow, obj_[i,OBJ_TO_ROW] -= 1,'') }) + aeval(obj_,{|e_,i| IF(e_[OBJ_ROW] > nRow, obj_[i,OBJ_ROW] -= 1,'') }) + + IF isLast + scn_[SCN_ROW_REP]-- + scn_[SCN_ROW_CUR]-- + ENDIF + + scn_[SCN_REFRESH] := OBJ_REFRESH_ALL + + RETURN NIL + +//----------------------------------------------------------------------// + +STATIC FUNCTION scrIsBoxIn(obj_,scn_) + RETURN ascan(obj_,{|e_| inRange( scn_[SCN_ROW_REP ], e_[ OBJ_ROW ], e_[ OBJ_TO_ROW ] ); + .AND. ; + (e_[OBJ_TYPE] == OBJ_O_BOX ; + .OR. ; + e_[OBJ_TYPE] == OBJ_O_BMP ) } ) > 0 + +//----------------------------------------------------------------------// + +STATIC FUNCTION scrObjCopy(obj_,scn_) + + HB_SYMBOL_UNUSED( obj_ ) + + IF scn_[SCN_MODE] == OBJ_MODE_SELECT + scn_[SCN_OBJ_COPIED] := scn_[SCN_OBJ_SELECTED] + ELSEIF scn_[SCN_OBJ_HILITE] > 0 + scn_[SCN_OBJ_COPIED] := scn_[SCN_OBJ_HILITE] + ENDIF + RETURN NIL + +//----------------------------------------------------------------------// + +STATIC FUNCTION scrObjPas(obj_,scn_) // Paste Copied OBJECT + LOCAL nObj,o_,oldRow,oldCol,oldRow2,oldcol2 + + IF (nObj := scn_[SCN_OBJ_COPIED]) > 0 .AND. scn_[SCN_OBJ_SELECTED] == 0 + o_:= aclone(obj_[nObj]) + + oldRow := o_[OBJ_ROW] ; oldCol := o_[OBJ_COL] + oldRow2 := o_[OBJ_TO_ROW] ; oldCol2 := o_[OBJ_TO_COL] + + o_[OBJ_ROW] := scn_[SCN_ROW_REP] + o_[OBJ_COL] := scn_[SCN_COL_REP] + IF o_[OBJ_TYPE ] == OBJ_O_FIELD .OR. o_[OBJ_TYPE] == OBJ_O_EXP + o_[OBJ_TO_ROW] := scn_[SCN_ROW_REP] + o_[OBJ_TO_COL] := scn_[SCN_COL_REP] + len(o_[OBJ_TEXT]) - 1 + ELSEIF o_[OBJ_TYPE] == OBJ_O_BOX .OR. o_[OBJ_TYPE] == OBJ_O_BMP + o_[OBJ_TO_ROW] := scn_[SCN_ROW_REP] + (oldRow2-oldRow) + o_[OBJ_TO_COL] := scn_[SCN_COL_REP] + (oldCol2-oldCol) + ELSEIF o_[OBJ_TYPE] == OBJ_O_TEXT + o_[OBJ_TO_ROW] := scn_[SCN_ROW_REP] + o_[OBJ_TO_COL] := scn_[SCN_COL_REP] + (oldCol2-oldCol) + ENDIF + + o_[OBJ_SECTION] := scrSecCur(scn_,scn_[SCN_ROW_REP]) + + aadd(obj_,o_) + + scrOrdObj(obj_) + scn_[SCN_OBJ_SELECTED] := 0 + scn_[SCN_REFRESH ] := OBJ_REFRESH_LINE + scn_[SCN_MODE ] := 0 + scn_[SCN_OBJ_COPIED ] := 0 + ENDIF + RETURN NIL + +//----------------------------------------------------------------------// + +STATIC FUNCTION scrObjDel(obj_,scn_,nObj) + LOCAL s_:= obj_,nUnique := obj_[nObj,OBJ_OBJ_UNIQUE],n + + aShrink(s_,nObj) + IF empty(s_) + aadd(s_,scrObjBlank()) + ENDIF + scn_[SCN_OBJ_SELECTED] := 0 + scn_[SCN_REFRESH] := OBJ_REFRESH_LINE + + IF scn_[SCN_DESIGN] == DGN_MODULE .AND. nUnique > 0 + IF (n := ascan(scn_[SCN_FIELDS],{|e_| e_[1] == nUnique })) > 0 + aShrink(scn_[SCN_FIELDS],n) + ENDIF + ENDIF + RETURN s_ + +//----------------------------------------------------------------------// + +STATIC FUNCTION scrObject(obj_,scn_) + LOCAL nObj + LOCAL mnu_:={'Field Alt_F',; + 'Boxes Alt_B',; + ' ',; + 'Columns Width Alt_W',; + 'Graphic Characters Alt_F6',; + ' ',; + 'Copy OBJECT Alt_C',; + 'Paste OBJECT Alt_V',; + 'Selection of Block Ctrl_F6',; + 'Copy Selection Ctrl_F7',; + 'Cut & Paste Selection Ctrl_F8',; + ' ',; + 'Matrix Alt_M' } + + LOCAL sel_:= {.t.,.t.,; + .f.,; + .t.,.t.,.t.,.t.,; + .f.,; + .t.,.t.,.t.,.t.,.t.,; + .f.,; + .t. } + + B_MSG CHOOSE mnu_ RESTORE SHADOW CENTER INTO nObj SELECTABLES sel_ + + @ scn_[ SCN_ROW_CUR ], scn_[ SCN_COL_CUR ] SAY '' + + DO CASE + CASE nObj == 1 // Field + scrAddFld(obj_,scn_,0) + CASE nObj == 2 // Box + scrAddBox( obj_,scn_,0 ) + CASE nObj == 3 // Blank + + CASE nObj == 4 // Columns + scrRepCol(obj_,scn_) + CASE nObj == 5 // Graphcs + //graphChar() + scn_[SCN_GRAPHICS] := !scn_[SCN_GRAPHICS] + CASE nObj == 6 // Blank + + CASE nObj == 7 // Copy + scrObjCopy(obj_,scn_) + CASE nObj ==81 // Paste + scrObjPas(obj_,scn_) + CASE nObj == 9 // Block Selection + scrTextBlock(obj_,scn_) + CASE nObj == 10 // Copy Selectin + obj_:= scrTextMove(obj_,scn_,1) + CASE nObj == 11 // Copy & Cut Selection + obj_:= scrTextMove(obj_,scn_,0) + CASE nObj == 12 // Blank + + CASE nObj == 13 // Matrix + arview({scn_,obj_}) + ENDCASE + + RETURN nObj + +//----------------------------------------------------------------------// + +STATIC FUNCTION scrTxtProp(obj_,scn_,nObj) + LOCAL sel_, v_ + + obj_[nObj,OBJ_F_LEN] := len(obj_[nObj,OBJ_EQN]) + obj_[nObj,OBJ_F_TYPE] := 'C' + + v_:= scrObj2Vv(obj_[nObj]) + sel_:= scrVvSelAble(scn_) + + sel_[ VV_ID ] := .F. + sel_[ VV_ALIGN ] := .t. + sel_[ VV_COLOR ] := .T. + sel_[ VV_F_LEN ] := .F. + sel_[ VV_F_DEC ] := .f. + sel_[ VV_REPEATED ] := .F. + sel_[ VV_VERTICLE ] := .F. + sel_[ VV_WRAP_SEMI ] := .F. + sel_[ VV_ZERO ] := .F. + sel_[ VV_EQN ] := .F. + + scrField( nObj,3,obj_,scn_,v_,sel_,'W/B ' ) + + RETURN NIL + +//----------------------------------------------------------------------// + +STATIC FUNCTION scrOnFirstCol( obj_,scn_,nObj,type_ ) + LOCAL nCur, nOff + + IF scn_[ SCN_COL_REP ] <> obj_[ nObj,OBJ_COL ] + IF VouchInArray( obj_[ nObj, OBJ_TYPE ], type_ ) + IF obj_[ nObj, OBJ_TYPE ] == OBJ_O_BOX + nCur := scn_[ SCN_COL_CUR ] + nOff := scn_[ SCN_COL_REP ] - obj_[ nObj,OBJ_COL ] + scn_[ SCN_COL_CUR ] := max( scn_[ SCN_LEFT ], scn_[ SCN_COL_CUR ]-nOff ) + scn_[ SCN_COL_REP ] := obj_[nObj,OBJ_COL] + IF nOff > nCur - scn_[ SCN_LEFT ] + scn_[ SCN_REFRESH ] := OBJ_REFRESH_ALL + scn_[ SCN_COL_DIS ] += nOff - ( nCur - scn_[ SCN_LEFT ] ) + ENDIF + + nCur := scn_[ SCN_ROW_CUR ] + nOff := scn_[ SCN_ROW_REP ] - obj_[ nObj, OBJ_ROW ] + scn_[ SCN_ROW_CUR ] := max( scn_[ SCN_TOP ], scn_[ SCN_ROW_CUR ] - nOff ) + scn_[ SCN_ROW_REP ] := obj_[ nObj,OBJ_ROW ] + IF nOff > nCur - scn_[ SCN_TOP ] + scn_[ SCN_REFRESH ] := OBJ_REFRESH_ALL + scn_[ SCN_ROW_DIS ] += nOff - ( nCur - scn_[ SCN_TOP ] ) + ENDIF + + ELSE + IF scn_[ SCN_LASTKEY ] == K_RIGHT + nCur := scn_[ SCN_COL_CUR ] + nOff := obj_[ nObj, OBJ_TO_COL ] - scn_[ SCN_COL_REP ] + 1 // NEXT Col TO OBJECT + IF scn_[SCN_COL_REP] + nOff > scn_[SCN_COL_MAX] + scn_[SCN_COL_MAX] := scn_[ SCN_COL_REP ] + nOff + ENDIF + scn_[SCN_COL_CUR] := min( scn_[ SCN_RIGHT ], scn_[ SCN_COL_CUR ] + nOff ) + scn_[SCN_COL_REP] := obj_[ nObj,OBJ_TO_COL ] + 1 + IF nOff > scn_[SCN_RIGHT] - nCur + scn_[SCN_REFRESH] := OBJ_REFRESH_ALL + scn_[SCN_COL_DIS] -= nOff-(scn_[SCN_RIGHT]-nCur) + ENDIF + scn_[SCN_OBJ_HILITE] := 0 + ELSE + nCur := scn_[ SCN_COL_CUR ] + nOff := scn_[ SCN_COL_REP ] - obj_[ nObj,OBJ_COL ] + scn_[ SCN_COL_CUR ] := max( scn_[ SCN_LEFT ], scn_[ SCN_COL_CUR ]-nOff ) + scn_[ SCN_COL_REP ] := obj_[nObj,OBJ_COL] + IF nOff > nCur-scn_[SCN_LEFT] + scn_[SCN_REFRESH] := OBJ_REFRESH_ALL + scn_[SCN_COL_DIS] += nOff-(nCur-scn_[SCN_LEFT]) + ENDIF + ENDIF + ENDIF + ENDIF + ENDIF + RETURN NIL + +//----------------------------------------------------------------------// + +FUNCTION scrGetChar(obj_,nRow,nCol) + LOCAL s := THE_FILL,n + + // Locate Text + n := ascan(obj_,{|e_| e_[OBJ_ROW]==nRow .AND. ; + inRange(nCol,e_[OBJ_COL],e_[OBJ_TO_COL]) }) + IF n == 0 // Locate Box + n := ascan(obj_,{|e_| inRange(nRow,e_[OBJ_ROW],e_[OBJ_TO_ROW]) .AND. ; + inRange(nCol,e_[OBJ_COL],e_[OBJ_TO_COL]) }) + ENDIF + + IF n > 0 + IF obj_[n,OBJ_TYPE]==OBJ_O_TEXT + s := substr(obj_[n,OBJ_EQN],nCol-obj_[n,OBJ_COL]+1,1) + + ELSEIF obj_[n,OBJ_TYPE]==OBJ_O_FIELD .OR. obj_[n,OBJ_TYPE]==OBJ_O_EXP + s := substr(obj_[n,OBJ_ID ],nCol-obj_[n,OBJ_COL]+1,1) + + ELSEIF obj_[n,OBJ_TYPE]==OBJ_O_BOX .OR. obj_[n,OBJ_TYPE]==OBJ_O_BMP + IF nRow == obj_[n,OBJ_ROW ] + IF nCol == obj_[n,OBJ_COL] + s := substr(obj_[n,OBJ_BOX_SHAPE],1,1) + ELSEIF nCol == obj_[n,OBJ_TO_COL] + s := substr(obj_[n,OBJ_BOX_SHAPE],3,1) + ELSE + s := substr(obj_[n,OBJ_BOX_SHAPE],2,1) + ENDIF + ELSEIF nRow == obj_[n,OBJ_TO_ROW] + IF nCol == obj_[n,OBJ_COL] + s := substr(obj_[n,OBJ_BOX_SHAPE],7,1) + ELSEIF nCol == obj_[n,OBJ_TO_COL] + s := substr(obj_[n,OBJ_BOX_SHAPE],5,1) + ELSE + s := substr(obj_[n,OBJ_BOX_SHAPE],6,1) + ENDIF + ELSE + IF nCol == obj_[n,OBJ_COL] + s := substr(obj_[n,OBJ_BOX_SHAPE],8,1) // 4.8 are Same + ELSEIF nCol == obj_[n,OBJ_TO_COL] + s := substr(obj_[n,OBJ_BOX_SHAPE],4,1) + ELSE + s := substr(obj_[n,OBJ_BOX_SHAPE],9,1) + s := IF(empty(s),THE_FILL,s) + ENDIF + ENDIF + ENDIF + ENDIF + RETURN s + +//----------------------------------------------------------------------// + +STATIC FUNCTION scrTextBlock(obj_,scn_) + LOCAL n, nKey + LOCAL key_:= {K_RIGHT,K_LEFT,K_UP,K_DOWN,K_ENTER} + + scrMsg('Use TO Select Text Block, TO Finish') + scn_[SCN_TEXT_BLOCK_] := {scn_[SCN_ROW_REP],scn_[SCN_COL_REP],; + scn_[SCN_ROW_REP],scn_[SCN_COL_REP]} + scrMove(obj_,scn_) + scrStatus(obj_,scn_) + + DO WHILE .t. + nKey := scrInkey(key_) + + DO CASE + CASE nKey == key_[1] + IF scrMovRgt(scn_) + scn_[SCN_TEXT_BLOCK_,4]++ + ENDIF + CASE nKey == key_[2] + IF scrMovLft(scn_) + scn_[SCN_TEXT_BLOCK_,4]-- + ENDIF + CASE nKey == key_[3] + IF scrMovUp(scn_) + scn_[SCN_TEXT_BLOCK_,3]-- + ENDIF + CASE nKey == key_[4] + IF scrMovDn(scn_) + scn_[SCN_TEXT_BLOCK_,3]++ + ENDIF + CASE nKey == key_[5] + EXIT + ENDCASE + + IF scn_[SCN_TEXT_BLOCK_,3] < scn_[SCN_TEXT_BLOCK_,1] + n := scn_[SCN_TEXT_BLOCK_,1] + scn_[SCN_TEXT_BLOCK_,1] := scn_[SCN_TEXT_BLOCK_,3] + scn_[SCN_TEXT_BLOCK_,3] := n + ENDIF + + IF scn_[SCN_TEXT_BLOCK_,4] < scn_[SCN_TEXT_BLOCK_,2] + n := scn_[SCN_TEXT_BLOCK_,2] + scn_[SCN_TEXT_BLOCK_,2] := scn_[SCN_TEXT_BLOCK_,4] + scn_[SCN_TEXT_BLOCK_,4] := n + ENDIF + + scrMove(obj_,scn_) + scrStatus(obj_,scn_) + ENDDO + scrMsg('') + RETURN NIL + +//----------------------------------------------------------------------// + +STATIC FUNCTION scrTextMove(obj_,scn_,nMode) + LOCAL gst_,nKey + LOCAL crs := setCursor(0) + LOCAL key_:= {K_RIGHT,K_LEFT,K_UP,K_DOWN,K_ENTER} + + DEFAULT nMode TO 0 // 0.Paste 1.Copy + + IF !empty(scn_[SCN_TEXT_BLOCK_]) + // CREATE a ghost movement block + scrMsg('Use Arrow Keys TO Move Selected Block') + // Check FOR current cursor position + gst_:= {scn_[SCN_ROW_REP],scn_[SCN_COL_REP],; + scn_[SCN_ROW_REP]+scn_[SCN_TEXT_BLOCK_,3]-scn_[SCN_TEXT_BLOCK_,1],; + scn_[SCN_COL_REP]+scn_[SCN_TEXT_BLOCK_,4]-scn_[SCN_TEXT_BLOCK_,2]} + DO WHILE .t. + scrMove(obj_,scn_) + scrDispGhost(obj_,scn_,gst_) + scrStatus(obj_,scn_) + + nKey := scrInkey(key_) + DO CASE + CASE nKey == key_[1] + IF scrMovRgt(scn_) + gst_[2]++ ; gst_[4]++ + ENDIF + CASE nKey == key_[2] + IF scrMovLft(scn_) + gst_[2]-- ; gst_[4]-- + ENDIF + CASE nKey == key_[3] + IF scrMovUp(scn_) + gst_[1]-- ; gst_[3]-- + ENDIF + CASE nKey == key_[4] + IF scrMovDn(scn_) + gst_[1]++ ; gst_[3]++ + ENDIF + CASE nKey == key_[5] + EXIT + ENDCASE + ENDDO + // Post Selected Block TO Moved Area + obj_:= scrTextPost(obj_,scn_,gst_,nMode) + + scrOrdObj(obj_,scn_) // Update this routine TO show exact nature + + scrMove(obj_,scn_) + scrStatus(obj_,scn_) + + scrMsg('') + ENDIF + setCursor(crs) + RETURN obj_ + +//----------------------------------------------------------------------// + +STATIC FUNCTION scrTextPost(obj_,scn_,gst_,nMode) + // Good work of statistics + LOCAL n,i,s,s1,s2,s3,n1,nWid,nCol,nn + LOCAL del_:={0},ins_:={},d_:={},ddd_ + LOCAL old_:= scn_[SCN_TEXT_BLOCK_] + + FOR i := gst_[1] TO gst_[3] + n := -1 + DO WHILE .t. + n := ascan(obj_,{|e_| e_[OBJ_ROW]==i ; + .AND. ; + (inRange(e_[OBJ_COL],gst_[2],gst_[4]); + .OR. ; + inRange(e_[OBJ_TO_COL],gst_[2],gst_[4])) ; + .AND.; + !VouchInArray(n,del_) }) + IF n > 0 + IF obj_[n,OBJ_TYPE] == OBJ_O_TEXT + aadd(del_,n) + + s1 := '' ; ; s3 := '' + s := obj_[n,OBJ_EQN] + nCol := obj_[n,OBJ_COL] + + IF gst_[2] <= obj_[n,OBJ_COL] .AND. gst_[4] >= obj_[n,OBJ_TO_COL] + // Only deletion of OBJECT + // s2 := s + ELSEIF gst_[2] >= nCol + s1 := substr(s,1,gst_[2]-nCol) + // s2 := substr(s,gst_[2]-nCol+1,gst_[4]-nCol+1) + s3 := substr(s,gst_[4]-nCol+2) + ELSEIF gst_[2] < nCol + s1 := substr(s,1,gst_[2]-nCol) + // s2 := substr(s,gst_[2]-nCol+1,gst_[4]-nCol+1) + s3 := substr(s,gst_[4]-nCol+2) + ENDIF + + IF len(s1)>0 + aadd(ins_,scrObjBlank()) + n1 := len(ins_) + ins_[n1,OBJ_TYPE] := OBJ_O_TEXT + ins_[n1,OBJ_ROW] := obj_[n,OBJ_ROW] + ins_[n1,OBJ_COL] := obj_[n,OBJ_COL] + ins_[n1,OBJ_EQN] := s1 + ins_[n1,OBJ_ID] := 'Text' + ins_[n1,OBJ_COLOR] := 'W/B' + ins_[n1,OBJ_SECTION] := obj_[n,OBJ_SECTION] + ins_[n1,OBJ_TO_ROW] := obj_[n,OBJ_ROW ] + ins_[n1,OBJ_TO_COL] := ins_[n1,OBJ_COL]+len(s1)-1 + ENDIF + + IF len(s3) > 0 + aadd(ins_,scrObjBlank()) + n1 := len(ins_) + ins_[n1,OBJ_TYPE] := OBJ_O_TEXT + ins_[n1,OBJ_ROW] := obj_[n,OBJ_ROW] + ins_[n1,OBJ_COL] := gst_[4]+1 + ins_[n1,OBJ_EQN] := s3 + ins_[n1,OBJ_ID] := 'Text' + ins_[n1,OBJ_COLOR] := 'W/B' + ins_[n1,OBJ_SECTION] := obj_[n,OBJ_SECTION] + ins_[n1,OBJ_TO_ROW] := obj_[n,OBJ_ROW ] + ins_[n1,OBJ_TO_COL] := ins_[n1,OBJ_COL]+len(s3)-1 + ENDIF + + ELSEIF obj_[n,OBJ_TYPE] == OBJ_O_FIELD .OR. ; + obj_[n,OBJ_TYPE] == OBJ_O_EXP + aadd(del_,n) + + ELSEIF obj_[n,OBJ_TYPE] == OBJ_O_BOX + + ELSEIF obj_[n,OBJ_TYPE] == OBJ_O_BMP + + ENDIF + ELSE + EXIT + ENDIF + ENDDO + NEXT + + ddd_:= del_ ; del_:={0} ; nn := 0 + + FOR i := old_[1] TO old_[3] // Rows + n := -1 + + DO WHILE .t. + n := ascan(obj_,{|e_| e_[OBJ_ROW]==i; + .AND. ; + (inRange(e_[OBJ_COL],old_[2],old_[4]); + .OR. ; + inRange(e_[OBJ_TO_COL],old_[2],old_[4])) ; + .AND. ; + !VouchInArray(n,del_) }) + IF n > 0 + IF obj_[n,OBJ_TYPE] == OBJ_O_TEXT + aadd(del_,n) + + // TO be retained as it is + s1 := '' ; s2 := '' ; s3 := '' + s := obj_[n,OBJ_EQN] + nCol := obj_[n,OBJ_COL] + + IF old_[2] <= obj_[n,OBJ_COL] .AND. old_[4] >= obj_[n,OBJ_TO_COL] + s2 := s // Insert WITH moved coordinates + ELSEIF old_[2] >= obj_[n,OBJ_COL] + s1 := substr(s,1,old_[2]-nCol) + s2 := substr(s,old_[2]-nCol+1,old_[4]-old_[2]+1) + s3 := substr(s,old_[4]-nCol+2) + ELSEIF old_[2] < nCol + s1 := substr(s,1,old_[2]-nCol) + s2 := substr(s,old_[2]-nCol+1,old_[4]-old_[2]+1) + s3 := substr(s,old_[4]-nCol+2) + ENDIF + + IF nMode == 0 + IF len(s1)>0 + aadd(ins_,scrObjBlank()) + n1 := len(ins_) + ins_[n1,OBJ_TYPE] := OBJ_O_TEXT + ins_[n1,OBJ_ROW] := obj_[n,OBJ_ROW] + ins_[n1,OBJ_COL] := obj_[n,OBJ_COL] + ins_[n1,OBJ_EQN] := s1 + ins_[n1,OBJ_ID] := 'Text' + ins_[n1,OBJ_COLOR] := 'W/B' + ins_[n1,OBJ_SECTION] := obj_[n,OBJ_SECTION] + ins_[n1,OBJ_TO_ROW] := obj_[n,OBJ_ROW ] + ins_[n1,OBJ_TO_COL] := ins_[n1,OBJ_COL]+len(s1)-1 + ENDIF + IF len(s3) > 0 + aadd(ins_,scrObjBlank()) + n1 := len(ins_) + ins_[n1,OBJ_TYPE] := OBJ_O_TEXT + ins_[n1,OBJ_ROW] := obj_[n,OBJ_ROW] + ins_[n1,OBJ_COL] := old_[4]+1 + ins_[n1,OBJ_EQN] := s3 + ins_[n1,OBJ_ID] := 'Text' + ins_[n1,OBJ_COLOR] := 'W/B' + ins_[n1,OBJ_SECTION] := obj_[n,OBJ_SECTION] + ins_[n1,OBJ_TO_ROW] := obj_[n,OBJ_ROW ] + ins_[n1,OBJ_TO_COL] := ins_[n1,OBJ_COL]+len(s3)-1 + ENDIF + ENDIF + + IF len(s2) > 0 + aadd(ins_,aclone(obj_[n])) + n1 := len(ins_) + ins_[n1,OBJ_ROW] := gst_[1]+nn + ins_[n1,OBJ_COL] := gst_[2]+IF(old_[2]-obj_[n,OBJ_COL]>=0,; + 0,abs(old_[2]-obj_[n,OBJ_COL])) + ins_[n1,OBJ_TO_ROW] := ins_[n1,OBJ_ROW] + ins_[n1,OBJ_TO_COL] := ins_[n1,OBJ_COL]+len(s2)-1 + ins_[n1,OBJ_EQN] := s2 + ENDIF + + ELSEIF obj_[n,OBJ_TYPE] == OBJ_O_FIELD .OR. ; + obj_[n,OBJ_TYPE] == OBJ_O_EXP + IF nMode == 0 + aadd(del_,n) + ENDIF + + // Same OBJECT is TO be inserted IN moved block + aadd(ins_,aclone(obj_[n])) + n1 := len(ins_) + ins_[n1,OBJ_ROW] := gst_[1]+nn + nWid := obj_[n,OBJ_TO_COL]-obj_[n,OBJ_COL] + ins_[n1,OBJ_COL] := gst_[2]+old_[2]-obj_[n,OBJ_COL] + ins_[n1,OBJ_TO_ROW] := ins_[n1,OBJ_ROW] + ins_[n1,OBJ_TO_COL] := ins_[n1,OBJ_COL]+nWid + ENDIF + ELSE + EXIT + ENDIF + ENDDO + nn++ + NEXT + + IF nMode <> 0 + del_:={} + ENDIF + aeval(ddd_,{|e| aadd(del_,e) }) + + IF !empty(del_) + FOR i := 1 TO len(obj_) + IF ascan(del_,i) == 0 + aadd(d_,obj_[i]) + ENDIF + NEXT + obj_:= aclone(d_) + IF empty(obj_) + aadd(obj_,scrObjBlank()) + ENDIF + ENDIF + + aeval(ins_,{|e_| aadd(obj_,e_) }) + + scn_[SCN_TEXT_BLOCK_] := {} + RETURN obj_ + +//----------------------------------------------------------------------// + +STATIC FUNCTION scrTextDel(obj_,scn_) + LOCAL i,n,n1,s,s1,s3,nCol,ins_:={},del_:={},d_:={},old_:={} + + old_:= scn_[SCN_TEXT_BLOCK_] + FOR i := old_[1] TO old_[3] // Rows + n := -1 + + DO WHILE .t. + n := ascan(obj_,{|e_| e_[OBJ_ROW]==i; + .AND. ; + (inRange(e_[OBJ_COL], old_[2],old_[4]); + .OR. ; + inRange(e_[OBJ_TO_COL],old_[2],old_[4])) ; + .AND. ; + !VouchInArray(n,del_) }) + IF n > 0 + IF obj_[n,OBJ_TYPE] == OBJ_O_TEXT + aadd(del_,n) + + // TO be retained as it is + s1 := '' ; s3 := '' + s := obj_[n,OBJ_EQN] + nCol := obj_[n,OBJ_COL] + + IF old_[2] <= obj_[n,OBJ_COL] .AND. old_[4] >= obj_[n,OBJ_TO_COL] + // s2 := s // Insert WITH moved coordinates + ELSEIF old_[2] >= obj_[n,OBJ_COL] + s1 := substr(s,1,old_[2]-nCol) + // s2 := substr(s,old_[2]-nCol+1,old_[4]-old_[2]+1) + s3 := substr(s,old_[4]-nCol+2) + ELSEIF old_[2] < nCol + s1 := substr(s,1,old_[2]-nCol) + // s2 := substr(s,old_[2]-nCol+1,old_[4]-old_[2]+1) + s3 := substr(s,old_[4]-nCol+2) + ENDIF + + IF len(s1)>0 + aadd(ins_,scrObjBlank()) + n1 := len(ins_) + ins_[n1,OBJ_TYPE] := OBJ_O_TEXT + ins_[n1,OBJ_ROW] := obj_[n,OBJ_ROW] + ins_[n1,OBJ_COL] := obj_[n,OBJ_COL] + ins_[n1,OBJ_EQN] := s1 + ins_[n1,OBJ_ID] := 'Text' + ins_[n1,OBJ_COLOR] := 'W/B' + ins_[n1,OBJ_SECTION] := obj_[n,OBJ_SECTION] + ins_[n1,OBJ_TO_ROW] := obj_[n,OBJ_ROW ] + ins_[n1,OBJ_TO_COL] := ins_[n1,OBJ_COL]+len(s1)-1 + ENDIF + IF len(s3) > 0 + aadd(ins_,scrObjBlank()) + n1 := len(ins_) + ins_[n1,OBJ_TYPE] := OBJ_O_TEXT + ins_[n1,OBJ_ROW] := obj_[n,OBJ_ROW] + ins_[n1,OBJ_COL] := old_[4]+1 + ins_[n1,OBJ_EQN] := s3 + ins_[n1,OBJ_ID] := 'Text' + ins_[n1,OBJ_COLOR] := 'W/B' + ins_[n1,OBJ_SECTION] := obj_[n,OBJ_SECTION] + ins_[n1,OBJ_TO_ROW] := obj_[n,OBJ_ROW ] + ins_[n1,OBJ_TO_COL] := ins_[n1,OBJ_COL]+len(s3)-1 + ENDIF + + ELSEIF obj_[n,OBJ_TYPE] == OBJ_O_FIELD .OR. ; + obj_[n,OBJ_TYPE] == OBJ_O_EXP + aadd(del_,n) + + ENDIF + ELSE + EXIT + ENDIF + ENDDO + //nn++ + NEXT + + IF !empty(del_) + FOR i := 1 TO len(obj_) + IF ascan(del_,i) == 0 + aadd(d_,obj_[i]) + ENDIF + NEXT + obj_:= aclone(d_) + IF empty(obj_) + aadd(obj_,scrObjBlank()) + ENDIF + ENDIF + + aeval(ins_,{|e_| aadd(obj_,e_) }) + scn_[SCN_TEXT_BLOCK_] := {} + + RETURN obj_ + +//----------------------------------------------------------------------// + +STATIC FUNCTION scrNewBand( obj_,scn_,nSecId ) + + HB_SYMBOL_UNUSED( obj_ ) + HB_SYMBOL_UNUSED( scn_ ) + HB_SYMBOL_UNUSED( nSecId ) + + RETURN NIL + +//----------------------------------------------------------------------// + +STATIC FUNCTION scrGroup(obj_,scn_) + + HB_SYMBOL_UNUSED( obj_ ) + HB_SYMBOL_UNUSED( scn_ ) + + RETURN NIL + +//----------------------------------------------------------------------// + +STATIC FUNCTION scrHd2Sm( nOrdH ) + RETURN SCT_ID_GRP01_S - (nOrdH - SCT_ID_GRP01_H) + +//----------------------------------------------------------------------// + +STATIC FUNCTION scrGrpEqn( eqn,scn_ ) + + HB_SYMBOL_UNUSED( eqn ) + HB_SYMBOL_UNUSED( scn_ ) + + RETURN NIL + +//----------------------------------------------------------------------// + +STATIC FUNCTION scrForRows( obj_,scn_ ) + + HB_SYMBOL_UNUSED( obj_ ) + HB_SYMBOL_UNUSED( scn_ ) + + RETURN NIL + +//----------------------------------------------------------------------// + +STATIC FUNCTION scrExport( obj_,scn_ ) + LOCAL cFile := 'SCREEN' + LOCAL rpt_ + + cFile := VouchGetSome( 'Screen Name Please', pad( cFile,100 ) ) + IF !empty( cFile ) + rpt_:= objScn2Rpt( obj_, scn_, scn_[ SCN_NMODE ] ) + //save_array( rpt_, trim( cFile ) + '.vsc' ) + uiDebug( rpt_ ) + ENDIF + + RETURN file( cFile ) + +//----------------------------------------------------------------------// + +STATIC FUNCTION scrImport( obj_,scn_ ) + LOCAL cFile := 'SCREEN' + LOCAL rpt_:={},aa_ + + cFile := VouchGetSome( 'Screen TO Import?', pad( cFile,100 ) ) + IF ! empty( cFile ) + //rpt_:= rest_array( trim( cFile ) + '.vsc' ) + ENDIF + IF !empty( rpt_ ) + aa_:= rpt2ObjScn( scn_[SCN_COBJECT], rpt_, scn_[SCN_NMODE], {},; + scn_[SCN_CRPT], scn_[SCN_NWHERE], scn_[SCN_LMSG] ) + obj_:= aa_[ 1 ] + scn_:= aa_[ 2 ] + ENDIF + + scn_[SCN_REFRESH] := OBJ_REFRESH_ALL + + RETURN NIL + +//----------------------------------------------------------------------// diff --git a/harbour/contrib/hbcuied/cu_field.prg b/harbour/contrib/hbcuied/cu_field.prg new file mode 100644 index 0000000000..4898dd3524 --- /dev/null +++ b/harbour/contrib/hbcuied/cu_field.prg @@ -0,0 +1,521 @@ +/* + * $Id$ + */ + +/* + * Harbour Project source code: + * CUI Forms Editor + * + * Copyright 2011 Pritpal Bedi + * http://harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ +/* + * EkOnkar + * ( The LORD is ONE ) + * + * Harbour CUI Editor Source + * + * Pritpal Bedi + * 13Aug2011 + */ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ + +#include "hbcuied.ch" +#include "common.ch" + +/*----------------------------------------------------------------------*/ + +#define FLD_UNIQUE 1 // N 4 + +#define FLD_ALIAS 2 // C 8 +#define FLD_HEADING 3 // C 15 +#define FLD_TYPE 4 // C 1 +#define FLD_LEN 5 // N 3 +#define FLD_DEC 6 // N 3 +#define FLD_ORD_NAT 7 // N 3 +#define FLD_FLD_NO 8 // N 3 + +#define FLD_INDEXED 9 // L 1 +#define FLD_INDEX_NO 10 // N 3 + +#define FLD_CONFIGURE 11 // L 1 +#define FLD_CALCULATED 12 // L 1 +#define FLD_TRIGGER 13 // L 1 + +#define FLD_ORD_GET 14 // N 3 +#define FLD_EDITABLE 15 // L 1 +#define FLD_DATA 16 // C 60 +#define FLD_WHEN 17 // C 100 +#define FLD_VALID 18 // C 100 + +#define FLD_ORD_BRW 19 // N 3 +#define FLD_BROWSE 20 // L 1 +#define FLD_BRW_INIT 21 // L 1 +#define FLD_BRW_VIS 22 // L 1 + +#define FLD_HELP 23 // C 8 +#define FLD_PG_TOTAL 24 // L 1 + +#define FLD_F_FLD 25 // N 3 +#define FLD_F_ALIAS 26 // C 8 +#define FLD_F_LOOK_FLD 27 // N 3 +#define FLD_F_RTN_FLD 28 // N 3 + +#define FLD_ENCRYPTED 29 // L 1 +#define FLD_ENK_BASE 30 // N 3 +#define FLD_ENK_ALOG 31 // N 3 +#define FLD_FLD_ATTR 32 // N 2 + // --- + // 352 +#define FLD_INIT_VRBLS 32 + +/*----------------------------------------------------------------------*/ + +#define FLD_LEN_UNIQUE 4 + +#define FLD_LEN_ALIAS 8 +#define FLD_LEN_HEADING 15 +#define FLD_LEN_TYPE 1 +#define FLD_LEN_LEN 3 +#define FLD_LEN_DEC 2 +#define FLD_LEN_ORD_NAT 3 +#define FLD_LEN_FLD_NO 3 + +#define FLD_LEN_INDEXED 1 +#define FLD_LEN_INDEX_NO 3 + +#define FLD_LEN_CONFIGURE 1 +#define FLD_LEN_CALCULATED 1 +#define FLD_LEN_TRIGGER 1 + +#define FLD_LEN_ORD_GET 3 +#define FLD_LEN_EDITABLE 1 +#define FLD_LEN_DATA 60 +#define FLD_LEN_WHEN 100 +#define FLD_LEN_VALID 100 + +#define FLD_LEN_ORD_BRW 3 +#define FLD_LEN_BROWSE 1 +#define FLD_LEN_BRW_INIT 1 +#define FLD_LEN_BRW_VIS 1 + +#define FLD_LEN_HELP 8 +#define FLD_LEN_PG_TOTAL 1 + +#define FLD_LEN_F_FLD 3 +#define FLD_LEN_F_ALIAS 8 +#define FLD_LEN_F_LOOK_FLD 3 +#define FLD_LEN_F_RTN_FLD 3 + +#define FLD_LEN_ENCRYPTED 1 +#define FLD_LEN_ENK_BASE 3 +#define FLD_LEN_ENK_ALOG 3 + +#define FLD_LEN_FLD_ATTR 2 + +/*----------------------------------------------------------------------*/ + +#define FLD_OS_UNIQUE 1 // 4 + +#define FLD_OS_ALIAS 5 // 8 +#define FLD_OS_HEADING 13 // 15 +#define FLD_OS_TYPE 28 // 1 +#define FLD_OS_LEN 29 // 3 +#define FLD_OS_DEC 32 // 2 +#define FLD_OS_ORD_NAT 34 // 3 +#define FLD_OS_FLD_NO 37 // 3 + +#define FLD_OS_INDEXED 40 // 1 +#define FLD_OS_INDEX_NO 41 // 3 + +#define FLD_OS_CONFIGURE 44 // 1 +#define FLD_OS_CALCULATED 45 // 1 +#define FLD_OS_TRIGGER 46 // 1 + +#define FLD_OS_ORD_GET 47 // 3 +#define FLD_OS_EDITABLE 50 // 1 +#define FLD_OS_DATA 51 // 60 +#define FLD_OS_WHEN 111 //-----100 +#define FLD_OS_VALID 211 //-----100 + +#define FLD_OS_ORD_BRW 311 // 3 +#define FLD_OS_BROWSE 314 // 1 +#define FLD_OS_BRW_INIT 315 // 1 +#define FLD_OS_BRW_VIS 316 // 1 + +#define FLD_OS_HELP 317 // 8 +#define FLD_OS_PG_TOTAL 325 // 1 + +#define FLD_OS_F_FLD 326 // 3 +#define FLD_OS_F_ALIAS 329 // 8 +#define FLD_OS_F_LOOK_FLD 337 // 3 +#define FLD_OS_F_RTN_FLD 340 // 3 + +#define FLD_OS_ENCRYPTED 343 // 1 +#define FLD_OS_ENK_BASE 344 // 3 +#define FLD_OS_ENK_ALOG 347 // 3 +#define FLD_OS_FLD_ATTR 350 // 2 + + +//----------------------------------------------------------------------// + +#define PRM_TYPE 1 // C 1 +#define PRM_ALIAS 2 // C 8 +#define PRM_DESC 3 // C 35 +#define PRM_FILE_1 4 // C 8 +#define PRM_FILE_2 5 // C 8 +#define PRM_FILE_3 6 // C 8 +#define PRM_PK 7 // N 3 +#define PRM_DK 8 // N 3 +#define PRM_PROTO 9 // N 2 +#define PRM_PATH 10 // C 80 +#define PRM_DELETE 11 // C 80 +#define PRM_PREVALIDATE 12 // C 80 +#define PRM_INITIALIZE 13 // C 80 +#define PRM_ATTACHED 14 // L 1 +#define PRM_MODE 15 // C 1 +#define PRM_SHORT 16 // C 3 + +#define PRM_INIT_VRBLS 16 + +//----------------------------------------------------------------------// + +#define PRM_LEN_TYPE 1 +#define PRM_LEN_ALIAS 8 // C 8 +#define PRM_LEN_DESC 35 // C 35 +#define PRM_LEN_FILE_1 8 // C 8 +#define PRM_LEN_FILE_2 8 // C 8 +#define PRM_LEN_FILE_3 8 // C 8 +#define PRM_LEN_PK 3 // N 3 +#define PRM_LEN_DK 3 // N 3 +#define PRM_LEN_PROTO 2 // N 2 +#define PRM_LEN_PATH 80 // C 80 +#define PRM_LEN_DELETE 80 // C 80 +#define PRM_LEN_PREVALIDATE 80 // C 80 +#define PRM_LEN_INITIALIZE 80 // C 80 +#define PRM_LEN_ATTACHED 1 // L 1 +#define PRM_LEN_MODE 1 // C 1 +#define PRM_LEN_SHORT 3 // C 3 + +//----------------------------------------------------------------------// + +#define PRM_OS_TYPE 1 // C 1 +#define PRM_OS_ALIAS 2 // C 8 +#define PRM_OS_DESC 10 // C 35 +#define PRM_OS_FILE_1 45 // C 8 +#define PRM_OS_FILE_2 53 // C 8 +#define PRM_OS_FILE_3 61 // C 8 +#define PRM_OS_PK 69 // N 3 +#define PRM_OS_DK 72 // N 3 +#define PRM_OS_PROTO 75 // N 2 +#define PRM_OS_PATH 77 // C 80 +#define PRM_OS_DELETE 157 // C 80 +#define PRM_OS_PREVALIDATE 237 // C 80 +#define PRM_OS_INITIALIZE 317 // C 80 +#define PRM_OS_ATTACHED 397 // L 1 +#define PRM_OS_MODE 398 // C 1 +#define PRM_OS_SHORT 399 // C 3 + +//----------------------------------------------------------------------// + +#define FATR_CHR 1 +#define FATR_DTE 2 +#define FATR_NUM 3 +#define FATR_LOG 4 +#define FATR_PKS 5 +#define FATR_PKM 6 +#define FATR_DTF 7 +#define FATR_FRN 8 +#define FATR_INF 9 +#define FATR_SUM 10 +#define FATR_TRG 11 +#define FATR_REF 12 +#define FATR_OPN 13 + +//----------------------------------------------------------------------// + +FUNCTION scrMdlFld( obj_, scn_, nObj ) + LOCAL v_, n, sel_ + + sel_:= scrVvSelAble( scn_ ) + v_ := IF( nObj > 0, scrObj2Vv( obj_[ nObj ] ), scrVvBlank() ) + n := v_[ VV_FIELD ] + IF nObj == 0 + v_[ VV_FIELD ] := 0 + v_[ VV_ID ] := space( 10 ) + v_[ VV_F_PIC ] := space( 15 ) + v_[ VV_COLOR ] := 'N/W ' + ENDIF + + IF .T. + v_[ VV_EQN ] := 'fieldget('+ ltrim( str( n ) ) + ')' + + sel_[ VV_ALIGN ] := .f. + sel_[ VV_PRN_LEN ] := .f. +// sel_[ VV_ID ] := .f. + sel_[ VV_PRN_LEN ] := .f. + sel_[ VV_ALIGN ] := .f. + sel_[ VV_COLOR ] := .f. + sel_[ VV_POINT ] := .f. + sel_[ VV_COL_JUST ] := .f. + sel_[ VV_PATTERN ] := .f. + sel_[ VV_F_TYPE ] := .T. + + scrField( nObj, 1, obj_, scn_, v_, sel_, OBJ_CLR_FIELD ) + IF nObj > 0 + scrOrdObj( obj_ ) + ENDIF + ENDIF + RETURN NIL + +//----------------------------------------------------------------------// + +STATIC FUNCTION scrFldUnique(obj_) + LOCAL nUnq := 2001 + DO WHILE .t. + IF ascan(obj_,{|e_| e_[OBJ_OBJ_UNIQUE] == nUnq }) == 0 + EXIT + ENDIF + nUnq++ + ENDDO + RETURN nUnq + +//----------------------------------------------------------------------// +#IF 0 +STATIC FUNCTION prpObj2Fld( obj_ ) // Akin TO Blank + + LOCAL v_:= array( FLD_INIT_VRBLS ) + LOCAL idx_:={ .f.,.f.,.f.,.f.,.t.,.t.,.t.,.t.,.f.,.f.,.f.,.f.,.f. } + LOCAL nAttr := obj_[ OBJ_MDL_F_TYPE ] + + v_[FLD_UNIQUE ] := obj_[OBJ_OBJ_UNIQUE] + v_[FLD_ALIAS ] := space(8) + v_[FLD_HEADING ] := obj_[OBJ_ID] + v_[FLD_TYPE ] := obj_[OBJ_F_TYPE] + v_[FLD_LEN ] := obj_[OBJ_F_LEN] + v_[FLD_DEC ] := obj_[OBJ_F_DEC] + v_[FLD_ORD_NAT ] := 0 + v_[FLD_FLD_NO ] := 0 + v_[FLD_INDEXED ] := idx_[nAttr] + v_[FLD_INDEX_NO ] := 0 + v_[FLD_CONFIGURE ] := VouchInArray(nAttr,{FATR_NUM,FATR_LOG,FATR_CHR,; + FATR_DTE,FATR_REF,FATR_TRG,FATR_INF}) + v_[FLD_CALCULATED ] := VouchInArray(nAttr,{FATR_NUM,FATR_LOG,FATR_CHR,; + FATR_DTE,FATR_INF}) + v_[FLD_TRIGGER ] := nAttr == FATR_TRG .OR. nAttr == FATR_REF + v_[FLD_ORD_GET ] := 0 + v_[FLD_EDITABLE ] := !VouchInArray(nAttr,{FATR_PKS,FATR_PKM}) + v_[FLD_DATA ] := space(FLD_LEN_DATA) + v_[FLD_WHEN ] := space(FLD_LEN_WHEN) + v_[FLD_VALID ] := space(FLD_LEN_VALID) + v_[FLD_ORD_BRW ] := 0 + v_[FLD_BROWSE ] := nAttr <> FATR_TRG .OR. nAttr <> FATR_REF + v_[FLD_BRW_INIT ] := nAttr <> FATR_TRG .OR. nAttr <> FATR_REF + v_[FLD_BRW_VIS ] := nAttr <> FATR_TRG .OR. nAttr <> FATR_REF + v_[FLD_HELP ] := space(8) + v_[FLD_PG_TOTAL ] := obj_[OBJ_F_TYPE]=='N' + v_[FLD_F_FLD ] := 0 + v_[FLD_F_ALIAS ] := space(8) + v_[FLD_F_LOOK_FLD ] := 0 + v_[FLD_F_RTN_FLD ] := 0 + v_[FLD_ENCRYPTED ] := .t. + v_[FLD_ENK_BASE ] := b_rand(254) + v_[FLD_ENK_ALOG ] := b_rand(19) + v_[FLD_FLD_ATTR ] := nAttr + RETURN v_ +#ENDIF +//----------------------------------------------------------------------// + +FUNCTION prpFld2Str(v_) + LOCAL s := ; + str(v_[FLD_UNIQUE ], FLD_LEN_UNIQUE )+ ; + pad(v_[FLD_ALIAS ], FLD_LEN_ALIAS )+ ; + pad(v_[FLD_HEADING ], FLD_LEN_HEADING )+ ; + pad(v_[FLD_TYPE ], FLD_LEN_TYPE )+ ; + str(v_[FLD_LEN ], FLD_LEN_LEN )+ ; + str(v_[FLD_DEC ], FLD_LEN_DEC )+ ; + str(v_[FLD_ORD_NAT ], FLD_LEN_ORD_NAT )+ ; + str(v_[FLD_FLD_NO ], FLD_LEN_FLD_NO )+ ; + IF(v_[FLD_INDEXED ], 'T', 'F' )+ ; + str(v_[FLD_INDEX_NO ], FLD_LEN_INDEX_NO )+ ; + IF(v_[FLD_CONFIGURE ], 'T', 'F' )+ ; + IF(v_[FLD_CALCULATED ], 'T', 'F' )+ ; + IF(v_[FLD_TRIGGER ], 'T', 'F' )+ ; + str(v_[FLD_ORD_GET ], FLD_LEN_ORD_GET )+ ; + IF(v_[FLD_EDITABLE ], 'T', 'F' )+ ; + pad(v_[FLD_DATA ], FLD_LEN_DATA )+ ; + pad(v_[FLD_WHEN ], FLD_LEN_WHEN )+ ; + pad(v_[FLD_VALID ], FLD_LEN_VALID )+ ; + str(v_[FLD_ORD_BRW ], FLD_LEN_ORD_BRW )+ ; + IF(v_[FLD_BROWSE ], 'T', 'F' )+ ; + IF(v_[FLD_BRW_INIT ], 'T', 'F' )+ ; + IF(v_[FLD_BRW_VIS ], 'T', 'F' )+ ; + pad(v_[FLD_HELP ], FLD_LEN_HELP )+ ; + IF(v_[FLD_PG_TOTAL ], 'T', 'F' )+ ; + str(v_[FLD_F_FLD ], FLD_LEN_F_FLD )+ ; + pad(v_[FLD_F_ALIAS ], FLD_LEN_F_ALIAS )+ ; + str(v_[FLD_F_LOOK_FLD ], FLD_LEN_F_LOOK_FLD )+ ; + str(v_[FLD_F_RTN_FLD ], FLD_LEN_F_RTN_FLD )+ ; + IF(v_[FLD_ENCRYPTED ], 'T', 'F' )+ ; + str(v_[FLD_ENK_BASE ], FLD_LEN_ENK_BASE )+ ; + str(v_[FLD_ENK_ALOG ], FLD_LEN_ENK_ALOG )+ ; + str(v_[FLD_FLD_ATTR ], FLD_LEN_FLD_ATTR ) + RETURN s + +//----------------------------------------------------------------------// + +FUNCTION prpStr2Fld(s) + LOCAL v_:= array(FLD_INIT_VRBLS) + + v_[FLD_UNIQUE ] := val(substr(s, FLD_OS_UNIQUE , FLD_LEN_UNIQUE )) + v_[FLD_ALIAS ] := substr(s, FLD_OS_ALIAS , FLD_LEN_ALIAS ) + v_[FLD_HEADING ] := substr(s, FLD_OS_HEADING , FLD_LEN_HEADING ) + v_[FLD_TYPE ] := substr(s, FLD_OS_TYPE , FLD_LEN_TYPE ) + v_[FLD_LEN ] := val(substr(s, FLD_OS_LEN , FLD_LEN_LEN )) + v_[FLD_DEC ] := val(substr(s, FLD_OS_DEC , FLD_LEN_DEC )) + v_[FLD_ORD_NAT ] := val(substr(s, FLD_OS_ORD_NAT , FLD_LEN_ORD_NAT )) + v_[FLD_FLD_NO ] := val(substr(s, FLD_OS_FLD_NO , FLD_LEN_FLD_NO )) + v_[FLD_INDEXED ] := substr(s, FLD_OS_INDEXED , FLD_LEN_INDEXED )=='T' + v_[FLD_INDEX_NO ] := val(substr(s, FLD_OS_INDEX_NO , FLD_LEN_INDEX_NO )) + v_[FLD_CONFIGURE ] := substr(s, FLD_OS_CONFIGURE , FLD_LEN_CONFIGURE )=='T' + v_[FLD_CALCULATED ] := substr(s, FLD_OS_CALCULATED , FLD_LEN_CALCULATED)=='T' + v_[FLD_TRIGGER ] := substr(s, FLD_OS_TRIGGER , FLD_LEN_TRIGGER )=='T' + v_[FLD_ORD_GET ] := val(substr(s, FLD_OS_ORD_GET , FLD_LEN_ORD_GET )) + v_[FLD_EDITABLE ] := substr(s, FLD_OS_EDITABLE , FLD_LEN_EDITABLE )=='T' + v_[FLD_DATA ] := substr(s, FLD_OS_DATA , FLD_LEN_DATA ) + v_[FLD_WHEN ] := substr(s, FLD_OS_WHEN , FLD_LEN_WHEN ) + v_[FLD_VALID ] := substr(s, FLD_OS_VALID , FLD_LEN_VALID ) + v_[FLD_ORD_BRW ] := val(substr(s, FLD_OS_ORD_BRW , FLD_LEN_ORD_BRW )) + v_[FLD_BROWSE ] := substr(s, FLD_OS_BROWSE , FLD_LEN_BROWSE )=='T' + v_[FLD_BRW_INIT ] := substr(s, FLD_OS_BRW_INIT , FLD_LEN_BRW_INIT )=='T' + v_[FLD_BRW_VIS ] := substr(s, FLD_OS_BRW_VIS , FLD_LEN_BRW_VIS )=='T' + v_[FLD_HELP ] := substr(s, FLD_OS_HELP , FLD_LEN_HELP ) + v_[FLD_PG_TOTAL ] := substr(s, FLD_OS_PG_TOTAL , FLD_LEN_PG_TOTAL )=='T' + v_[FLD_F_FLD ] := val(substr(s, FLD_OS_F_FLD , FLD_LEN_F_FLD )) + v_[FLD_F_ALIAS ] := substr(s, FLD_OS_F_ALIAS , FLD_LEN_F_ALIAS ) + v_[FLD_F_LOOK_FLD ] := val(substr(s, FLD_OS_F_LOOK_FLD , FLD_LEN_F_LOOK_FLD)) + v_[FLD_F_RTN_FLD ] := val(substr(s, FLD_OS_F_RTN_FLD , FLD_LEN_F_RTN_FLD )) + v_[FLD_ENCRYPTED ] := substr(s, FLD_OS_ENCRYPTED , FLD_LEN_ENCRYPTED )=='T' + v_[FLD_ENK_BASE ] := val(substr(s, FLD_OS_ENK_BASE , FLD_LEN_ENK_BASE )) + v_[FLD_ENK_ALOG ] := val(substr(s, FLD_OS_ENK_ALOG , FLD_LEN_ENK_ALOG )) + v_[FLD_FLD_ATTR ] := val(substr(s, FLD_OS_FLD_ATTR , FLD_LEN_FLD_ATTR )) + + RETURN v_ + +//----------------------------------------------------------------------// + +FUNCTION prpMdlBlank() + LOCAL v_:= array(PRM_INIT_VRBLS) + + v_[PRM_TYPE ] := 'S' + v_[PRM_ALIAS ] := 'Z7_NEW ' + v_[PRM_DESC ] := 'The NEXT Module ' + v_[PRM_FILE_1 ] := 'Z7A00001' + v_[PRM_FILE_2 ] := 'Z7B00002' + v_[PRM_FILE_3 ] := 'Z7_NEW ' + v_[PRM_PK ] := 1 + v_[PRM_DK ] := 2 + v_[PRM_PROTO ] := 0 + v_[PRM_PATH ] := space(PRM_LEN_PATH) + v_[PRM_DELETE ] := space(PRM_LEN_DELETE) + v_[PRM_PREVALIDATE] := space(PRM_LEN_PREVALIDATE) + v_[PRM_INITIALIZE ] := space(PRM_LEN_INITIALIZE) + v_[PRM_ATTACHED ] := .f. + v_[PRM_MODE ] := 'V' + v_[PRM_SHORT ] := 'XXX' + + RETURN v_ + +//----------------------------------------------------------------------// + +FUNCTION prpMdl2Str(v_) + LOCAL s := ; + pad(v_[PRM_TYPE ], PRM_LEN_TYPE ) +; + pad(v_[PRM_ALIAS ], PRM_LEN_ALIAS ) +; + pad(v_[PRM_DESC ], PRM_LEN_DESC ) +; + pad(v_[PRM_FILE_1 ], PRM_LEN_FILE_1 ) +; + pad(v_[PRM_FILE_2 ], PRM_LEN_FILE_2 ) +; + pad(v_[PRM_FILE_3 ], PRM_LEN_FILE_3 ) +; + str(v_[PRM_PK ], PRM_LEN_PK ) +; + str(v_[PRM_DK ], PRM_LEN_DK ) +; + str(v_[PRM_PROTO ], PRM_LEN_PROTO ) +; + pad(v_[PRM_PATH ], PRM_LEN_PATH ) +; + pad(v_[PRM_DELETE ], PRM_LEN_DELETE ) +; + pad(v_[PRM_PREVALIDATE], PRM_LEN_PREVALIDATE) +; + pad(v_[PRM_INITIALIZE ], PRM_LEN_INITIALIZE ) +; + IF(v_[PRM_ATTACHED ],'T','F') +; + pad(v_[PRM_MODE ], PRM_LEN_MODE ) +; + pad(v_[PRM_SHORT ], PRM_LEN_SHORT ) + RETURN s + +//----------------------------------------------------------------------// + +FUNCTION prpStr2Mdl(s) + LOCAL v_:= array(PRM_INIT_VRBLS) + + v_[PRM_TYPE ] := substr(s, PRM_OS_TYPE , PRM_LEN_TYPE ) + v_[PRM_ALIAS ] := substr(s, PRM_OS_ALIAS , PRM_LEN_ALIAS ) + v_[PRM_DESC ] := substr(s, PRM_OS_DESC , PRM_LEN_DESC ) + v_[PRM_FILE_1 ] := substr(s, PRM_OS_FILE_1 , PRM_LEN_FILE_1 ) + v_[PRM_FILE_2 ] := substr(s, PRM_OS_FILE_2 , PRM_LEN_FILE_2 ) + v_[PRM_FILE_3 ] := substr(s, PRM_OS_FILE_3 , PRM_LEN_FILE_3 ) + v_[PRM_PK ] := val(substr(s, PRM_OS_PK , PRM_LEN_PK )) + v_[PRM_DK ] := val(substr(s, PRM_OS_DK , PRM_LEN_DK )) + v_[PRM_PROTO ] := val(substr(s, PRM_OS_PROTO , PRM_LEN_PROTO )) + v_[PRM_PATH ] := substr(s, PRM_OS_PATH , PRM_LEN_PATH ) + v_[PRM_DELETE ] := substr(s, PRM_OS_DELETE , PRM_LEN_DELETE ) + v_[PRM_PREVALIDATE] := substr(s, PRM_OS_PREVALIDATE, PRM_LEN_PREVALIDATE) + v_[PRM_INITIALIZE ] := substr(s, PRM_OS_INITIALIZE , PRM_LEN_INITIALIZE ) + v_[PRM_ATTACHED ] := substr(s, PRM_OS_ATTACHED , PRM_LEN_ATTACHED ) == 'T' + v_[PRM_MODE ] := substr(s, PRM_OS_MODE , PRM_LEN_MODE ) + v_[PRM_SHORT ] := substr(s, PRM_OS_SHORT , PRM_LEN_SHORT ) + + RETURN v_ + +//----------------------------------------------------------------------// + diff --git a/harbour/contrib/hbcuied/cu_main.prg b/harbour/contrib/hbcuied/cu_main.prg new file mode 100644 index 0000000000..de6c765af2 --- /dev/null +++ b/harbour/contrib/hbcuied/cu_main.prg @@ -0,0 +1,104 @@ +/* + * $Id$ + */ + +/* + * Harbour Project source code: + * CUI Forms Editor + * + * Copyright 2011 Pritpal Bedi + * http://harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ +/* + * EkOnkar + * ( The LORD is ONE ) + * + * Harbour CUI Editor Source + * + * Pritpal Bedi + * 13Aug2011 + */ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ + +#include "hbgtinfo.ch" + +/*----------------------------------------------------------------------*/ + +FUNCTION Main( cSource, cScreen ) + + SET SCOREBOARD OFF + SET EPOCH TO 1950 + + Wvt_SetGui( .f. ) + Wvt_SetFont( "Courier New", 18, 0, 0 ) + Wvt_SetMouseMove( .t. ) + + SetColor( "N/W" ) + CLS + ? "Press ESC TO EXIT ... " + + hb_gtInfo( HB_GTI_WINTITLE, "Harbour CUI Forms Designer v1.0" ) + + hb_threadStart( {|| thd_dgn_Screen( cSource, cScreen ) } ) + + DO WHILE inkey() != 27 + + ENDDO + + RETURN cSource + +/*----------------------------------------------------------------------*/ + +FUNCTION HB_GTSYS() + + REQUEST HB_GT_WVG_DEFAULT + + RETURN NIL + +/*----------------------------------------------------------------------*/ + diff --git a/harbour/contrib/hbcuied/cu_menu.prg b/harbour/contrib/hbcuied/cu_menu.prg new file mode 100644 index 0000000000..2abb9850d5 --- /dev/null +++ b/harbour/contrib/hbcuied/cu_menu.prg @@ -0,0 +1,237 @@ +/* + * $Id$ + */ + +/* + * Harbour Project source code: + * CUI Forms Editor + * + * Copyright 2011 Pritpal Bedi + * http://harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ +/* + * EkOnkar + * ( The LORD is ONE ) + * + * Harbour CUI Editor Source + * + * Pritpal Bedi + * 13Aug2011 + */ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ + +#include "hbcuied.ch" +#include "common.ch" +#include "hbgtinfo.ch" + +//----------------------------------------------------------------------// + +#define REP_MSG_WAIT_YES .T. +#define REP_MSG_WAIT_NO .F. + +//----------------------------------------------------------------------// + +FUNCTION thd_dgn_Screen( cSource ) + LOCAL rpt_, oCrt + + DEFAULT cSource TO "Untitled" + + SetMTModule( .t. ) + + oCrt := WvgCrt():New( , , { -1,-1 }, { 24,79 }, , .f. ) + oCrt:resizeMode := HB_GTI_RESIZEMODE_ROWS + oCrt:icon := "..\..\package\harb_win.ico" + oCrt:create() + oCrt:closable := .f. + oCrt:showWindow() + + hb_gtInfo( HB_GTI_WINTITLE, 'Harbour Screen Designer - ' + cSource ) + SetColor( 'N/W' ) + CLS + SetOCrt( oCrt ) + + rpt_:= dgn_Screen( cSource, REP_FOR_MDL ) + + oCrt:destroy() + + RETURN rpt_ + +/*----------------------------------------------------------------------*/ + +STATIC FUNCTION dgn_Screen( cObject, nMode ) + LOCAL rpt_:={} + LOCAL bErr + + bErr := errorBlock( {|| Break() } ) + + IF ! empty( rpt_:= rptDefine( cObject, rpt_, nMode,/*struct_*/, /*cRpt*/, 1, REP_MSG_WAIT_YES ) ) + rptSave( cObject, /*cRpt*/, rpt_, 1, nMode, REP_MSG_WAIT_YES ) + ENDIF + + errorBlock( bErr ) + + RETURN rpt_ + +//---------------------------------------------------------------------// + +STATIC FUNCTION rptDefine( cObject,rpt_,nMode,struct_,cRpt,nWhere,lMsg ) + LOCAL scn_,a_,obj_ + + a_ := rpt2ObjScn( cObject,rpt_,nMode,struct_,cRpt,nWhere,lMsg ) + obj_:= a_[ 1 ] + scn_:= a_[ 2 ] + + a_ := Operate(obj_,scn_) // Common TO All Modes + + obj_:= a_[ 1 ] + scn_:= a_[ 2 ] + rpt_:= objScn2rpt( obj_,scn_,nMode ) + + RETURN rpt_ + +//----------------------------------------------------------------------// + +FUNCTION rptSave( /* cObject,cRpt,rRpt_,nWhere,nMode,lMsgWait */ ) + RETURN .t. + +//---------------------------------------------------------------------// + +STATIC FUNCTION rptInit() + RETURN { { '',0,'' } } + +//---------------------------------------------------------------------// + +STATIC FUNCTION s2sct(s) + LOCAL sct_:= array( SCT_INIT_VRBLS ) + + sct_[SCT_ORDER] := val(substr(s,SCT_OS_ORDER,SCT_LEN_ORDER)) + sct_[SCT_ID ] := substr(s,SCT_OS_ID ,SCT_LEN_ID ) + sct_[SCT_SAY ] := substr(s,SCT_OS_SAY ,SCT_LEN_SAY ) + sct_[SCT_ROWS ] := val(substr(s,SCT_OS_ROWS ,SCT_LEN_ROWS )) + sct_[SCT_COLOR] := substr(s,SCT_OS_COLOR,SCT_LEN_COLOR) + sct_[SCT_EQN ] := substr(s,SCT_OS_EQN ,SCT_LEN_EQN ) + sct_[SCT_EJECT] := substr(s,SCT_OS_EJECT,SCT_LEN_EJECT) == 'T' + sct_[SCT_RESET] := substr(s,SCT_OS_RESET,SCT_LEN_RESET) == 'T' + + RETURN sct_ + +//---------------------------------------------------------------------// + +STATIC FUNCTION sct2s(sct_) + LOCAL s := ; + str(sct_[SCT_ORDER],SCT_LEN_ORDER) + ; + pad(sct_[SCT_ID ],SCT_LEN_ID ) + ; + pad(sct_[SCT_SAY ],SCT_LEN_SAY ) + ; + str(sct_[SCT_ROWS ],SCT_LEN_ROWS ) + ; + pad(sct_[SCT_COLOR],SCT_LEN_COLOR) + ; + pad(sct_[SCT_EQN ],SCT_LEN_EQN ) + ; + IF(sct_[SCT_EJECT],'T','F' ) + ; + IF(sct_[SCT_RESET],'T','F' ) + RETURN s + +//---------------------------------------------------------------------// + +FUNCTION rpt2ObjScn( cObject,rpt_,nMode,struct_,cRpt,nWhere,lMsg ) + LOCAL obj_,scn_:={} + LOCAL i, n + + HB_SYMBOL_UNUSED( struct_ ) + + rpt_:= IF(rpt_ == NIL .OR. empty(rpt_), rptInit(), rpt_) + obj_:= scrScn2obj(rpt_,0) + + DO CASE + + CASE nMode == REP_FOR_MDL + scn_:= scrConfig(obj_,DGN_MODULE) + IF (n := ascan(rpt_,{|e_| e_[2]==1 })) > 0 + scn_[SCN_PROPERTY] := eval(COMPILE(rpt_[n,3])) + ENDIF + IF (n := ascan(rpt_,{|e_| e_[2]== 51 })) > 0 // Property + scn_[SCN_PROPERTY] := prpStr2Mdl(rpt_[n,3]) + ENDIF + FOR i := 1 TO len(rpt_) // Fields + IF inRange(rpt_[i,2],2001,3000) + aadd(scn_[SCN_FIELDS], prpStr2Fld(rpt_[i,3])) + ENDIF + NEXT + + ENDCASE + + scn_[SCN_FILE ] := iif( empty( rpt_[ 1,1 ] ), 'Untitled', substr( rpt_[ 1,1 ], 13 ) ) + + scn_[SCN_COBJECT ] := cObject // FOR threaded usage + scn_[SCN_CRPT ] := cRpt + scn_[SCN_NWHERE ] := nWhere + scn_[SCN_NMODE ] := nMode + scn_[SCN_LMSG ] := lMsg + + RETURN {obj_,scn_} + +//----------------------------------------------------------------------// + +FUNCTION objScn2Rpt(obj_,scn_,nMode) + LOCAL rpt_:={}, i //, s + + DO CASE + CASE nMode == REP_FOR_MDL + aeval(obj_,{|e_| IF(e_[OBJ_ROW]==0,'',aadd(rpt_,{'',0,scrObj2str(e_)} )) }) + IF !empty(scn_[SCN_PROPERTY]) + aadd(rpt_, {'',51,prpMdl2Str(scn_[SCN_PROPERTY]) }) + ENDIF + IF !empty(scn_[SCN_FIELDS]) + FOR i := 1 TO len(scn_[SCN_FIELDS]) + aadd(rpt_,{'',scn_[SCN_FIELDS,i,1], prpFld2Str(scn_[SCN_FIELDS,i]) }) + NEXT + ENDIF + ENDCASE + + RETURN rpt_ + +//----------------------------------------------------------------------// + diff --git a/harbour/contrib/hbcuied/cu_outpt.prg b/harbour/contrib/hbcuied/cu_outpt.prg new file mode 100644 index 0000000000..3132138336 --- /dev/null +++ b/harbour/contrib/hbcuied/cu_outpt.prg @@ -0,0 +1,520 @@ +/* + * $Id$ + */ + +/* + * Harbour Project source code: + * CUI Forms Editor + * + * Copyright 2011 Pritpal Bedi + * http://harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ +/* + * EkOnkar + * ( The LORD is ONE ) + * + * Harbour CUI Editor Source + * + * Pritpal Bedi + * 13Aug2011 + */ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ + +#include "hbcuied.ch" +#include "inkey.ch" +#include "wvtwin.ch" + +/*----------------------------------------------------------------------*/ + +#define K_WVT_FULLSCREEN 299701 + +#define K_WVT_BITMAP 299705 +#define K_WVT_FRAME 299706 +#define K_WVT_ELLIPSE 299707 +#define K_WVT_LINE_H 299708 +#define K_WVT_LINE_V 299709 +#define K_WVT_GRID 299710 +#define K_WVT_BARCODE 299711 +#define K_WVT_TEXTBOX 299712 + +#define K_WVT_CARRY 299721 +#define K_WVT_BROUGHT 299722 +#define K_WVT_SUMMARY 299723 +#define K_WVT_GROUP 299724 +#define K_WVT_MATRIX 299725 + +//----------------------------------------------------------------------// + +FUNCTION ScrDisplay( scn_ ) + + dispbegin() + setcursor(0) + setColor( scn_[ SCN_CLR_OVERALL ] ) + cls + + @ scn_[SCN_ROW_RULER], scn_[SCN_LEFT] ; + SAY substr( scn_[SCN_RULER], 1, scn_[SCN_RIGHT] - scn_[SCN_LEFT] + 1 ) ; + COLOR scn_[ SCN_CLR_RULER ] + + scrMsg() + + setcolor( scn_[ SCN_CLR_WINDOW ] ) + setCursor(2) + dispend() + + RETURN NIL + +//----------------------------------------------------------------------// + +FUNCTION scrStatus(obj_,scn_) + LOCAL s,objId,nSct,cClr:='GR+/BG' + LOCAL typ_ + + dispbegin() + s := pad(scn_[SCN_DESIGN_ID],8)+' ³ ' + + s += pad(scn_[SCN_FILE],12)+; + ' ³ '+; + ' Row:'+; + str( scn_[SCN_ROW_REP]-1, 3 )+; + ' Col:'+; + str( scn_[SCN_COL_REP]-1, 3 )+; + ' ³ ' +; + IF(readInsert(),'Ins ',' ')+; + ' ³ ' + + objId := '' + IF scn_[SCN_OBJ_HILITE] > 0 + objId := scn_[SCN_OBJ_ID_,obj_[scn_[SCN_OBJ_HILITE],OBJ_TYPE]] + IF obj_[scn_[SCN_OBJ_HILITE],OBJ_TYPE] == OBJ_O_BOX + typ_:= {'Bitmap','Frame','Ellipse','Line (H)','Line (V)','Grid','BarCode','Text Box'} + objId := typ_[obj_[scn_[SCN_OBJ_HILITE],OBJ_MDL_F_TYPE]-60] + ENDIF + ELSEIF scn_[SCN_OBJ_SELECTED] > 0 + objId := scn_[SCN_OBJ_ID_,obj_[scn_[SCN_OBJ_SELECTED],OBJ_TYPE]] + IF obj_[scn_[SCN_OBJ_SELECTED],OBJ_TYPE] == OBJ_O_BOX + typ_:= {'Bitmap','Frame','Ellipse','Line (H)','Line (V)','Grid','BarCode','Text Box'} + objId := typ_[obj_[scn_[SCN_OBJ_SELECTED],OBJ_MDL_F_TYPE]-60] + ENDIF + ENDIF + + s += pad(trim(objId),10)+' ³ ' + + IF ( nSct := scrSecOrd(scn_,scn_[SCN_ROW_REP])) <> NIL + s += scn_[ SCN_SECTORS_,nSct,SCT_ID ] + #ifdef __WVT__ + cClr := scn_[ SCN_SECTORS_,nSct,SCT_COLOR ] + #ENDIF + ENDIF + + @ scn_[SCN_STATUS_ROW], scn_[SCN_STATUS_COL] ; + say pad(s,scn_[SCN_STATUS_COL_TO]-scn_[SCN_STATUS_COL]+1) ; + color scn_[SCN_CLR_STATUS] + + /* Ruler */ + s := substr(scn_[SCN_RULER],; + max( 1,scn_[SCN_COL_REP]-scn_[SCN_COL_CUR]+scn_[SCN_LEFT]),; + scn_[ SCN_RIGHT]-scn_[SCN_LEFT]+1 ) + DispBox( scn_[SCN_TOP]-1,0,scn_[SCN_TOP]-1,maxcol(),' ',scn_[SCN_CLR_OVERALL] ) + @ scn_[SCN_ROW_RULER],scn_[SCN_LEFT] SAY s COLOR scn_[SCN_CLR_RULER] + @ scn_[SCN_ROW_RULER],scn_[SCN_COL_CUR] say ; + substr( s, scn_[SCN_COL_CUR]-scn_[SCN_LEFT]+1,1) COLOR cClr + + @ scn_[SCN_ROW_CUR],scn_[SCN_COL_CUR] SAY '' + + // Now update current cursor position + scn_[SCN_ROW_PREV] := scn_[SCN_ROW_CUR] + scn_[SCN_COL_PREV] := scn_[SCN_COL_CUR] + + dispend() + RETURN NIL + +//----------------------------------------------------------------------// + +FUNCTION scrHiLite(obj_,scn_,mode) + LOCAL nObj := scn_[SCN_OBJ_HILITE] + LOCAL cColor := IF(mode,scn_[SCN_CLR_HILITE],obj_[nObj,OBJ_COLOR]) + + IF obj_[nObj,OBJ_TYPE] == OBJ_O_BOX + DispBegin() + dispBox( obj_[nObj,OBJ_ROW] + scn_[SCN_ROW_DIS],; + obj_[nObj,OBJ_COL] + scn_[SCN_COL_DIS],; + obj_[nObj,OBJ_TO_ROW] + scn_[SCN_ROW_DIS],; + obj_[nObj,OBJ_TO_COL] + scn_[SCN_COL_DIS],; + obj_[nObj,OBJ_BOX_SHAPE],; + 'gr+/b' /* cColor */) + DispEnd() + ELSEIF obj_[nObj,OBJ_TYPE] == OBJ_O_FIELD .OR. ; + obj_[nObj,OBJ_TYPE] == OBJ_O_EXP + DispBegin() + @ obj_[nObj,OBJ_ROW]+scn_[SCN_ROW_DIS], ; + obj_[nObj,OBJ_COL]+scn_[SCN_COL_DIS] ; + say obj_[nObj,OBJ_TEXT] color cColor + DispEnd() + ENDIF + RETURN NIL + +//----------------------------------------------------------------------// + +FUNCTION scrDispSelctd(obj_,scn_) + LOCAL i,j,nCol,nRow + + IF !empty(scn_[SCN_TEXT_BLOCK_]) + DispBegin() + + FOR i := scn_[SCN_TEXT_BLOCK_,1] TO scn_[SCN_TEXT_BLOCK_,3] + IF (nRow := i+scn_[SCN_ROW_DIS]) <= scn_[SCN_BOTTOM] + FOR j := scn_[SCN_TEXT_BLOCK_,2] TO scn_[SCN_TEXT_BLOCK_,4] + IF (nCol := j+scn_[SCN_COL_DIS]) <= scn_[SCN_RIGHT] + @ nRow,nCol SAY scrGetChar(obj_,i,j) COLOR 'GR+/R' + ENDIF + NEXT + ENDIF + NEXT + + DispEnd() + ENDIF + RETURN NIL + +//----------------------------------------------------------------------// + +FUNCTION scrDispGhost(obj_,scn_,gst_) + LOCAL i,j,nRow,nCol + + HB_SYMBOL_UNUSED( obj_ ) + + DispBegin() + FOR i := gst_[1] TO gst_[3] + IF (nRow := i+scn_[SCN_ROW_DIS]) <= scn_[SCN_BOTTOM] + FOR j := gst_[2] TO gst_[4] + IF (nCol := j+scn_[SCN_COL_DIS]) <= scn_[SCN_RIGHT] + @ nRow,nCol SAY THE_FILL COLOR 'GR+/R' + ENDIF + NEXT + ENDIF + NEXT + DispEnd() + + RETURN NIL + +//----------------------------------------------------------------------// + +FUNCTION scrMove(obj_,scn_) + LOCAL i,scrT,scrB,scrL,scrR,k,n,nRepOff,nRowWnd,nTo + LOCAL crs := setCursor( 0 ) + LOCAL nOff, cText, nRow, nCol, cColor + + dispBegin() + + IF scn_[SCN_DESIGN] == DGN_MODULE .OR. scn_[SCN_DESIGN]==DGN_SCREEN + scrT := VouchWndSave(0,0,scn_[SCN_TOP]-1,maxcol()) + scrB := VouchWndSave(scn_[SCN_BOTTOM]+1,0,maxrow(),maxcol()) + scrL := VouchWndSave(0,0,maxrow(),scn_[SCN_LEFT]-1) + scrR := VouchWndSave(0,scn_[SCN_RIGHT]+1,maxrow(),maxcol()) + ELSE + scrT := VouchWndSave(0,0,scn_[SCN_TOP]-2,maxcol()) + scrB := VouchWndSave(maxrow()-2,0,maxrow(),maxcol()) + DispBox( scn_[SCN_TOP],0,maxrow()-2,maxcol(),' ',scn_[SCN_CLR_OVERALL] ) + + nRowWnd := scn_[SCN_BOTTOM ] - scn_[SCN_TOP] + 1 + nRepOff := scn_[SCN_ROW_REP] - (scn_[SCN_ROW_CUR] - scn_[SCN_TOP]) + nTo := (nRowWnd + nRepOff - 1) + + k := 0 + FOR i := nRepOff TO nTo + IF ( n := scrSecOrd( scn_,i ) ) <> NIL + @ scn_[ SCN_TOP ]+k, 0 SAY scn_[ SCN_SECTORS_, n, SCT_SAY ] ; + COLOR scn_[ SCN_SECTORS_,n,SCT_COLOR ] + k++ + ENDIF + NEXT + + scrL := VouchWndSave(0,0,maxrow(),scn_[SCN_LEFT]-1) + scrR := VouchWndSave(0,scn_[SCN_RIGHT]+1,maxrow()-2,maxcol()) + ENDIF + + dispBox(scn_[ SCN_TOP ],; + scn_[ SCN_LEFT ],; + scn_[ SCN_BOTTOM ],; + scn_[ SCN_RIGHT ],; + scn_[ SCN_DRAW_FILL ],; + scn_[ SCN_CLR_PREV ] ) + + FOR i := 1 TO len( obj_ ) + IF obj_[ i,OBJ_ROW ] + scn_[ SCN_ROW_DIS ] <= scn_[ SCN_BOTTOM ] .AND. ; + obj_[ i,OBJ_COL ] + scn_[ SCN_COL_DIS ] <= scn_[ SCN_RIGHT ] + + nOff := obj_[ i,OBJ_COL ] + scn_[ SCN_COL_DIS ] + nRow := obj_[ i,OBJ_ROW ] + scn_[ SCN_ROW_DIS ] + nCol := obj_[ i,OBJ_COL ] + scn_[ SCN_COL_DIS ] + + IF nOff < 0 + nCol := 0 + ENDIF + + IF obj_[i,OBJ_TYPE] == OBJ_O_BOX + DO CASE + CASE VouchInArray(obj_[ i,OBJ_MDL_F_TYPE ], { 61,62,63,67,68 } ) + dispBox( obj_[ i,OBJ_ROW ] + scn_[ SCN_ROW_DIS ],; + obj_[ i,OBJ_COL ] + scn_[ SCN_COL_DIS ],; + obj_[ i,OBJ_TO_ROW ] + scn_[ SCN_ROW_DIS ],; + obj_[ i,OBJ_TO_COL ] + scn_[ SCN_COL_DIS ],; + substr( obj_[ i,OBJ_BOX_SHAPE ], 1, 8 ),; + IF( scn_[ SCN_OBJ_HILITE ] == i, scn_[ SCN_CLR_HILITE ],; + 'w/b' /* obj_[i,OBJ_COLOR] */)) + CASE VouchInArray(obj_[i,OBJ_MDL_F_TYPE], {64,65} ) // Line + @ obj_[i,OBJ_ROW] + scn_[SCN_ROW_DIS],; + obj_[i,OBJ_COL] + scn_[SCN_COL_DIS] ; + TO obj_[i,OBJ_TO_ROW] + scn_[SCN_ROW_DIS],; + obj_[i,OBJ_TO_COL] + scn_[SCN_COL_DIS] ; + COLOR IF(scn_[SCN_OBJ_HILITE]==i,scn_[SCN_CLR_HILITE],; + 'w/b' /* obj_[i,OBJ_COLOR] */) + ENDCASE + ENDIF + + IF obj_[i,OBJ_TYPE] == OBJ_O_FIELD .OR. obj_[i,OBJ_TYPE] == OBJ_O_EXP + cText := obj_[ i,OBJ_TEXT ] + cColor := IF( scn_[ SCN_OBJ_SELECTED ] == i,scn_[ SCN_CLR_SELECT ],; + IF( scn_[ SCN_OBJ_HILITE ] == i,scn_[ SCN_CLR_HILITE ],; + 'W+/W' /* obj_[i,OBJ_COLOR] */ )) + IF nOff < 0 + cText := substr( obj_[ i,OBJ_TEXT ], abs( nOff ) + 1 ) + ENDIF + @ nRow, nCol SAY cText COLOR cColor + ENDIF + + IF obj_[i,OBJ_TYPE] == OBJ_O_TEXT + cText := obj_[ i,OBJ_EQN ] + cColor := IF( scn_[SCN_OBJ_SELECTED]==i,scn_[SCN_CLR_SELECT],; + IF( empty(obj_[i,OBJ_COLOR]),scn_[SCN_CLR_TEXT],; + 'W/B' /* obj_[i,OBJ_COLOR] */)) + IF nOff < 0 + cText := substr( obj_[ i,OBJ_EQN ], abs( nOff ) + 1 ) + ENDIF + + @ nRow, nCol SAY cText COLOR cColor + ENDIF + ELSEIF ( obj_[ i,OBJ_ROW ] + scn_[ SCN_ROW_DIS ] > scn_[ SCN_BOTTOM ] ) + + ENDIF + NEXT + + ScrDispSelctd( obj_,scn_ ) // Display Selected Screen + + IF scn_[ SCN_TOP ] > 0 + VouchWndRest(scrT) + ENDIF + IF scn_[ SCN_LEFT ] > 0 + VouchWndRest(scrL) + ENDIF + IF scn_[ SCN_BOTTOM ] < maxrow() + VouchWndRest(scrB) + ENDIF + IF scn_[ SCN_RIGHT ] < maxcol() + VouchWndRest(scrR) + ENDIF + + dispEnd() + setcursor( crs ) + RETURN NIL + +//----------------------------------------------------------------------// + +FUNCTION scrMoveLine(obj_,scn_) + LOCAL scrL,scrR,i,crs, nRow, nCol, cText, nOff, cColor + + crs := setCursor( 0 ) + + IF scn_[ SCN_ROW_PREV ] == scn_[ SCN_ROW_CUR ] + dispbegin() + dispBox(scn_[SCN_ROW_CUR ],; + scn_[SCN_LEFT ],; + scn_[SCN_ROW_CUR ],; + scn_[SCN_RIGHT ],; + scn_[SCN_DRAW_FILL],; + scn_[SCN_CLR_PREV ] ) + + scrL := VouchWndSave(scn_[SCN_ROW_CUR],0,scn_[SCN_ROW_CUR],scn_[SCN_LEFT]-1) + IF scn_[SCN_RIGHT] < maxcol() + scrR := VouchWndSave( scn_[SCN_ROW_CUR],scn_[SCN_RIGHT]+1,scn_[SCN_ROW_CUR],maxcol() ) + ENDIF + + FOR i := 1 TO len(obj_) + nOff := obj_[i,OBJ_COL]+scn_[SCN_COL_DIS] + nRow := obj_[i,OBJ_ROW]+scn_[SCN_ROW_DIS] + nCol := nOff + #ifdef __WVT__ + nCol := IF( nOff < 0, 0, nOff ) + #ENDIF + + IF obj_[i,OBJ_TYPE] == OBJ_O_BOX + DO CASE + CASE VouchInArray(obj_[i,OBJ_MDL_F_TYPE],{64,65}) // Lines V.H + @ obj_[i,OBJ_ROW] + scn_[SCN_ROW_DIS],; + obj_[i,OBJ_COL] + scn_[SCN_COL_DIS] ; + TO obj_[i,OBJ_TO_ROW] + scn_[SCN_ROW_DIS],; + obj_[i,OBJ_TO_COL] + scn_[SCN_COL_DIS] ; + COLOR IF(scn_[SCN_OBJ_HILITE]==i,scn_[SCN_CLR_HILITE],; + 'w/b' /* obj_[i,OBJ_COLOR] */) + ENDCASE + ENDIF + + IF obj_[ i,OBJ_ROW ] == scn_[ SCN_ROW_REP ] + IF obj_[i,OBJ_TYPE] == OBJ_O_FIELD .OR. obj_[i,OBJ_TYPE] == OBJ_O_EXP + cText := obj_[i,OBJ_TEXT] + cColor := IF(scn_[SCN_OBJ_SELECTED]==i,scn_[SCN_CLR_SELECT],; + IF(scn_[SCN_OBJ_HILITE ]==i,scn_[SCN_CLR_HILITE],; + 'W+/W' /* obj_[i,OBJ_COLOR] */ )) + #ifdef __WVT__ + IF nOff < 0 + cText := substr( cText, abs( nOff )+1 ) + ENDIF + #ENDIF + @ nRow, nCol SAY cText COLOR cColor + ENDIF + + IF obj_[i,OBJ_TYPE] == OBJ_O_TEXT + cText := obj_[i,OBJ_EQN] + cColor := IF(scn_[SCN_OBJ_SELECTED]==i,scn_[SCN_CLR_SELECT],; + IF(empty(obj_[i,OBJ_COLOR]),scn_[SCN_CLR_TEXT],; + 'W/B' /* obj_[i,OBJ_COLOR] */)) + #ifdef __WVT__ + cText := IF( nOff < 0, substr( cText, abs( nOff )+1 ), cText ) + #ENDIF + @ nRow, nCol SAY cText COLOR cColor + ENDIF + ENDIF + NEXT + + scrDispSelctd(obj_,scn_) // Display Selected Screen + + VouchWndRest(scrL) + IF scn_[SCN_RIGHT] < maxcol() + VouchWndRest(scrR) + ENDIF + + dispEnd() + ELSE + scrMove(obj_,scn_) + ENDIF + setCursor(crs) + RETURN NIL + +//----------------------------------------------------------------------// + +FUNCTION scrMouse( obj_, scn_, nEvent ) + LOCAL nmRow, nmCol + LOCAL aEvents_:= { K_LBUTTONUP, K_LBUTTONDOWN, K_MMLEFTDOWN } + + STATIC nLastCol := 0 + STATIC nLastRow := 0 + STATIC lAnchored := .f. + STATIC nCursor + + IF !( VouchInArray( nEvent, aEvents_ ) ) + RETURN .f. + ENDIF + + nmRow := mRow() + nmCol := mCol() + + IF nmRow < scn_[ SCN_TOP ] .OR. nmRow > scn_[ SCN_BOTTOM ] .OR. ; + nmCol < scn_[ SCN_LEFT ] .OR. nmCol > scn_[ SCN_RIGHT ] + RETURN .f. + ENDIF + + scrToMouse( scn_, nmRow, nmCol ) + + IF nEvent == K_LDBLCLK + + ELSEIF nEvent == K_MMLEFTDOWN /*K_LBUTTONDOWN */ .AND. !( lAnchored ) + IF scrChkObj( obj_,scn_ ) > 0 .AND. scn_[ SCN_MODE ] <> OBJ_MODE_SELECT + nCursor := SetCursor( 0 ) + + lAnchored := .t. + scn_[ SCN_LASTKEY ] := K_F6 + Wvt_SetPointer( WVT_IDC_SIZEALL ) + Wvt_SetMousePos( scn_[ SCN_ROW_CUR ],scn_[ SCN_COL_CUR ] ) + ENDIF + + ELSEIF nEvent == K_MMLEFTDOWN .AND. lAnchored + + ELSEIF nEvent == K_LBUTTONUP .AND. lAnchored + Wvt_SetPointer( WVT_IDC_ARROW ) + Wvt_SetMousePos( scn_[ SCN_ROW_CUR ],scn_[ SCN_COL_CUR ] ) + SetCursor( nCursor ) + lAnchored := .f. + __keyboard( chr( K_ENTER ) ) + + ELSEIF nEvent == K_LBUTTONUP + + ENDIF + + RETURN .t. + +//----------------------------------------------------------------------// + +FUNCTION scrToMouse( scn_, nmRow, nmCol ) + LOCAL nRowOff, nColOff + + nRowOff := nmRow - scn_[SCN_ROW_CUR] + IF nRowOff <> 0 + scn_[ SCN_ROW_CUR ] += nRowOff + scn_[ SCN_ROW_REP ] += nRowOff + ENDIF + + nColOff := nmCol - scn_[ SCN_COL_CUR ] + IF nColOff <> 0 + scn_[ SCN_COL_CUR ] += nColOff + scn_[ SCN_COL_REP ] += nColOff + ENDIF + + RETURN NIL + +//----------------------------------------------------------------------// + diff --git a/harbour/contrib/hbcuied/cu_prpty.prg b/harbour/contrib/hbcuied/cu_prpty.prg new file mode 100644 index 0000000000..a82f49383b --- /dev/null +++ b/harbour/contrib/hbcuied/cu_prpty.prg @@ -0,0 +1,194 @@ +/* + * $Id$ + */ + +/* + * Harbour Project source code: + * CUI Forms Editor + * + * Copyright 2011 Pritpal Bedi + * http://harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ +/* + * EkOnkar + * ( The LORD is ONE ) + * + * Harbour CUI Editor Source + * + * Pritpal Bedi + * 13Aug2011 + */ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ + +#include "hbcuied.ch" + +//----------------------------------------------------------------------// + +FUNCTION scrProperty( obj_,scn_ ) + LOCAL prp_ + + HB_SYMBOL_UNUSED( obj_ ) + + DO CASE + CASE scn_[ SCN_DESIGN ] == DGN_MODULE + prp_:= iif( empty( scn_[SCN_PROPERTY ] ), prpMdlBlank(), scn_[ SCN_PROPERTY ] ) + //prp_:= prpModule( prp_ ) /* Fetch actual values */ + scn_[SCN_PROPERTY] := prp_ + + ENDCASE + + RETURN NIL + +//----------------------------------------------------------------------// +#IF 0 +FUNCTION prpRStr2Ar(s,s1,s2) + LOCAL prp_:= array(REP_INIT_VRBLS) + + IF empty(s) // IF no property is defined, defaults + RETURN prpRepBlank() + ENDIF + + prp_[ REP_DESC ] := substr( s , REP_OS_DESC , REP_LEN_DESC ) + prp_[ REP_TYPE ] := val( substr( s , REP_OS_TYPE , REP_LEN_TYPE ) ) + prp_[ REP_IDX_NO ] := val( substr( s , REP_OS_IDX_NO , REP_LEN_IDX_NO ) ) + prp_[ REP_IDX_EXP ] := substr( s , REP_OS_IDX_EXP , REP_LEN_IDX_EXP ) + prp_[ REP_PG_SIZE ] := substr( s , REP_OS_PG_SIZE , REP_LEN_PG_SIZE ) + prp_[ REP_PG_LEN ] := val( substr( s , REP_OS_PG_LEN , REP_LEN_PG_LEN ) ) + prp_[ REP_PG_WID ] := val( substr( s , REP_OS_PG_WID , REP_LEN_PG_WID ) ) + prp_[ REP_LINES ] := val( substr( s , REP_OS_LINES , REP_LEN_LINES ) ) + prp_[ REP_MG_TOP ] := val( substr( s , REP_OS_MG_TOP , REP_LEN_MG_TOP ) ) + prp_[ REP_MG_LEFT ] := val( substr( s , REP_OS_MG_LEFT , REP_LEN_MG_LEFT ) ) + prp_[ REP_MG_BOTTOM ] := val( substr( s , REP_OS_MG_BOTTOM , REP_LEN_MG_BOTTOM ) ) + prp_[ REP_EJ_BEFORE ] := substr( s , REP_OS_EJ_BEFORE , REP_LEN_EJ_BEFORE ) == 'T' + prp_[ REP_EJ_AFTER ] := substr( s , REP_OS_EJ_AFTER , REP_LEN_EJ_AFTER ) == 'T' + prp_[ REP_PLAIN ] := val( substr( s , REP_OS_PLAIN , REP_LEN_PLAIN ) ) + prp_[ REP_FTR_PAG ] := substr( s , REP_OS_FTR_PAG , REP_LEN_FTR_PAG ) + prp_[ REP_SMR_NEXT ] := substr( s , REP_OS_SMR_NEXT , REP_LEN_SMR_NEXT ) == 'T' + prp_[ REP_HDR_PAGES ] := substr( s , REP_OS_HDR_PAGES , REP_LEN_HDR_PAGES ) + prp_[ REP_BNK_LINES ] := val( substr( s , REP_OS_BNK_LINES , REP_LEN_BNK_LINES ) ) + prp_[ REP_BNK_AFTER ] := val( substr( s , REP_OS_BNK_AFTER , REP_LEN_BNK_AFTER ) ) + prp_[ REP_DATA_BOX ] := substr( s , REP_OS_DATA_BOX , REP_LEN_DATA_BOX ) == 'T' + prp_[ REP_FILE ] := substr( s , REP_OS_FILE , REP_LEN_FILE ) + prp_[ REP_COPIES ] := val( substr( s , REP_OS_COPIES , REP_LEN_COPIES ) ) + prp_[ REP_TTL_PAGES ] := substr( s , REP_OS_TTL_PAGES , REP_LEN_TTL_PAGES ) + prp_[ REP_INIT_CPI ] := val( substr( s , REP_OS_INIT_CPI , REP_LEN_INIT_CPI ) ) + prp_[ REP_PRN_QLY ] := substr( s , REP_OS_PRN_QLY , REP_LEN_PRN_QLY ) + prp_[ REP_RECONFIRM ] := substr( s , REP_OS_RECONFIRM , REP_LEN_RECONFIRM ) == 'T' + prp_[ REP_FTR_BOTTOM ] := substr( s , REP_OS_FTR_BOTTOM, REP_LEN_FTR_BOTTOM ) == 'T' + prp_[ REP_HTML ] := substr( s , REP_OS_HTML , REP_LEN_HTML ) == 'T' + prp_[ REP_PRINTER ] := substr( s , REP_OS_PRINTER , REP_LEN_PRINTER ) + prp_[ REP_ORIENT ] := substr( s , REP_OS_ORIENT , REP_LEN_ORIENT ) + prp_[ REP_PREVIEW ] := substr( s , REP_OS_PREVIEW , REP_LEN_PREVIEW ) == 'T' + prp_[ REP_GRAY ] := substr( s , REP_OS_GRAY , REP_LEN_GRAY ) == 'T' + prp_[ REP_WINDLG ] := substr( s , REP_OS_WINDLG , REP_LEN_WINDLG ) == 'T' + prp_[ REP_DUPLEX ] := val( substr( s , REP_OS_DUPLEX , REP_LEN_DUPLEX ) ) + prp_[ REP_COLS ] := val( substr( s , REP_OS_COLS , REP_LEN_COLS ) ) + prp_[ REP_ROWS ] := val( substr( s , REP_OS_ROWS , REP_LEN_ROWS ) ) + + prp_[ REP_FOR ] := substr( s1, REP_OS_FOR , REP_LEN_FOR ) + prp_[ REP_WHILE ] := substr( s1, REP_OS_WHILE , REP_LEN_WHILE ) + prp_[ REP_FIRST ] := substr( s1, REP_OS_FIRST , REP_LEN_FIRST ) + prp_[ REP_EXE_PRE ] := substr( s2, REP_OS_EXE_PRE , REP_LEN_EXE_PRE ) + prp_[ REP_EXE_POST ] := substr( s2, REP_OS_EXE_POST , REP_LEN_EXE_POST ) + + prp_[ REP_ORIENT ] := iif( empty( prp_[ REP_ORIENT ] ), 'P', prp_[ REP_ORIENT ] ) + + RETURN prp_ +#ENDIF +//----------------------------------------------------------------------// + +FUNCTION prpRAr2Str(prp_,s,s1,s2) // Passed by reference + + s := pad( prp_[ REP_DESC ] , REP_LEN_DESC ) +; + pad( NTRIM( prp_[ REP_TYPE ] ), REP_LEN_TYPE ) +; + pad( NTRIM( prp_[ REP_IDX_NO ] ), REP_LEN_IDX_NO ) +; + pad( prp_[ REP_IDX_EXP ] , REP_LEN_IDX_EXP ) +; + pad( prp_[ REP_PG_SIZE ] , REP_LEN_PG_SIZE ) +; + pad( NTRIM( prp_[ REP_PG_LEN ] ), REP_LEN_PG_LEN ) +; + pad( NTRIM( prp_[ REP_PG_WID ] ), REP_LEN_PG_WID ) +; + pad( NTRIM( prp_[ REP_LINES ] ), REP_LEN_LINES ) +; + pad( NTRIM( prp_[ REP_MG_TOP ] ), REP_LEN_MG_TOP ) +; + pad( NTRIM( prp_[ REP_MG_LEFT ] ), REP_LEN_MG_LEFT ) +; + pad( NTRIM( prp_[ REP_MG_BOTTOM ] ), REP_LEN_MG_BOTTOM ) +; + iif( prp_[ REP_EJ_BEFORE ] , 'T','F' ) +; + iif( prp_[ REP_EJ_AFTER ] , 'T','F' ) +; + pad( NTRIM( prp_[ REP_PLAIN ] ), REP_LEN_PLAIN ) +; + pad( prp_[ REP_FTR_PAG ] , REP_LEN_FTR_PAG ) +; + iif( prp_[ REP_SMR_NEXT ] , 'T','F' ) +; + pad( prp_[ REP_HDR_PAGES ] , REP_LEN_HDR_PAGES ) +; + pad( NTRIM( prp_[ REP_BNK_LINES ] ), REP_LEN_BNK_LINES ) +; + pad( NTRIM( prp_[ REP_BNK_AFTER ] ), REP_LEN_BNK_AFTER ) +; + iif( prp_[ REP_DATA_BOX ] ,'T','F' ) +; + pad( prp_[ REP_FILE ] , REP_LEN_FILE ) +; + pad( NTRIM( prp_[ REP_COPIES ] ), REP_LEN_COPIES ) +; + pad( prp_[ REP_TTL_PAGES ] , REP_LEN_TTL_PAGES ) +; + pad( NTRIM( prp_[ REP_INIT_CPI ] ), REP_LEN_INIT_CPI ) +; + pad( prp_[ REP_PRN_QLY ] , REP_LEN_PRN_QLY ) +; + iif( prp_[ REP_RECONFIRM ] , 'T','F' ) +; + iif( prp_[ REP_FTR_BOTTOM ] , 'T','F' ) +; + iif( prp_[ REP_HTML ] , 'T','F' ) +; + pad( prp_[ REP_PRINTER ] , REP_LEN_PRINTER ) +; + pad( prp_[ REP_ORIENT ] , REP_LEN_ORIENT ) +; + iif( prp_[ REP_PREVIEW ] , 'T','F' ) +; + iif( prp_[ REP_GRAY ] , 'T','F' ) +; + iif( prp_[ REP_WINDLG ] , 'T','F' ) +; + pad( NTRIM( prp_[ REP_DUPLEX ] ), REP_LEN_DUPLEX ) +; + pad( NTRIM( prp_[ REP_COLS ] ), REP_LEN_COLS ) +; + pad( NTRIM( prp_[ REP_ROWS ] ), REP_LEN_ROWS ) + + s1 := pad( prp_[ REP_FOR ] , REP_LEN_FOR ) +; + pad( prp_[ REP_WHILE ] , REP_LEN_WHILE ) +; + pad( prp_[ REP_FIRST ] , REP_LEN_FIRST ) + + s2 := pad( prp_[ REP_EXE_PRE ] , REP_LEN_EXE_PRE ) +; + pad( prp_[ REP_EXE_POST ] , REP_LEN_EXE_POST ) + + RETURN NIL + +//----------------------------------------------------------------------// + diff --git a/harbour/contrib/hbcuied/cu_utlty.prg b/harbour/contrib/hbcuied/cu_utlty.prg new file mode 100644 index 0000000000..e8d29b882c --- /dev/null +++ b/harbour/contrib/hbcuied/cu_utlty.prg @@ -0,0 +1,2140 @@ +/* + * $Id$ + */ + +/* + * Harbour Project source code: + * CUI Forms Editor + * + * Copyright 2011 Pritpal Bedi + * http://harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ +/* + * EkOnkar + * ( The LORD is ONE ) + * + * Harbour CUI Editor Source + * + * Pritpal Bedi + * 13Aug2011 + */ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ + +#include "hbcuied.ch" +#include "hbgtinfo.ch" +#include "hbgtwvg.ch" +#include "common.ch" +#include "inkey.ch" +#include "achoice.ch" + +//----------------------------------------------------------------------// + +FUNCTION scrVvBlank() + LOCAL v_:= array( VV_INIT_VRBLS ) + + v_[ VV_ID ] := 'New ' + v_[ VV_FIELD ] := 0 + v_[ VV_F_TYPE ] := 'C' + v_[ VV_F_LEN ] := 25 + v_[ VV_F_DEC ] := 0 + v_[ VV_ATTRB ] := 'NONE ' + v_[ VV_EQN ] := ' ' + v_[ VV_PRN_LEN ] := 25 + v_[ VV_F_PIC ] := ' ' + v_[ VV_PITCH ] := 10 + v_[ VV_FONT ] := 'COURIER ' + v_[ VV_BOLD ] := .f. + v_[ VV_ITALIC ] := .f. + v_[ VV_UNDERLN ] := .f. + v_[ VV_S_SCRPT ] := .f. + v_[ VV_U_SCRPT ] := .f. + v_[ VV_HALF_H ] := .f. + v_[ VV_ALIGN ] := 'C' + v_[ VV_COLOR ] := 'W+/B ' + v_[ VV_ZERO ] := .t. + v_[ VV_REPEATED ] := 'NO ' + v_[ VV_VERTICLE ] := .F. + v_[ VV_WRAP_SEMI ] := .F. + v_[ VV_FOR ] := space( 80 ) + v_[ VV_OBJ_UNIQUE ] := 0 + v_[ VV_MDL_F_TYPE ] := 0 + v_[ VV_POINT ] := 12 + v_[ VV_COL_JUST ] := 0 + v_[ VV_PATTERN ] := 'SOLID ' + v_[ VV_BORDER ] := 0.50 + + RETURN v_ + +//----------------------------------------------------------------------// + +FUNCTION scrVvSelAble( /*scn_*/ ) + LOCAL sel_:= array( VV_INIT_VRBLS ) + LOCAL isPrint := .f. + + sel_[ VV_ID ] := .t. + sel_[ VV_FIELD ] := .f. + sel_[ VV_F_TYPE ] := .t. + sel_[ VV_F_LEN ] := .t. + sel_[ VV_F_DEC ] := .t. + sel_[ VV_ATTRB ] := .f. + sel_[ VV_EQN ] := .f. + sel_[ VV_PRN_LEN ] := .T. + sel_[ VV_F_PIC ] := .t. + sel_[ VV_PITCH ] := isPrint + sel_[ VV_FONT ] := isPrint + sel_[ VV_BOLD ] := isPrint + sel_[ VV_ITALIC ] := isPrint + sel_[ VV_UNDERLN ] := isPrint + sel_[ VV_S_SCRPT ] := .f. // isPrint + sel_[ VV_U_SCRPT ] := .f. // isPrint + sel_[ VV_HALF_H ] := isPrint + sel_[ VV_ALIGN ] := .t. // isPrint + sel_[ VV_COLOR ] := .t. // !isPrint + sel_[ VV_ZERO ] := isPrint + sel_[ VV_REPEATED ] := isPrint + sel_[ VV_VERTICLE ] := isPrint + sel_[ VV_WRAP_SEMI ] := isPrint + sel_[ VV_FOR ] := isPrint + sel_[ VV_OBJ_UNIQUE ] := .f. + sel_[ VV_MDL_F_TYPE ] := .f. + sel_[ VV_POINT ] := .T. + sel_[ VV_COL_JUST ] := .t. + sel_[ VV_PATTERN ] := .t. + sel_[ VV_BORDER ] := .f. + + RETURN sel_ + +//----------------------------------------------------------------------// + +FUNCTION scrVv2Obj( v_,o_ ) + + o_[ OBJ_ID ] := v_[ VV_ID ] + o_[ OBJ_FIELD ] := v_[ VV_FIELD ] + o_[ OBJ_F_TYPE ] := v_[ VV_F_TYPE ] + o_[ OBJ_F_LEN ] := v_[ VV_F_LEN ] + o_[ OBJ_F_DEC ] := v_[ VV_F_DEC ] + o_[ OBJ_ATTRB ] := v_[ VV_ATTRB ] + o_[ OBJ_EQN ] := v_[ VV_EQN ] + o_[ OBJ_PRN_LEN ] := v_[ VV_PRN_LEN ] + o_[ OBJ_F_PIC ] := v_[ VV_F_PIC ] + o_[ OBJ_PITCH ] := v_[ VV_PITCH ] + o_[ OBJ_FONT ] := v_[ VV_FONT ] + o_[ OBJ_BOLD ] := v_[ VV_BOLD ] + o_[ OBJ_ITALIC ] := v_[ VV_ITALIC ] + o_[ OBJ_UNDERLN ] := v_[ VV_UNDERLN ] + o_[ OBJ_S_SCRPT ] := v_[ VV_S_SCRPT ] + o_[ OBJ_U_SCRPT ] := v_[ VV_U_SCRPT ] + o_[ OBJ_HALF_H ] := v_[ VV_HALF_H ] + o_[ OBJ_ALIGN ] := v_[ VV_ALIGN ] + o_[ OBJ_COLOR ] := v_[ VV_COLOR ] + o_[ OBJ_ZERO ] := v_[ VV_ZERO ] + o_[ OBJ_REPEATED ] := v_[ VV_REPEATED ] + o_[ OBJ_VERTICLE ] := v_[ VV_VERTICLE ] + o_[ OBJ_WRAP_SEMI ] := v_[ VV_WRAP_SEMI ] + o_[ OBJ_FOR ] := v_[ VV_FOR ] + o_[ OBJ_OBJ_UNIQUE ] := v_[ VV_OBJ_UNIQUE ] + o_[ OBJ_MDL_F_TYPE ] := v_[ VV_MDL_F_TYPE ] + o_[ OBJ_POINT ] := v_[ VV_POINT ] + o_[ OBJ_COL_JUST ] := v_[ VV_COL_JUST ] + o_[ OBJ_PATTERN ] := v_[ VV_PATTERN ] + o_[ OBJ_BORDER ] := v_[ VV_BORDER ] + + RETURN o_ + +//----------------------------------------------------------------------// + +FUNCTION scrObj2Vv( o_ ) + LOCAL v_:={} + + aadd( v_, pad( o_[OBJ_ID ],15 ) ) + aadd( v_, o_[ OBJ_FIELD ] ) + aadd( v_, o_[ OBJ_F_TYPE ] ) + aadd( v_, o_[ OBJ_F_LEN ] ) + aadd( v_, o_[ OBJ_F_DEC ] ) + aadd( v_, o_[ OBJ_ATTRB ] ) + aadd( v_, o_[ OBJ_EQN ] ) + aadd( v_, o_[ OBJ_PRN_LEN ] ) + aadd( v_, o_[ OBJ_F_PIC ] ) + aadd( v_, o_[ OBJ_PITCH ] ) + aadd( v_, o_[ OBJ_FONT ] ) + aadd( v_, o_[ OBJ_BOLD ] ) + aadd( v_, o_[ OBJ_ITALIC ] ) + aadd( v_, o_[ OBJ_UNDERLN ] ) + aadd( v_, o_[ OBJ_S_SCRPT ] ) + aadd( v_, o_[ OBJ_U_SCRPT ] ) + aadd( v_, o_[ OBJ_HALF_H ] ) + aadd( v_, o_[ OBJ_ALIGN ] ) + aadd( v_, o_[ OBJ_COLOR ] ) + aadd( v_, o_[ OBJ_ZERO ] ) + aadd( v_, o_[ OBJ_REPEATED ] ) + aadd( v_, o_[ OBJ_VERTICLE ] ) + aadd( v_, o_[ OBJ_WRAP_SEMI ] ) + aadd( v_, o_[ OBJ_FOR ] ) + aadd( v_, o_[ OBJ_OBJ_UNIQUE ] ) + aadd( v_, o_[ OBJ_MDL_F_TYPE ] ) + aadd( v_, o_[ OBJ_POINT ] ) + aadd( v_, o_[ OBJ_COL_JUST ] ) + aadd( v_, o_[ OBJ_PATTERN ] ) + aadd( v_, o_[ OBJ_BORDER ] ) + + RETURN v_ + +//----------------------------------------------------------------------// + +FUNCTION scrStr2Obj( s ) + LOCAL obj_:= scrObjBlank() + + obj_[ OBJ_TYPE ] := val( substr( s, OBJ_OS_TYPE, OBJ_LEN_TYPE ) ) + obj_[ OBJ_ROW ] := val( substr( s, OBJ_OS_ROW, OBJ_LEN_ROW ) ) + obj_[ OBJ_COL ] := val( substr( s, OBJ_OS_COL, OBJ_LEN_COL ) ) + obj_[ OBJ_TEXT ] := substr( s, OBJ_OS_TEXT, OBJ_LEN_TEXT ) + obj_[ OBJ_COLOR ] := substr( s, OBJ_OS_COLOR, OBJ_LEN_COLOR ) + obj_[ OBJ_TO_ROW ] := val( substr( s, OBJ_OS_TO_ROW, OBJ_LEN_TO_ROW ) ) + obj_[ OBJ_TO_COL ] := val( substr( s, OBJ_OS_TO_COL, OBJ_LEN_TO_COL ) ) + obj_[ OBJ_ID ] := substr( s, OBJ_OS_ID, OBJ_LEN_ID ) + obj_[ OBJ_SECTION ] := val( substr( s, OBJ_OS_SECTION, OBJ_LEN_SECTION ) ) + obj_[ OBJ_ALIAS ] := substr( s, OBJ_OS_ALIAS, OBJ_LEN_ALIAS ) + obj_[ OBJ_FIELD ] := val( substr( s, OBJ_OS_FIELD, OBJ_LEN_FIELD ) ) + obj_[ OBJ_EQN ] := substr( s, OBJ_OS_EQN, OBJ_LEN_EQN ) + obj_[ OBJ_F_TYPE ] := substr( s, OBJ_OS_F_TYPE, OBJ_LEN_F_TYPE ) + obj_[ OBJ_F_LEN ] := val( substr( s, OBJ_OS_F_LEN, OBJ_LEN_F_LEN ) ) + obj_[ OBJ_F_DEC ] := val( substr( s, OBJ_OS_F_DEC, OBJ_LEN_F_DEC ) ) + obj_[ OBJ_F_PIC ] := substr( s, OBJ_OS_F_PIC, OBJ_LEN_F_PIC ) + obj_[ OBJ_ALIGN ] := substr( s, OBJ_OS_ALIGN, OBJ_LEN_ALIGN ) + obj_[ OBJ_PITCH ] := val( substr( s, OBJ_OS_PITCH, OBJ_LEN_PITCH ) ) + obj_[ OBJ_FONT ] := substr( s, OBJ_OS_FONT, OBJ_LEN_FONT ) + obj_[ OBJ_BOLD ] := substr( s, OBJ_OS_BOLD, OBJ_LEN_BOLD ) == 'T' + obj_[ OBJ_ITALIC ] := substr( s, OBJ_OS_ITALIC, OBJ_LEN_ITALIC ) == 'T' + obj_[ OBJ_UNDERLN ] := substr( s, OBJ_OS_UNDERLN, OBJ_LEN_UNDERLN ) == 'T' + obj_[ OBJ_S_SCRPT ] := substr( s, OBJ_OS_S_SCRPT, OBJ_LEN_S_SCRPT ) == 'T' + obj_[ OBJ_U_SCRPT ] := substr( s, OBJ_OS_U_SCRPT, OBJ_LEN_U_SCRPT ) == 'T' + obj_[ OBJ_HALF_H ] := substr( s, OBJ_OS_HALF_H, OBJ_LEN_HALF_H ) == 'T' + obj_[ OBJ_PRN_LEN ] := val( substr( s, OBJ_OS_PRN_LEN, OBJ_LEN_PRN_LEN ) ) + obj_[ OBJ_ZERO ] := substr( s, OBJ_OS_ZERO , OBJ_LEN_ZERO ) == 'T' + obj_[ OBJ_REPEATED ] := substr( s, OBJ_OS_REPEATED, OBJ_LEN_REPEATED ) + obj_[ OBJ_VERTICLE ] := substr( s, OBJ_OS_VERTICLE, OBJ_LEN_VERTICLE ) == 'T' + obj_[ OBJ_WRAP_SEMI ] := substr( s, OBJ_OS_WRAP_SEMI, OBJ_LEN_WRAP_SEMI ) == 'T' + obj_[ OBJ_FOR ] := substr( s, OBJ_OS_FOR, OBJ_LEN_FOR ) + obj_[ OBJ_SEC_ROW ] := val( substr( s, OBJ_OS_SEC_ROW, OBJ_LEN_SEC_ROW ) ) + obj_[ OBJ_ATTRB ] := substr( s, OBJ_OS_ATTRB, OBJ_LEN_ATTRB ) + obj_[ OBJ_VAL ] := substr( s, OBJ_OS_VAL, OBJ_LEN_VAL ) + obj_[ OBJ_OBJ_UNIQUE ] := val( substr( s, OBJ_OS_OBJ_UNIQUE, OBJ_LEN_OBJ_UNIQUE ) ) + obj_[ OBJ_MDL_F_TYPE ] := val( substr( s, OBJ_OS_MDL_F_TYPE, OBJ_LEN_MDL_F_TYPE ) ) + obj_[ OBJ_POINT ] := val( substr( s, OBJ_OS_POINT, OBJ_LEN_POINT ) ) + obj_[ OBJ_COL_JUST ] := val( substr( s, OBJ_OS_COL_JUST, OBJ_LEN_COL_JUST ) ) + obj_[ OBJ_PATTERN ] := substr( s, OBJ_OS_PATTERN, OBJ_LEN_PATTERN ) + obj_[ OBJ_BORDER ] := val( substr( s, OBJ_OS_BORDER, OBJ_LEN_BORDER ) ) + + obj_[OBJ_TEXT ] := padc( alltrim( obj_[OBJ_TEXT] ),obj_[OBJ_F_LEN] ) + + obj_[OBJ_EQN ] := iif( obj_[ OBJ_TYPE ] == OBJ_O_TEXT, substr( obj_[ OBJ_EQN ], 1,; + obj_[ OBJ_TO_COL ] - obj_[ OBJ_COL ] + 1 ), obj_[ OBJ_EQN ] ) + RETURN obj_ + +//----------------------------------------------------------------------// + +FUNCTION scrObj2str( obj_ ) + LOCAL s := ; + str( obj_[ OBJ_TYPE ], OBJ_LEN_TYPE ) + ; + str( obj_[ OBJ_ROW ], OBJ_LEN_ROW ) + ; + str( obj_[ OBJ_COL ], OBJ_LEN_COL ) + ; + pad( alltrim( obj_[ OBJ_TEXT ] ), OBJ_LEN_TEXT ) + ; + pad( obj_[ OBJ_COLOR ], OBJ_LEN_COLOR ) + ; + str( obj_[ OBJ_TO_ROW ], OBJ_LEN_TO_ROW ) + ; + str( obj_[ OBJ_TO_COL ], OBJ_LEN_TO_COL ) + ; + pad( obj_[ OBJ_ID ], OBJ_LEN_ID ) + ; + str( obj_[ OBJ_SECTION ], OBJ_LEN_SECTION ) + ; + pad( obj_[ OBJ_ALIAS ], OBJ_LEN_ALIAS ) + ; + str( obj_[ OBJ_FIELD ], OBJ_LEN_FIELD ) + ; + pad( obj_[ OBJ_EQN ], OBJ_LEN_EQN ) + ; + pad( obj_[ OBJ_F_TYPE ], OBJ_LEN_F_TYPE ) + ; + str( obj_[ OBJ_F_LEN ], OBJ_LEN_F_LEN ) + ; + str( obj_[ OBJ_F_DEC ], OBJ_LEN_F_DEC ) + ; + pad( obj_[ OBJ_F_PIC ], OBJ_LEN_F_PIC ) + ; + pad( obj_[ OBJ_ALIGN ], OBJ_LEN_ALIGN ) + ; + str( obj_[ OBJ_PITCH ], OBJ_LEN_PITCH ) + ; + pad( obj_[ OBJ_FONT ], OBJ_LEN_FONT ) + ; + iif( obj_[ OBJ_BOLD ], 'T', 'F' ) + ; + iif( obj_[ OBJ_ITALIC ], 'T', 'F' ) + ; + iif( obj_[ OBJ_UNDERLN ], 'T', 'F' ) + ; + iif( obj_[ OBJ_S_SCRPT ], 'T', 'F' ) + ; + iif( obj_[ OBJ_U_SCRPT ], 'T', 'F' ) + ; + iif( obj_[ OBJ_HALF_H ], 'T', 'F' ) + ; + str( obj_[ OBJ_PRN_LEN ], OBJ_LEN_PRN_LEN ) + ; + iif( obj_[ OBJ_ZERO ], 'T', 'F' ) + ; + pad( obj_[ OBJ_REPEATED ], OBJ_LEN_REPEATED ) + ; + iif( obj_[ OBJ_VERTICLE ], 'T', 'F' ) + ; + iif( obj_[ OBJ_WRAP_SEMI ], 'T', 'F' ) + ; + pad( obj_[ OBJ_FOR ], OBJ_LEN_FOR ) + ; + str( obj_[ OBJ_SEC_ROW ], OBJ_LEN_SEC_ROW ) + ; + pad( obj_[ OBJ_ATTRB ], OBJ_LEN_ATTRB ) + ; + pad( obj_[ OBJ_VAL ], OBJ_LEN_VAL ) + ; + str( obj_[ OBJ_OBJ_UNIQUE ], OBJ_LEN_OBJ_UNIQUE ) + ; + str( obj_[ OBJ_MDL_F_TYPE ], OBJ_LEN_MDL_F_TYPE ) + ; + str( obj_[ OBJ_POINT ], OBJ_LEN_POINT ) + ; + str( obj_[ OBJ_COL_JUST ], OBJ_LEN_COL_JUST ) + ; + pad( obj_[ OBJ_PATTERN ], OBJ_LEN_PATTERN ) + ; + str( obj_[ OBJ_BORDER ], OBJ_LEN_BORDER, 2 ) + + RETURN pad( s,490 ) // 10 FOR Random, 500 FOR attr + +//----------------------------------------------------------------------// + +FUNCTION scrObjBlank() + LOCAL o_:= array( OBJ_INIT_VRBLS ) + + o_[ OBJ_TYPE ] := 0 + o_[ OBJ_ROW ] := 0 + o_[ OBJ_COL ] := 0 + o_[ OBJ_TEXT ] := '' + o_[ OBJ_COLOR ] := 'W/B ' + o_[ OBJ_TO_ROW ] := 0 + o_[ OBJ_TO_COL ] := 0 + o_[ OBJ_ID ] := '' + o_[ OBJ_SECTION ] := 1 + o_[ OBJ_ALIAS ] := '' + o_[ OBJ_FIELD ] := 0 + o_[ OBJ_EQN ] := '' + o_[ OBJ_F_TYPE ] := '' + o_[ OBJ_F_LEN ] := 0 + o_[ OBJ_F_DEC ] := 0 + o_[ OBJ_F_PIC ] := '' + o_[ OBJ_ALIGN ] := 'L' + o_[ OBJ_PITCH ] := 10 + o_[ OBJ_FONT ] := 'COURIER ' + o_[ OBJ_BOLD ] := .F. + o_[ OBJ_ITALIC ] := .F. + o_[ OBJ_UNDERLN ] := .F. + o_[ OBJ_S_SCRPT ] := .F. + o_[ OBJ_U_SCRPT ] := .F. + o_[ OBJ_PRN_LEN ] := 0 + o_[ OBJ_HALF_H ] := .F. + o_[ OBJ_ZERO ] := .T. + o_[ OBJ_REPEATED ] := 'NO ' + o_[ OBJ_VERTICLE ] := .F. + o_[ OBJ_WRAP_SEMI ] := .F. + o_[ OBJ_FOR ] := space( 80 ) + o_[ OBJ_SEC_ROW ] := 0 + o_[ OBJ_ATTRB ] := 'NONE ' + o_[ OBJ_VAL ] := ' ' + o_[ OBJ_OBJ_UNIQUE ] := 0 + o_[ OBJ_MDL_F_TYPE ] := 0 + o_[ OBJ_POINT ] := 0 + o_[ OBJ_COL_JUST ] := 0 + o_[ OBJ_PATTERN ] := 'SOLID ' + o_[ OBJ_BORDER ] := 0.50 + + RETURN o_ + +//----------------------------------------------------------------------// + +FUNCTION scrScn2obj( scn_,nType ) + LOCAL obj_:={} + DEFAULT nType TO 0 + aeval( scn_,{|e_| IF( e_[2] == nType, aadd( obj_,scrStr2Obj( e_[3] ) ), '' ) } ) + RETURN obj_ + +//----------------------------------------------------------------------// +#IF 0 +FUNCTION scrClrFrBk( cClr ) + LOCAL nClrF, nClrB,cFr,cBk,n + LOCAL pal_:={'W','N','N+','N++','BG','G','R','RB','GR',; + 'B','GR+','W+','B+','R+','BG+','G+','RB+','X'} + LOCAL mnu_:= ; + {'White', 'Black', 'Grey','Pale Grey','Baige', 'Green', 'Red',; + 'Magenta', 'Brown', 'Blue', 'Yellow','Bright White',; + 'Bright Blue', 'Bright Red', 'Bright Baige',; + 'Bright Green', 'Bright Magenta','None'} + + cClr := IF( empty( cClr ),'W/B',alltrim( upper( cClr ) ) ) + IF( n := at( '/',cClr ) )==0 + RETURN pad( cClr,7 ) + ENDIF + cFr := substr( cClr,1,n-1 ) + cBk := substr( cClr,n+1 ) + + nClrF := ascan( pal_,{|e| e == cFr} ) + nClrB := ascan( pal_,{|e| e == cBk} ) + + B_MSG 'ForeGround Color' ; + CHOOSE mnu_ RESTORE SHADOW CENTER INTO nClrF INITIAL nClrF + IF nClrF == 0 + RETURN space( 7 ) + ENDIF + + B_MSG 'BackGround Color' ; + CHOOSE mnu_ RESTORE SHADOW CENTER INTO nClrB INITIAL nClrB + IF nClrB == 0 + RETURN space( 7 ) + ENDIF + RETURN pad( pal_[nClrF]+'/'+pal_[nClrB],7 ) +#ENDIF +//----------------------------------------------------------------------// + +FUNCTION scrField( nObj,nFldExp,obj_,scn_,v_,sel_,cColor ) + LOCAL h_:={},w_:={},o_ + + DEFAULT cColor TO scn_[ SCN_CLR_FIELD ] + DEFAULT sel_ TO scrVvSelAble() + + IF nObj == 0 + o_:= scrObjBlank() + DEFAULT v_ TO scrVvBlank() + ELSE + o_:= obj_[ nObj ] + IF v_ == NIL .OR. empty( v_ ) + v_:= scrObj2Vv( o_ ) + ENDIF + ENDIF + + v_[ VV_PRN_LEN ] := iif( v_[ VV_PRN_LEN ] == 0, v_[ VV_F_LEN ], v_[ VV_PRN_LEN ] ) + + aadd( h_, ' Title ' ) + aadd( h_, ' Field ' ) + aadd( h_, ' Type ' ) + aadd( h_, ' Width ' ) + aadd( h_, ' Decimals ' ) + aadd( h_, ' Calculate ' ) + aadd( h_, ' Expression ' ) + aadd( h_, ' Printed Width ' ) + aadd( h_, ' Picture ' ) + aadd( h_, ' Pitch ' ) + aadd( h_, ' Font ' ) + aadd( h_, ' Bold ' ) + aadd( h_, ' Italics ' ) + aadd( h_, ' UnderLine ' ) + aadd( h_, ' SuperScript ' ) + aadd( h_, ' SubScript ' ) + aadd( h_, ' Half Height ' ) + aadd( h_, ' Alignment ' ) + aadd( h_, ' Color ' ) + aadd( h_, ' Zero as Blank ' ) + aadd( h_, ' Supress Repeated Values ' ) + aadd( h_, ' Verticle Stretch ' ) + aadd( h_, ' Wrap Semi Colons ' ) + aadd( h_, ' The FOR Condition ' ) + aadd( h_, ' Unique Id ' ) + aadd( h_, ' Field Type . Module ' ) + aadd( h_, ' Point Size ' ) + aadd( h_, ' Column FOR Justification ' ) + aadd( h_, ' Pattern TO fill a frame ' ) + aadd( h_, ' Border Thickness ' ) + + aadd( w_, {| |.t.} ) + aadd( w_, {| |.t.} ) + aadd( w_, {| | VouchMenuM( 'MN_TYFLD' ) } ) + aadd( w_, {|v| v := oAchGet( 3 ),IF( v=='D',!oCPut( 8 ),IF( v=='L',!oCPut( 1 ),.t. ) ) } ) + aadd( w_, {|v| v := oAchGet( 3 ),IF( v<>'N',!oCPut( 0 ),.t. ) } ) + aadd( w_, {| | IF( oAchGet( 3 )=='N',VouchMenuM( 'MN_SUMAV' ),.f. ) } ) + aadd( w_, {| | !oCPut( scrExp( oGet(),oAchGet( 3 ) ) ) } ) + aadd( w_, {| |.t.} ) // Printing Width + aadd( w_, {| |.t.} ) // Picture + aadd( w_, {| | VouchMenuM( 'MN_CPI ' ) } ) + aadd( w_, {| | VouchMenuM( 'MN_FONTS' ) } ) // Font + aadd( w_, {| | VouchYN( 'Bold Printing',oGet() ),.f. } ) + aadd( w_, {| | VouchYN( 'Italic Printing',oGet() ),.f. } ) + aadd( w_, {| | VouchYN( 'Underlined Printing',oGet() ),.f. } ) + aadd( w_, {| | VouchYN( 'SuperScript Printing',oGet() ),.f. } ) + aadd( w_, {| | VouchYN( 'SubScript Printing',oGet() ),.f. } ) + aadd( w_, {| | VouchYN( 'Half Height Printing',oGet() ),.f. } ) + aadd( w_, {| | VouchMenuM( 'MN_ALIGN' ),.f. } ) + aadd( w_, {| | .f. } ) + aadd( w_, {| | IF( oAchGet( 3 )=='N',!VouchYN( 'Zeros as Blank',oGet() ),.f. ) } ) + aadd( w_, {| | VouchMenuM( 'MN_SPRES' ) } ) + aadd( w_, {| | !VouchYN( 'Stretch Value Verically',oGet() ),.f. } ) + aadd( w_, {| | !VouchYN( 'Wrap Semicolons',oGet() ),.f. } ) + aadd( w_, {| | .f. } ) + aadd( w_, {| | .f. } ) + aadd( w_, {| | .f. } ) + aadd( w_, {| | .t. } ) // Point Size + aadd( w_, {| | .t. } ) // Justify Column + aadd( w_, {| | VouchMenuM( 'MN_PTTRN' ) } ) + aadd( w_, {| | .t. } ) // Border Thickness + + B_GETS HEADERS h_ VALUES v_ ; + TITLE 'Configure '+ IF( nFldExp==1,'Field',IF( nFldExp==2,'Expression',IF( nFldexp==3,'Text','OBJECT' ) ) ) ; + INTO v_ WHEN w_ SELECTABLES sel_ + + v_:= v_[1] + v_[1] := alltrim( trim( v_[1] ) ) + IF empty( v_[1] ) + RETURN NIL + ENDIF + + IF lastkey()<>K_ESC // Now Configure OBJECT + v_[VV_PRN_LEN] := IF( v_[VV_PRN_LEN]=0,v_[VV_F_LEN],v_[VV_PRN_LEN] ) + + o_:= scrVv2Obj( v_,o_ ) + + o_[OBJ_TYPE] := IF( nFldExp==1, OBJ_O_FIELD,; + IF( nFldExp==2, OBJ_O_EXP,; + IF( nFldExp==3,OBJ_O_TEXT,; + IF( nFldExp==4,OBJ_O_BOX,; + OBJ_O_FIELD ) ) ) ) + IF o_[ OBJ_TYPE ] == OBJ_O_FIELD .OR. o_[OBJ_TYPE] == OBJ_O_EXP + o_[ OBJ_ROW ] := IF( nObj==0,scn_[SCN_ROW_REP],o_[OBJ_ROW] ) + o_[ OBJ_COL ] := IF( nObj==0,scn_[SCN_COL_REP],O_[OBJ_COL] ) + o_[ OBJ_TEXT ] := padc( alltrim( v_[VV_ID] ),v_[VV_F_LEN] ) + o_[ OBJ_COLOR ] := IF( empty( o_[OBJ_COLOR] ),cColor,o_[OBJ_COLOR] ) + o_[ OBJ_TO_ROW ] := IF( nObj==0,scn_[SCN_ROW_REP],o_[OBJ_TO_ROW] ) + o_[ OBJ_TO_COL ] := IF( nObj==0,scn_[SCN_COL_REP],o_[OBJ_COL] ) + ; + v_[VV_F_LEN]-1 + ENDIF + + o_[OBJ_SECTION] := scrSecCur( scn_,scn_[SCN_ROW_REP] ) + + IF nObj == 0 + aadd( obj_,o_ ) + nObj := len( obj_ ) + ELSE + obj_[nObj] := o_ + ENDIF + + scn_[SCN_OBJ_SELECTED] := 0 + scn_[SCN_REFRESH] := OBJ_REFRESH_LINE + scn_[SCN_MODE] := 0 + ENDIF + + RETURN nObj + +//----------------------------------------------------------------------// + +FUNCTION scrAddBox( obj_, scn_, nObj, Sel ) + LOCAL nKey,o_,border,cClr, nnObj, cFile + + DEFAULT Sel TO 0 + + nnObj := nObj + cFile := '' + border := ' '+chr( 255 ) + cClr := 'N/X ' + + IF nnObj == 0 + sel := 2 + + o_:= scrObjBlank() + + o_[ OBJ_TYPE ] := OBJ_O_BOX + o_[ OBJ_ROW ] := scn_[ SCN_ROW_REP ] + o_[ OBJ_COL ] := scn_[ SCN_COL_REP ] + o_[ OBJ_TO_ROW ] := scn_[ SCN_ROW_REP ] + o_[ OBJ_TO_COL ] := scn_[ SCN_COL_REP ] + o_[ OBJ_SECTION ] := scrSecCur( scn_, scn_[ SCN_ROW_REP ] ) + o_[ OBJ_F_LEN ] := 9 + o_[ OBJ_MDL_F_TYPE ]:= sel + 60 + + aadd( obj_, o_ ) + nObj := len( obj_ ) + ELSE + sel := obj_[ nObj, OBJ_MDL_F_TYPE ] - 60 + ENDIF + + IF sel == 2 + border := 'ÚÄ¿³ÙÄÀ³' // can be DOUBLE_SINGLE, etc + cClr := "w/b" + obj_[ nObj, OBJ_BORDER ] := 0.5 + ENDIF + + obj_[ nObj, OBJ_BOX_SHAPE ] := border + obj_[ nObj, OBJ_COLOR ] := cClr + obj_[ nObj, OBJ_ID ] := "Frame" + obj_[ nObj, OBJ_EQN ] := cFile + obj_[ nObj, OBJ_PATTERN ] := 'CLEAR ' + + IF nnObj == 0 .AND. sel <> 6 + scrMsg( 'Draw Frame WITH . Finish WITH ' ) + + DO WHILE .t. + nKey := inkey( 0 ) + DO CASE + CASE nKey == K_RIGHT .AND. sel <> 5 + IF scrMovRgt( scn_ ) + obj_[ nObj,OBJ_TO_COL ]++ + ENDIF + CASE nKey == K_LEFT .AND. sel <> 5 + IF scrMovLft( scn_ ) + obj_[ nObj,OBJ_TO_COL ]-- + ENDIF + CASE nKey == K_DOWN .AND. sel <> 4 + IF scrMovDn( scn_ ) + obj_[ nObj,OBJ_TO_ROW ]++ + ENDIF + CASE nKey == K_UP .AND. sel <> 4 + IF scrMovUp( scn_ ) + obj_[ nObj,OBJ_TO_ROW ]-- + ENDIF + CASE nKey == K_ENTER + EXIT + ENDCASE + scrMove( obj_,scn_ ) + scrStatus( obj_,scn_ ) + ENDDO + ENDIF + + scrOrdObj( obj_ ) + scrMsg() + scn_[SCN_REFRESH] := OBJ_REFRESH_ALL + RETURN NIL + +//----------------------------------------------------------------------// + +STATIC FUNCTION scrSetChild( /*scn_*/ ) + RETURN .f. + +//----------------------------------------------------------------------// + +FUNCTION scrAddExp( /*obj_,scn_,nObj*/ ) + RETURN NIL + +//----------------------------------------------------------------------// + +FUNCTION scrAddFld( obj_,scn_,nObj ) + + HB_SYMBOL_UNUSED( obj_ ) + HB_SYMBOL_UNUSED( nObj ) + + DO CASE + CASE scn_[SCN_DESIGN] == DGN_MODULE + scrMdlFld( obj_, scn_, nObj ) + ENDCASE + + RETURN NIL + +//----------------------------------------------------------------------// + +FUNCTION scrAddTxt( obj_,scn_,nKey,nMode ) + LOCAL txt_:={},n, lClub,i + LOCAL n1,s1,s2,nTxt,nDel + LOCAL nRepCol := scn_[SCN_COL_REP], nRepRow := scn_[SCN_ROW_REP] + LOCAL lOrder := .f. + // nMode 1.Add 2.Del 3.BS + + // Scan obj_ FOR Text Objects Related WITH Current Report Row + aeval( obj_,{|e_| iif( e_[ OBJ_TYPE ] == OBJ_O_TEXT .AND. e_[ OBJ_ROW ] == nRepRow, aadd( txt_,e_ ),'' ) } ) + IF nMode == 1 // New Character + IF empty( txt_ ) .OR. ascan( txt_,{|e_| inRange( nRepCol, e_[OBJ_COL],e_[OBJ_TO_COL] ) } ) == 0 + aadd( txt_, scrObjBlank() ) ; lOrder := .t. + nTxt := len( txt_ ) + txt_[ nTxt, OBJ_TYPE ] := OBJ_O_TEXT + txt_[ nTxt, OBJ_F_TYPE ] := 'C' + txt_[ nTxt, OBJ_F_LEN ] := 1 + txt_[ nTxt, OBJ_ALIGN ] := 'L' + txt_[ nTxt, OBJ_ROW ] := scn_[SCN_ROW_REP] + txt_[ nTxt, OBJ_COL ] := scn_[SCN_COL_REP] + txt_[ nTxt, OBJ_EQN ] := '' + txt_[ nTxt, OBJ_ID ] := 'Text' + txt_[ nTxt, OBJ_COLOR ] := 'N/W' + txt_[ nTxt, OBJ_PITCH ] := 10 + txt_[ nTxt, OBJ_SECTION ] := scrSecCur( scn_,scn_[SCN_ROW_REP] ) + txt_[ nTxt, OBJ_TO_ROW ] := scn_[SCN_ROW_REP] + txt_[ nTxt, OBJ_TO_COL ] := scn_[SCN_COL_REP] + ENDIF + ENDIF + + nTxt := ascan( txt_,{|e_| inRange( nRepCol, e_[ OBJ_COL ], e_[ OBJ_TO_COL ] ) } ) + + IF nMode == 1 + txt_[nTxt,OBJ_EQN] := substr( txt_[nTxt,OBJ_EQN],1,; + scn_[SCN_COL_REP]-txt_[nTxt,OBJ_COL] ) + ; + chr( nKey ) + ; + substr( txt_[nTxt,OBJ_EQN],scn_[SCN_COL_REP]-txt_[nTxt,OBJ_COL] + ; + IF( ReadInsert(),1,2 ) ) + txt_[nTxt,OBJ_TO_COL] := txt_[nTxt,OBJ_COL]+len( txt_[nTxt,OBJ_EQN] )-1 + + ELSEIF nMode == 2 .OR. nMode == 3 // Delete + IF readInsert() + txt_[nTxt,OBJ_EQN] := substr( txt_[nTxt,OBJ_EQN],1,; + scn_[SCN_COL_REP]-txt_[nTxt,OBJ_COL] ) + ; + substr( txt_[nTxt,OBJ_EQN],scn_[SCN_COL_REP]-txt_[nTxt,OBJ_COL] + 2 ) + txt_[nTxt,OBJ_TO_COL] := txt_[nTxt,OBJ_COL]+len( txt_[nTxt,OBJ_EQN] )-1 + ELSE // Divide it IN two objects + s1 := substr( txt_[nTxt,OBJ_EQN],1,scn_[SCN_COL_REP]-txt_[nTxt,OBJ_COL] ) + s2 := substr( txt_[nTxt,OBJ_EQN],scn_[SCN_COL_REP]-txt_[nTxt,OBJ_COL] + 2 ) + nDel := 0 + IF len( s1 ) > 0 + txt_[nTxt,OBJ_EQN] := s1 + txt_[nTxt,OBJ_TO_COL] := txt_[nTxt,OBJ_COL]+len( s1 )-1 + txt_[nTxt,OBJ_PRN_LEN] := len( s1 ) + ELSE + nDel := nTxt + ENDIF + + IF len( s2 ) > 0 + IF nDel == 0 + aadd( txt_,aclone( txt_[nTxt] ) ) // scrObjBlank() ) + lOrder := .t. + n1 := len( txt_ ) + ELSE + n1 := nDel + ENDIF + txt_[n1,OBJ_TYPE] := OBJ_O_TEXT + txt_[n1,OBJ_F_TYPE] := 'C' + txt_[n1,OBJ_F_LEN] := len( s2 ) + txt_[n1,OBJ_PRN_LEN] := len( s2 ) + // txt_[n1,OBJ_ALIGN] := 'L' + txt_[n1,OBJ_ROW] := scn_[SCN_ROW_REP] + txt_[n1,OBJ_COL] := scn_[SCN_COL_REP]+1 + txt_[n1,OBJ_EQN] := s2 + txt_[n1,OBJ_ID] := 'Text' + txt_[n1,OBJ_SECTION] := scrSecCur( scn_,scn_[SCN_ROW_REP] ) + txt_[n1,OBJ_TO_ROW] := scn_[SCN_ROW_REP] + txt_[n1,OBJ_TO_COL] := txt_[n1,OBJ_COL]+len( s2 )-1 + ENDIF + IF len( s1 )==0.AND.len( s2 )==0 + aShrink( txt_,nTxt ) + IF empty( txt_ ) + aadd( txt_,scrObjBlank() ) + ENDIF + ENDIF + ENDIF + ENDIF + + IF !empty( txt_ ) + DO WHILE .t. + IF( n := ascan( txt_,{|e_| e_[OBJ_TO_COL] < e_[OBJ_COL] } ) ) > 0 + aShrink( txt_,n ) + ELSE + EXIT + ENDIF + ENDDO + IF empty( txt_ ) + aadd( txt_,scrObjBlank() ) + ENDIF + // CLUB DIFFERENT TEXT OBJECTS IF THESE ARE ADJACENT + asort( txt_,,,{|e_,f_| e_[OBJ_COL] 0 + aShrink( obj_,n ) + IF empty( obj_ ) + aadd( obj_, scrObjBlank() ) + ENDIF + ELSE + EXIT + ENDIF + ENDDO + + aeval( txt_,{|e_| IF( e_[OBJ_ROW]>0,aadd( obj_,e_ ),'' ) } ) // Now attach txt_ + + DO WHILE .t. + IF( n := ascan( obj_,{|e_| e_[OBJ_TO_COL] < e_[OBJ_COL] } ) ) > 0 + aShrink( obj_,n ) + IF empty( obj_ ) + aadd( obj_,scrObjBlank() ) + ENDIF + ELSE + EXIT + ENDIF + ENDDO + + IF lOrder + // scrOrdObj( obj_ ) + ENDIF + IF nMode == 1 + keyboard( chr( K_RIGHT ) ) + ENDIF + + scn_[SCN_REFRESH] := OBJ_REFRESH_LINE + + RETURN NIL + +//----------------------------------------------------------------------// + +FUNCTION ScrGrid( grd_ ) + + RETURN grd_ + +//----------------------------------------------------------------------// + +FUNCTION scrSecCur( scn_,nRepRow ) // Numeric id of sector + LOCAL n,i + n := 0 + FOR i := 1 TO len( scn_[SCN_SECTORS_] ) + n += scn_[SCN_SECTORS_,i,SCT_ROWS] + IF nRepRow <= n +// n1 := i + EXIT + ENDIF + NEXT + RETURN scn_[SCN_SECTORS_,i,SCT_ORDER] + +//----------------------------------------------------------------------// + +FUNCTION scrSecOrd( scn_,nRepRow ) // Index of sector + LOCAL n,n1,i + n := 0 + FOR i := 1 TO len( scn_[SCN_SECTORS_] ) + n += scn_[SCN_SECTORS_,i,SCT_ROWS] + IF nRepRow <= n + n1 := i + EXIT + ENDIF + NEXT + RETURN n1 + +//----------------------------------------------------------------------// + +FUNCTION scrSecRow( scn_,nRepRow ) // Row position IN sector + LOCAL n,n1,i + n := 0 ; n1 := 0 + FOR i := 1 TO len( scn_[SCN_SECTORS_] ) + n += scn_[SCN_SECTORS_,i,SCT_ROWS] + IF nRepRow <= n + n1 := nRepRow -( n - scn_[SCN_SECTORS_,i,SCT_ROWS] ) + EXIT + ENDIF + NEXT + RETURN n1 + +//----------------------------------------------------------------------// + +FUNCTION scrExp( eqn /*,cType*/ ) + RETURN eqn + +//----------------------------------------------------------------------// + +FUNCTION scrMsg( msg ) + LOCAL row := row(), col := col() + + @ maxrow(),0 SAY padc( " ", maxcol()+1 ) COLOR "W+/W" + IF empty( msg ) + msg := "F1 Help F5 Edit F6 Select F7 Copy F8 Paste F9 Box F10 Field" + ENDIF + msg := " " + msg + " " + @ maxrow(),( maxcol()+1-len( msg ) )/2 SAY msg COLOR "W+/B" + + setPos( row,col ) + RETURN NIL + +//----------------------------------------------------------------------// + +FUNCTION scrEqnGen( /*obj_,scn_,nObj,cType,cMsg*/ ) + RETURN "" + +//----------------------------------------------------------------------// + +FUNCTION scrInkey( key_ ) + LOCAL nKey + + DO WHILE .t. + nKey := inkey( 0 ) + IF ascan( key_,nKey )>0 + EXIT + ENDIF + ENDDO + + RETURN nKey + +//----------------------------------------------------------------------// + +FUNCTION scrConfig( obj_, nDgn, sct_ ) + LOCAL s, n, nRows, nCols + LOCAL cor_:={ { 1, 0, maxrow()-2, maxcol(), 200, 400 } } + LOCAL scn_:= array( SCN_NUM_VAR ) + + scn_[ SCN_SECTORS_ ] := {} + scn_[ SCN_DESIGN ] := nDgn + scn_[ SCN_FOR_ROWS ] := { { 0,'' } } + + nRows := scrSectors( obj_, scn_, nDgn, sct_ ) + + nCols := 0 + aeval( obj_, {|e_| nCols := max( nCols, e_[ OBJ_TO_COL ] ) } ) + nCols := IF( nCols == 0, cor_[ nDgn,4 ], nCols ) + + scn_[ SCN_TOP ] := cor_[ nDgn,1 ] + scn_[ SCN_LEFT ] := cor_[ nDgn,2 ] + scn_[ SCN_BOTTOM ] := cor_[ nDgn,3 ] + scn_[ SCN_RIGHT ] := cor_[ nDgn,4 ] + scn_[ SCN_MODE ] := 0 + scn_[ SCN_ROW_CUR ] := scn_[ SCN_TOP ] // 9 + scn_[ SCN_COL_CUR ] := scn_[ SCN_LEFT ] + scn_[ SCN_ROW_REP ] := 1 + scn_[ SCN_COL_REP ] := 1 + scn_[ SCN_ROW_DIS ] := scn_[ SCN_TOP ]-1 + scn_[ SCN_COL_DIS ] := scn_[ SCN_LEFT ]-1 + + scn_[ SCN_ROW_MENU ] := 0 + scn_[ SCN_ROW_RULER ] := 0 + scn_[ SCN_STATUS_ROW ] := maxrow()-1 + scn_[ SCN_STATUS_COL ] := 0 + scn_[ SCN_STATUS_COL_TO] := maxcol() + + scn_[ SCN_COL_MAX ] := iif( nDgn==DGN_SCREEN .OR. nDgn==DGN_MODULE, cor_[nDgn,6], nCols ) + scn_[ SCN_ROW_PREV ] := scn_[ SCN_TOP ] + scn_[ SCN_COL_PREV ] := scn_[ SCN_LEFT ] + scn_[ SCN_REP_LINES ] := iif( nDgn==DGN_SCREEN .OR. nDgn==DGN_MODULE, cor_[ nDgn,5 ], nRows ) + + scn_[ SCN_CLR_STATUS ] := "W+/BG" // 'W/B' + scn_[ SCN_CLR_TEXT ] := 'W+/B' + scn_[ SCN_CLR_BOX ] := 'W/B' + scn_[ SCN_CLR_FIELD ] := CLR_GET + scn_[ SCN_CLR_HILITE ] := iif( wvt(),'N/GR*','GR+/BG' ) + scn_[ SCN_CLR_WINDOW ] := 'W+/BG' + scn_[ SCN_CLR_RULER ] := "N/W" //'W/B' + scn_[ SCN_CLR_MENU ] := "W+/B" //'W+/W' + scn_[ SCN_CLR_OVERALL ] := "N/W" + scn_[ SCN_CLR_PREV ] := iif( wvt(), 'B/W' , 'B/W' ) + scn_[ SCN_CLR_SELECT ] := iif( wvt(), 'N/W*', 'GR+/N' ) + + scn_[ SCN_OBJ_HILITE ] := 0 // 32 + scn_[ SCN_OBJ_SELECTED ] := 0 // 33 + + s := '.' + FOR n := 1 TO 40 + s += '.......' + strtran( str( n,3 ), ' ', '.' ) + NEXT + scn_[ SCN_RULER ] := s + + scn_[ SCN_DRAW_FILL ] := '±±±±±±±±±' + scn_[ SCN_OBJ_ID_ ] := { 'Bitmap','Line','Text','Field','Expression','BitMap' } + scn_[ SCN_REFRESH ] := OBJ_REFRESH_ALL + scn_[ SCN_OBJ_COPIED ] := 0 + scn_[ SCN_BOX_SHAPE ] := 'ÚÄ¿³ÙÄÀ³' + scn_[ SCN_CHR_PREV ] := '' + scn_[ SCN_DESIGN_ID ] := "Module" + scn_[ SCN_FILE ] := "Untitled" + scn_[ SCN_PROPERTY ] := {} + scn_[ SCN_GRAPHICS ] := .f. + scn_[ SCN_TEXT_BLOCK_ ] := {} + scn_[ SCN_FIELDS ] := {} + scn_[ SCN_LASTKEY ] := 0 + + RETURN scn_ + +//----------------------------------------------------------------------// + +FUNCTION scrWvtConfig( obj_, scn_ ) + LOCAL nRows,nCols + LOCAL cor_:={ { 1, 0, maxrow()-2, maxcol(), 200, 400 } } + LOCAL nDgn := scn_[ SCN_DESIGN ] + + nRows := 0 + aeval( scn_[ SCN_SECTORS_ ], {|e_| nRows += e_[ SCT_ROWS ] } ) + + nCols := 0 + aeval( obj_, {|e_| nCols := max( nCols,e_[ OBJ_TO_COL ] ) } ) + nCols := IF( nCols == 0, cor_[ nDgn,4 ], nCols ) + + scn_[ SCN_TOP ] := cor_[ nDgn,1 ] + scn_[ SCN_LEFT ] := cor_[ nDgn,2 ] + scn_[ SCN_BOTTOM ] := cor_[ nDgn,3 ] + scn_[ SCN_RIGHT ] := cor_[ nDgn,4 ] + scn_[ SCN_STATUS_ROW ] := maxrow()-1 + scn_[ SCN_STATUS_COL ] := 0 + scn_[ SCN_STATUS_COL_TO ] := maxcol() + scn_[ SCN_MODE ] := 0 + scn_[ SCN_ROW_CUR ] := scn_[ SCN_TOP ] + scn_[ SCN_COL_CUR ] := scn_[ SCN_LEFT ] + scn_[ SCN_ROW_REP ] := 1 + scn_[ SCN_COL_REP ] := 1 + scn_[ SCN_ROW_DIS ] := scn_[ SCN_TOP ]-1 + scn_[ SCN_COL_DIS ] := scn_[ SCN_LEFT ]-1 + scn_[ SCN_ROW_RULER ] := 0 + scn_[ SCN_ROW_MENU ] := 0 + scn_[ SCN_COL_MAX ] := cor_[ nDgn, 6 ] + scn_[ SCN_ROW_PREV ] := scn_[ SCN_TOP ] + scn_[ SCN_COL_PREV ] := scn_[ SCN_LEFT ] + scn_[ SCN_REP_LINES ] := cor_[ nDgn, 5 ] + + RETURN NIL + +//----------------------------------------------------------------------// + +STATIC FUNCTION scrSectors( obj_,scn_,nDgn /*,sct_*/ ) + LOCAL nRows + + HB_SYMBOL_UNUSED( obj_ ) + + IF nDgn == DGN_MODULE .OR. nDgn == DGN_SCREEN + aadd( scn_[ SCN_SECTORS_ ], { 1,'Screen', 'R ', 100, 'w+/bg', '', .f., .f. } ) + nRows := 100 + ENDIF + + RETURN nRows + +//----------------------------------------------------------------------// + +STATIC FUNCTION scrAddPrp( scn_,sct_ ) + aadd( scn_[SCN_SECTORS_], ; + {sct_[1],sct_[2],sct_[3],sct_[4],sct_[5],sct_[6],sct_[7],sct_[8]} ) + RETURN NIL + +//----------------------------------------------------------------------// + +FUNCTION scrPicture( cType,nWidth,nDec,cPic,nScrWid ) + + DO CASE + CASE cType == 'N' + cPic := '@Z '+replicate( '9',nScrWid-IF( nDec>0,nDec+1,0 ) )+; + IF( nDec>0,'.'+replicate( '9',nDec ),'' ) + CASE cType == 'C' + IF nScrWid <> nWidth + cPic := '@'+IF( '!' $ cPic,'!','' )+'S'+NTRIM( nScrWid ) + ENDIF + ENDCASE + + RETURN cPic + +//----------------------------------------------------------------------// + +FUNCTION inRange( v,r1,r2 ) + RETURN( v >= r1 .AND. v <= r2 ) + +/*----------------------------------------------------------------------*/ + +FUNCTION help( cToken ) + + DO CASE + CASE cToken == "this" + + ENDCASE + + RETURN NIL + +/*----------------------------------------------------------------------*/ + +FUNCTION arview() + RETURN NIL + +/*----------------------------------------------------------------------*/ + +FUNCTION pad_max( a_,lNum,max ) + LOCAL i := 1 + DEFAULT lNum TO .f. + IF max == NIL + max := 0 + aeval( a_, {|x| max := max( max,len( x ) )} ) + ENDIF + aeval( a_, {|x| a_[ i ] := iif( lNum, str( i,3 ) + ' ', '' ) + pad( x,max ), i++ } ) + RETURN a_ + +/*----------------------------------------------------------------------*/ + +FUNCTION VouchInArray( v,a_ ) + RETURN( ascan( a_,{|e| e = v } ) > 0 ) + +//----------------------------------------------------------------------// + +FUNCTION aShrink( a_,n ) + IF n > 0 + adel( a_,n ) + asize( a_,len( a_ )-1 ) + ENDIF + RETURN a_ + +//----------------------------------------------------------------------// + +FUNCTION uiDebug( ... ) + LOCAL a_:= hb_aParams() + LOCAL s := "", x + + FOR EACH x IN a_ + s += xtos( x ) + " " + NEXT + + WAPI_OutputDebugString( s ) + + RETURN NIL + +/*----------------------------------------------------------------------*/ + +FUNCTION setGetAch( v_ ) + LOCAL lCrt + THREAD STATIC sCrt := {} + lCrt := sCrt + IF hb_isArray( v_ ) + sCrt := v_ + ENDIF + RETURN lCrt + +/*----------------------------------------------------------------------*/ + +FUNCTION SetOCrt( oCrt ) + LOCAL lCrt + THREAD STATIC sCrt + lCrt := sCrt + IF hb_isObject( oCrt ) + sCrt := oCrt + ENDIF + RETURN lCrt + +/*----------------------------------------------------------------------*/ + +FUNCTION SetMTBrowser( lYes ) + LOCAL l_Yes + THREAD STATIC s_Yes := .f. + l_yes := s_Yes + IF valtype( lYes ) == 'L' + s_Yes := lYes + ENDIF + RETURN l_Yes + +/*----------------------------------------------------------------------*/ + +FUNCTION SetMTModule( lYes ) + LOCAL l_Yes + THREAD STATIC s_Yes := .f. + l_yes := s_Yes + IF valtype( lYes ) == 'L' + s_Yes := lYes + ENDIF + RETURN l_Yes + +/*----------------------------------------------------------------------*/ + +FUNCTION Vou_CreateOCrt( nT, nL, nB, nR, cTitle, xIcon, lModal, lRowCols, lHidden, ; + lCenter, nRow, nCol, lNoTitleBar ) + LOCAL oCrt, aPos + + DEFAULT cTitle TO 'Info' + DEFAULT xIcon TO "" + DEFAULT lModal TO .T. + DEFAULT lHidden TO .F. + DEFAULT lCenter TO .F. + DEFAULT lNoTitleBar TO .F. + + IF hb_isObject( SetOCrt() ) + SetOCrt():toFront() + ENDIF + + aPos := iif( lCenter, {-1,-1}, iif( nRow == NIL, { nT, nL }, { nRow,nCol } ) ) + + oCrt := WvgCrt():new( , , aPos, { nB - nT, nR - nL }, , .f. ) + oCrt:resizable := lRowCols + oCrt:lModal := lModal + IF lRowCols + oCrt:resizeMode := HB_GTI_RESIZEMODE_ROWS + ENDIF + oCrt:CREATE() + oCrt:cargo := GetCrtCargoSlots() + oCrt:cargo[ 5 ] := oCrt:resizable + + SetCursor( 0 ) + + IF hb_isNumeric( xIcon ) + hb_gtInfo( HB_GTI_ICONRES, xIcon ) + ELSE + IF( '.ico' $ lower( xIcon ) ) + hb_gtInfo( HB_GTI_ICONFILE, xIcon ) + ELSE + IF ! empty( xIcon ) + hb_gtInfo( HB_GTI_ICONRES, xIcon ) + ENDIF + ENDIF + ENDIF + + hb_gtInfo( HB_GTI_WINTITLE, cTitle ) + + SetColor( 'N/W' ) + CLS + IF !( lHidden ) + oCrt:showWindow() + ENDIF + + RETURN oCrt + +/*----------------------------------------------------------------------*/ + +FUNCTION Vou_DestroyOCrt( oCrt, oOCrt ) + + oCrt:destroy() + SetOCrt( oOCrt ) + #IF 0 + IF hb_isObject( oOCrt ) + //oOCrt:setFocus() + ENDIF + #ENDIF + RETURN NIL + +/*----------------------------------------------------------------------*/ + +FUNCTION VouchWndSave( t, l, b, r, lBmp ) + LOCAL wnd_,crs,a_ + + crs := mSetCursor( .f. ) + DEFAULT t TO 0, ; + l TO 0, ; + b TO maxrow(), ; + r TO maxcol() + + IF lBmp <> NIL + a_:= Wvt_SaveScreen( t,l,b,r ) + ENDIF + wnd_:= { t, l, b, r, saveScreen( t,l,b,r ), a_ } + + mSetCursor( crs ) + + RETURN wnd_ + +//----------------------------------------------------------------------// + +FUNCTION VouchWndRest( wnd_, lDoNotDestroyBMP ) + LOCAL crs, bError + + bError := errorblock( {|oErr| Break( oErr ) } ) + BEGIN SEQUENCE + crs := mSetCursor( .f. ) + + RestScreen( wnd_[1], wnd_[2], wnd_[3], wnd_[4], wnd_[5] ) + + IF wnd_[ 6 ] <> NIL + DEFAULT lDoNotDestroyBMP TO .f. + + Wvt_RestScreen( wnd_[ 1 ], wnd_[ 2 ], wnd_[ 3 ], wnd_[ 4 ], wnd_[ 6 ], lDoNotDestroyBMP ) + ENDIF + mSetCursor( crs ) + END + errorblock( bError ) + + RETURN NIL + +//----------------------------------------------------------------------// + +FUNCTION Wvt() + RETURN .T. + +/*----------------------------------------------------------------------*/ + +#define CGO_POS 1 +#define CGO_ROW 2 +#define CGO_LSEL 3 +#define CGO_LNUM 4 +#define CGO_CH_ 5 +#define CGO_SEL_ 6 +#define CGO_EXE_ 7 +#define CGO_SCROL 8 +#define CGO_LENSCR 9 + +FUNCTION VouchGetArray( h_,vv_, sel_, nTop, nLft, nBtm, nRgt, title, bWhen_, bValid_, pic_, hlp, ord_ ) + LOCAL i, nSel, maxL, mLen, oCrt, oOCrt + LOCAL nLenVrb, clr1, s, cTyp + LOCAL nLastKey,cgo_, aScrol_,nLenMnu,pmt_:={} + LOCAL nMaxCol := max( maxcol(), 79 ) + LOCAL nMaxRow := max( maxrow(), 24 ) + + HB_SYMBOL_UNUSED( hlp ) + HB_SYMBOL_UNUSED( ord_ ) + + IF h_== NIL .OR. valtype( h_ )<>'A' .OR. vv_== NIL .OR. valtype( vv_ )<>'A' + RETURN {vv_, 0} + ENDIF + + IF bWhen_ == NIL + bWhen_:= afill( array( len( vv_ ) ), {|| .t. } ) + FOR i := 1 TO len( vv_ ) + s := h_[i] + IF valtype( vv_[i] ) == 'L' + bWhen_[i] := {|| VouchYN( s,oGet() ),.f. } + ENDIF + NEXT + ENDIF + + IF bValid_ == NIL + bValid_:= afill( array( len( vv_ ) ),{|| .t. } ) + ENDIF + + IF pic_ == NIL + pic_:= array( len( vv_ ) ) + FOR i := 1 TO len( vv_ ) + cTyp := valtype( vv_[i] ) + pic_[i] := IF( cTyp=="C","@ ",IF( cTyp=="N","@Z 99999999.999",IF( cTyp=="L","Y","@ " ) ) ) + NEXT + ENDIF + + nLenVrb := 0 + aeval( vv_, {|e| cTyp := valtype( e ), nLenVrb := max( ; + IF( cTyp == 'C', len( e ), ; + IF( cTyp=='N', 15, IF( cTyp=='D',8,3 ) ) ), nLenVrb ) } ) + pmt_:={} + aeval( h_,{|e,i| aadd( pmt_, e + " {"+xtos( vv_[i] )+ "}" ) } ) + + // decide maximum length of the largest prompt + mLen := 0 + aeval( pmt_, {|x| mLen := max( mLen, len( x ) ) } ) + mLen := max( len( h_[1] )+2+nLenVrb, mLen )+2 + + IF nTop == NIL + nTop := int( ( nMaxrow - min( IF( wvt(),2,3 ) + len( h_ ), nMaxRow-3 ) ) / 2 ) + ENDIF + IF nBtm == NIL + nBtm := min( nTop + len( h_ ) + IF( wvt(),2,3 ), nMaxRow-3 ) + ENDIF + nTop := max( nTop, 2 ) + + IF nLft == NIL + nLft := max( 4, int( ( nMaxCol - min( 2+mLen, nMaxCol-8 ) ) / 2 ) ) + ENDIF + + nLft := 2 + nRgt = min( nLft+2+mLen+2, nMaxCol-2 ) + + IF title == NIL .OR. empty( title ) + title = "Untitled" + ELSE + title := alltrim( title ) + ENDIF + title := padc( title, nRgt - nLft ) + title := { title, replicate( chr( 196 ), len( title ) + 2 ) } + maxL := len( h_[ 1 ] ) + sel_ := IF( sel_ == NIL,.t., sel_ ) + + setcursor( 0 ) + + B_CRT nTop,nLft,nBtm,nRgt MODAL TITLE alltrim( title[ 1 ] ) INTO oCrt + oOCrt := SetOCrt( oCrt ) + + nBtm -= nTop; nRgt -= nLft; nTop := 0; nLft := 0 + + SetColor( 'b+/w*, w+/b*,,, n+/w*' ) + + aScrol_ := ScrolBarNew( nTop+1, nRgt, nBtm, "B+/W" ) + DispBox( nTop, nLft, nBtm, nRgt, ' ', 'N/W' ) + + Wvg_BoxRecessed( nTop+2,nLft+2,nBtm-1,nRgt-2 ) + Wvt_SetPen( 2, 0, VouchRgb( 225,225,225 ) ) + Wvg_Object( GOBJ_OBJTYPE_GRIDHORZ, {|| { nTop+3, nLft+2, nRgt-2, nBtm-( nTop+2 ) } } ) + + nLenMnu := len( pmt_ ) + clr1 := setColor() + + ScrolBarDisplay( aScrol_ ) + ScrolBarUpdate( aScrol_, 1, nLenMnu, .t. ) + + cgo_:= { 1, 0, .f., .f., pmt_, sel_,/*exe_*/, aScrol_, nLenMnu } + + SetGetAch( vv_ ) // Put on stack FOR aChPut(), aChGet() + + DO WHILE .t. + setColor( clr1 ) + + pmt_:= {} + aeval( h_, {|e,i| aadd( pmt_, e+" {"+xtos( vv_[i] )+"}" ) } ) + cgo_[ CGO_CH_ ] := pmt_ + + clear typeahead + + nSel := VouchAChoice( nTop+IF( wvt(),2,3 ),nLft+1+IF( wvt(),1,0 ),nBtm-1,nRgt-1-IF( wvt(),1,0 ), ; + cgo_[CGO_CH_], cgo_[CGO_SEL_], "VouchFunc1", ; + cgo_[CGO_POS], cgo_[CGO_ROW],/* oWin */, @nLastKey, cgo_ ) + + IF nLastKey == K_ENTER + vv_[ nSel ] := VouchGetChoice( vv_[ nSel ], nTop + cgo_[ CGO_ROW ] + IF( wvt(),2,3 ), ; + nLft + maxL + 1, nRgt-IF( wvt(),2,1 ), bWhen_[ nSel ], ; + bValid_[ nSel ], pic_[ nSel ] ) + ELSEIF nLastKey == K_F10 + EXIT + ELSEIF nLastKey == K_ESC + EXIT + ELSEIF nLastKey == K_CTRL_ENTER + EXIT + ELSEIF nLastKey == K_CTRL_END + EXIT + ENDIF + ENDDO + + Vou_DestroyOCrt( oCrt,oOCrt ) + + RETURN{ vv_, nSel } + +//----------------------------------------------------------------------// + +FUNCTION VouchFunc1( mode, nElem, nRow, nKey, cgo_ ) + LOCAL ret := AC_CONT + + IF nKey <> 0 + ScrolBarUpdate( cgo_[CGO_SCROL], nElem, cgo_[CGO_LENSCR], .t. ) + ENDIF + + cgo_[CGO_POS] := nElem + cgo_[CGO_ROW] := nRow + + DO CASE + CASE mode == AC_IDLE + CASE mode == AC_HITTOP + //NannyBoo + CASE mode == AC_HITBOTTOM + //Charge + CASE mode == AC_NOITEM + ret := AC_ABORT + OTHERWISE + DO CASE + CASE nKey == K_CTRL_END + ret := AC_SELECT + CASE nKey == K_ENTER + ret := AC_SELECT + CASE nKey == K_CTRL_ENTER + ret := AC_SELECT + CASE nKey == K_F10 + ret := AC_SELECT + CASE nKey == K_ESC + ret := AC_ABORT + CASE nKey > 31 .AND. nKey < 123 + cgo_[CGO_POS] := scan_ff( cgo_[CGO_POS], cgo_[CGO_CH_], chr( nKey ), 3 ) + RETURN AC_ABORT + ENDCASE + ENDCASE + + RETURN ret + +//----------------------------------------------------------------------// + +STATIC FUNCTION scan_ff( elem, a_, c /*, nFrom */ ) + LOCAL na, nlen + + c := lower( substr( c,1,1 ) ) + nLen := len( c ) + IF( na := ascan( a_,{|e| lower( substr( ltrim( e ),1,nLen ) ) == c }, min( elem+1, len( a_ ) ) ) ) == 0 + na := ascan( a_,{|e| lower( substr( ltrim( e ),1,nlen ) ) == c },1,elem-1 ) + ENDIF + + RETURN iif( na == 0, elem, na ) + +//----------------------------------------------------------------------// + +STATIC FUNCTION VouchGetChoice( vrb, row, col, e_col, whn, vld, pic ) + LOCAL scr, maxL, n_vrb, dec, r, c, r1, c1, crs, clr + LOCAL type := valtype( vrb ) + LOCAL getlist := {} + + IF type == "N" + n_vrb := str( vrb ) + maxL := len( n_vrb ) + dec := at( ".", n_vrb ) + IF pic == NIL + IF dec > 0 + pic := replicate( "9", maxL -( maxL - dec ) - 1 ) + "." + ; + replicate( "9", maxL - dec ) + ELSE + pic := replicate( "9", maxL ) + ENDIF + ENDIF + ELSEIF type == "D" + maxL := 8 + pic := "" + ELSEIF type == "L" + maxL := 1 + pic := "Y" + ELSEIF type == "C" + maxL := len( vrb ) + pic := "@K" + IF( maxL + col ) > e_col + maxL := e_col -( col+1 ) + pic := pic + "S" + ltrim( str( maxL ) ) + ENDIF + ENDIF + + r := row + c := col + r1 := r + c1 := e_col + + scr := VouchWndSave( r-1, c-1, r1, c1 ) + + IF wvt() + SetPaint( 'GET_ACH',3,{|| Wvt_DrawBoxGet( r, c+2, maxL ) } ) + clr := SetColor( 'W+/W*,N/GR*,,,W/GR*' ) + dispOutAt( r, c+1, space( c1-c ), 'W+/W*' ) + ELSE + @ r, c clear TO r1, c1 + ENDIF + + crs := setcursor( 1 ) + @ r, c+1+IF( Wvt(),1,0 ) get vrb when whn() valid vld() picture pic + atail( getlist ):cargo := { whn,vld } + read + setcursor( crs ) + SetColor( clr ) + + IF wvt() + DelPaint( 'GET_ACH',3 ) + ENDIF + + VouchWndRest( scr ) + RETURN vrb + +//----------------------------------------------------------------------// + +STATIC FUNCTION ScrolBarUpdate() + RETURN NIL + +/*----------------------------------------------------------------------*/ + +STATIC FUNCTION ScrolBarDisplay() + RETURN NIL + +/*----------------------------------------------------------------------*/ + +STATIC FUNCTION ScrolBarNew() + RETURN NIL + +/*----------------------------------------------------------------------*/ + +STATIC FUNCTION whn() + RETURN eval( getActive():cargo[1] ) + +//----------------------------------------------------------------------// + +STATIC FUNCTION vld() + RETURN eval( getActive():cargo[2] ) + +//----------------------------------------------------------------------// + +STATIC FUNCTION oAchGet( n ) + RETURN setGetAch()[n] + +//----------------------------------------------------------------------// + +STATIC FUNCTION oAchPut( n,v ) + setGetAch()[n] := v + RETURN .t. + +//----------------------------------------------------------------------// + +STATIC FUNCTION oCPut( v ) + getactive():varPut( v ) + RETURN .t. + +//----------------------------------------------------------------------// + +STATIC FUNCTION oGet() + RETURN getActive():varGet() + +//----------------------------------------------------------------------// + +FUNCTION VouchGetSome( msg, vrb, pass, pic, set_, wh, vl, nLastKey ) + LOCAL nMaxLen, nLenMsg, nLenVrb, r, oldCrt, oCrt, l + LOCAL t := maxrow()-7 + LOCAL b := maxrow()-3 + LOCAL GetList := {} + LOCAL dType := valtype( vrb ) + + DEFAULT msg TO 'Please Enter Required Value' + DEFAULT wh TO {|| .t. } + DEFAULT vl TO {|| .t. } + DEFAULT pass TO .f. + DEFAULT pic TO IF( dType == 'Y', 'Y', '@! ' ) + + IF set_<> NIL + msg += ' ' + ENDIF + + nMaxLen := 90 + nLenMsg := len( msg ) + + DO CASE + CASE dType == 'D' ; nLenVrb := 8 + CASE dType == 'N' ; nLenVrb := 17 // len( str( vrb ) ) + CASE dType == 'C' ; nLenVrb := len( vrb ) + CASE dType == 'L' ; nLenVrb := 1 + ENDCASE + + IF nLenMsg + nLenVrb > nMaxLen // Only when vrb type c will be asked + nLenVrb := nMaxLen - nLenMsg - 7 + pic := substr( pic,1,1 )+'S'+NTRIM( nLenVrb )+substr( pic,2 ) + ENDIF + + pic := IF( dType=='N', '@Z 999999999999.9999', IF( !pass, pic, strtran( pic,'!','' ) ) ) + l := IF( maxcol() > nLenMsg+nLenVrb+6,( ( maxcol()+1 -( nLenMsg + nLenVrb + 7 ) ) / 2 ), 0 ) + r := l + nLenMsg+nLenVrb + 6 + + /* REQUEST New Window */ + B_CRT t,l,b,r MODAL TITLE ' Info Required!' ICON 'EXCLAIM' INTO oCrt + oldCrt := SetOCrt( oCrt ) + + b -= t + r -= l + t := 0 + l := 0 + + IF !pass + setcolor( 'GR+/B,N/GR*, , ,N/GR*' ) + ELSE + setcolor( 'GR+/B,GR+/GR*, , ,N/GR*' ) + ENDIF + + Wvg_BoxRecessed( t+2, l+3+nlenMsg+1, t+2, l+3+nlenMsg+nLenVrb ) + DispBox( t, l, b, r, ' ', 'N/B' ) + oCrt:refresh() + + IF nLastKey <> NIL + KeyBoard( chr( nLastKey ) ) + ENDIF + + @ t+2, l+3 SAY msg GET vrb PICTURE pic WHEN eval( wh ) VALID eval( vl ) + setCursor( 1 ) + READ + + Vou_DestroyOCrt( oCrt, oldCrt ) + + RETURN vrb + +//----------------------------------------------------------------------// + +FUNCTION GetCrtCargoSlots() + RETURN { .f.,.f.,.f.,.f.,.f.,.f.,.f.,.f.,.f.,.f. } + +/*----------------------------------------------------------------------*/ + +FUNCTION xtos( x ) + LOCAL type := valtype( x ) + DO CASE + CASE type == 'C' + RETURN alltrim( x ) + CASE type == 'D' + RETURN dtoc( x ) + CASE type == 'L' + RETURN iif( x, 'Y', 'N' ) + CASE type == 'N' + RETURN ltrim( str( x ) ) + ENDCASE + RETURN "" + +//----------------------------------------------------------------------// + +FUNCTION VouchRgb( nR, nG, nB ) + RETURN ( nR +( nG * 256 ) +( nB * 256 * 256 ) ) + +//---------------------------------------------------------------------// + +FUNCTION VouchYN( msg, nInit ) + LOCAL g := getactive(), sel + + msg := IF( msg==NIL,'',msg ) + nInit := IF( nInit==NIL,1,IF( valtype( nInit )=='N',nInit,IF( nInit,1,2 ) ) ) + + B_MSG msg CHOOSE 'Yes','No ' TRIGGER {1,1} INITIAL nInit ; + RESTORE SHADOW AT g:row - 3, g:col INTO sel + + IF g <> NIL + g:varPut( IF( sel == 1, .t., .f. ) ) + ENDIF + + RETURN sel == 1 + +//----------------------------------------------------------------------// + +FUNCTION VouchMenuMM( mnu_,nInit,msg,lExact,aSel ) + LOCAL n, i, t, m_:={} + + DEFAULT nInit TO getActive():varGet() + DEFAULT msg TO 'Select an Option' + DEFAULT lExact TO .f. + DEFAULT aSel TO {} + + aSel := asize( aSel, len( mnu_ ) ) + FOR i := 1 TO len( mnu_ ) + DEFAULT aSel[ i ] TO .t. + NEXT + + aeval( mnu_,{|e_| aadd( m_,e_[ 1 ] ) } ) + + IF( t := valtype( nInit ) == 'C' ) + //nInit := IF( lExact, nInit, trim( nInit ) ) + ENDIF + + n := max( 1, ascan( mnu_, {|e_| ; + IF( t, IF( lExact, nInit, trim( nInit ) ) $ e_[ 2 ], nInit = e_[ 2 ] ) } ) ) + + B_MSG msg CHOOSE m_ INITIAL n SELECTABLES aSel RESTORE SHADOW AT row()-3,col() WVT .T. INTO n + n := max( 1,n ) + + getActive():varPut( IF( t,pad( mnu_[n,2],len( nInit ) ),mnu_[n,2] ) ) + + RETURN .f. + +//----------------------------------------------------------------------// + +FUNCTION VouchMenuM( id,nInit,msg ) + LOCAL n, m_:={},t, mnu_ + + DEFAULT msg TO 'Select' + DEFAULT nInit TO getActive():varGet() + + mnu_:={} + DO CASE + CASE id == "MN_TYFLD" + aadd( mnu_, { "Character", "C" } ) + aadd( mnu_, { "Numeric" , "N" } ) + aadd( mnu_, { "Date" , "D" } ) + aadd( mnu_, { "Logical" , "L" } ) + + CASE id == "MN_PGSZE" + aadd( mnu_, { "A4", "A4" } ) + ENDCASE + + aeval( mnu_,{|e_| aadd( m_,e_[ 1 ] ) } ) + t := valtype( nInit ) == 'C' + n := max( 1, ascan( mnu_, {|e_| iif( t, trim( nInit ) $ e_[ 2 ], nInit == e_[ 2 ] ) } ) ) + + B_MSG msg CHOOSE m_ INITIAL n INTO n RESTORE SHADOW AT row()-3,col() WVT .T. + n := max( 1,n ) + + getActive():varPut( mnu_[n,2] ) + + RETURN .f. // Note, because the FUNCTION is used IN when clause + +//----------------------------------------------------------------------// + +#define VOU_MAXROW 24 + +FUNCTION VouchMsgBox( r1, c1, r2, c2, width, depth, msg_, msgClr, ; + ch_, chClr, wait, restore, paste, shadow, trg_, sel, lSelect_, abr, ; + lSlctns, lLeftRight, center, tagged_,lNumeric,help,exe_,num_,; + lNoXpp, oWin, cIcon, lWvt, nAlign ) + + LOCAL msgLen := 0, chLen := 0, maxLen, pmtWidth + LOCAL boxWide, boxDeep, tBoxDeep + LOCAL cr1, i, oGet, oVal, gap, mCrs,n,nLastKey + LOCAL nLenScrol, nMsg, nOff, aScrolbar + LOCAL oldPnt_, oCrt, oldCrt + LOCAL nSlctns_:={}, dd_:={}, cgo_:={} + LOCAL xRet := NIL + + HB_SYMBOL_UNUSED( trg_ ) + HB_SYMBOL_UNUSED( help ) + + DEFAULT lNoXpp TO .f. + DEFAULT nAlign TO 2 + + DEFAULT r1 TO row() + DEFAULT c1 TO col() + DEFAULT msg_ TO {} + DEFAULT ch_ TO {} + DEFAULT lSelect_ TO {} + DEFAULT msgClr TO 1 //C_NORMAL + DEFAULT chClr TO 3 //C_ENHANCED + DEFAULT restore TO .f. + DEFAULT paste TO .f. + DEFAULT shadow TO .f. + DEFAULT abr TO .f. + DEFAULT lSlctns TO .f. + DEFAULT lLeftRight TO .f. + DEFAULT center TO .f. + DEFAULT tagged_ TO {} + DEFAULT lNumeric TO .f. + DEFAULT num_ TO {} + + // grab get OBJECT + oGet := iif( paste, getactive(), oGet ) + + // NIL is used TO indicate no MESSAGE is desired, just choices + IF( len( msg_ ) > 0 ) .AND. ( valtype( msg_[1] ) == "A" ) + msg_ := aclone( msg_[ 1 ] ) + ENDIF + + IF( len( msg_ ) > 0 ) .AND. ( msg_[1] == NIL ) + msg_ := {} + ENDIF + + IF( len( ch_ ) > 0 ) .AND. ( valtype( ch_[1] ) = "A" ) + ch_ := aclone( ch_[ 1 ] ) + ENDIF + + IF len( msg_ ) == 0 .AND. len( ch_ ) == 0 + RETURN .f. + ENDIF + + IF lSlctns + IF lNumeric + IF empty( num_ ) + FOR i := 1 TO len( ch_ ) + ch_[i] := ' '+ch_[i] + NEXT + ELSE + FOR i := 1 TO len( ch_ ) + IF( n := ascan( num_,i ) )==0 + ch_[ i ] := ' '+ch_[i] + ELSE + ch_[ i ] := pad( NTRIM( n ), 4 ) + ch_[ i ] + ENDIF + NEXT + ENDIF + ELSE + FOR i := 1 TO len( ch_ ) + ch_[ i ] := iif( empty( tagged_ ),' ', ; + iif( tagged_[ i ], chr( 251 ) +' ',' ' ) ) + ch_[ i ] + NEXT + ENDIF + ENDIF + + aeval( msg_, {|s| msgLen := max( msgLen, len( s ) ) } ) + aeval( ch_, {|s| chLen := max( chLen, len( s ) ) } ) + maxlen := max( msgLen, chLen ) + aeval( ch_, {|s,i| s:=s, ch_[i] := pad( ch_[i], maxLen ) } ) + + IF empty( lSelect_ ) + lSelect_:= {} + aeval( ch_, {|s| aadd( lSelect_, IF( empty( s ), .f., .t. ) ) } ) + ELSE + aeval( ch_, {|s,i| lSelect_[i] := IF( empty( s ),.f.,lSelect_[i] ) } ) + ENDIF + IF ascan( lSelect_, {|e| e } ) == 0 + IF len( ch_ ) > 0 + RETURN 0 + ENDIF + ENDIF + + nMsg := Len( msg_ ) + nOff := IF( nMsg == 1, 0, 1 ) + + boxDeep := IF( len( msg_ )=0,0,len( msg_ )+1 ) + ; + IF( len( ch_ )=0,0,len( ch_ )+1 ) + + IF nMsg == 1 + boxDeep-- + ENDIF + + tBoxDeep := boxDeep + boxWide := max( msgLen, chLen ) + 3 + + DEFAULT r2 TO r1 + iif( depth = NIL, boxDeep, depth ) + DEFAULT c2 TO c1 + iif( width = NIL, boxWide, width ) + + IF center + r1 := int( ( maxrow() - tBoxDeep ) / 2 ) + r1 := IF( r1 < 0, 0, r1 ) + r2 := r1 + tBoxDeep + IF r2 > VOU_MAXROW + r2 := VOU_MAXROW + ENDIF + c1 := int( ( maxcol() - boxWide ) / 2 ) + c1 := IF( c1 < 0, 3, c1 ) + c2 := c1 + boxWide + ELSE + IF r2 <= r1 + r2 := maxrow() + ENDIF + IF c2 <= c1 + c2 := maxcol() + ENDIF + + // IF coordinates are off the screen, confine them + IF r2 > VOU_MAXROW + gap := r2 - VOU_MAXROW + r2 := r2 - gap + r1 := r1 - gap + ENDIF + + IF c2 > maxcol() - 4 + gap :=( c2 - maxcol() + 4 ) + c2 := c2 - gap + c1 := c1 - gap + ENDIF + ENDIF + + lWvt := .t. + + IF sel == NIL .OR. sel < 1 .OR. sel > len( ch_ ) + sel := 1 + ENDIF + + mCrs := mSetCursor( .f. ) + oldPnt_:= WvtSetPaint( {} ) + + r2 -= IF( nMsg == 1, 1, 0 ) + + // CREATE New Window + B_CRT r1,c1,r2,c2 MODAL TITLE IF( len( msg_ ) == 1, msg_[ 1 ], 'Selections' ) ICON cIcon INTO oCrt + oldCrt := SetOCrt( oCrt ) + + // Adjust coordinates + r2 -= r1 + c2 -= c1 + r1 := 0 + c1 := 0 + + IF len( ch_ ) > 0 + DispBox( r1 + nOff + nMsg + IF( nMsg <= 1, 0, 1 ), c1+2, r2-1, c2-2, ' ', 'W/W*' ) + Wvg_Outline( r1 + nOff + nMsg + IF( nMsg <= 1, 0, 1 ), c1+2, r2-1, c2-2 ) + ENDIF + + FOR i = 1 TO min( len( msg_ ), r2 -( r1 + 1 ) ) + IF len( msg_ ) > 1 + IF nAlign == 2 + dispOutAt( r1 + i, c1+2, padc( msg_[ i ], c2 -( c1+3 ) ), 'N/W' ) + ELSEIF nAlign == 0 + dispOutAt( r1 + i, c1+2, pad( msg_[ i ], c2 -( c1+3 ) ), 'N/W' ) + ELSEIF nAlign == 1 + dispOutAt( r1 + i, c1+2, padr( msg_[ i ], c2 -( c1+3 ) ), 'N/W' ) + ENDIF + ENDIF + NEXT i + mSetCursor( mCrs ) + + IF len( ch_ ) > 0 + IF nMsg > 1 + mCrs := mSetCursor( .f. ) + mSetCursor( mCrs ) + cr1 := r1 + nMsg + 2 + + IF nMsg == 1 + cr1-- + ENDIF + ELSE + cr1 := r1 + 1 + ENDIF + + SetColor( 'N/W*,W+/B*,,,W/W*' ) + aScrolBar := ScrolBarNew( cr1 - 1, c2, r2, iif( wvt(),'B+/W', "b+/w" ) ) + + nLenScrol := len( ch_ ) + pmtWidth := c2-c1-3 + aeval( ch_, {|e,i| ch_[ i ] := pad( e,pmtWidth ) } ) + + IF .t. + ScrolBarUpdate( aScrolBar, sel, nLenScrol, .t. ) + + cgo_:= { sel, 0, lSlctns, lNumeric, ch_, lSelect_, exe_, aScrolbar, nLenScrol } + + DO WHILE .t. + sel := VouchAChoice( cr1, c1 + 2, r2 - 1, c1 +( c2 - c1 ) - 2, ; + cgo_[CGO_CH_], cgo_[CGO_SEL_], "VouchFunc2", ; + cgo_[CGO_POS], cgo_[CGO_ROW], oWin, ; + @nLastKey, @cgo_ ) + IF ! lSlctns + EXIT + ELSE + IF VouchInArray( nLastKey, { K_ESC, K_CTRL_ENTER, K_ALT_F7 } ) + EXIT + ENDIF + ENDIF + ENDDO + ENDIF + + ELSEIF valtype( wait ) = "N" + sel := inkey( wait ) + ENDIF + + Vou_DestroyOCrt( oCrt, oldCrt ) + + WvtSetPaint( oldPnt_ ) + + IF paste + IF valtype( oGet:varGet() ) == "C" + oVal := oGet:varGet() + oGet:varPut( pad( ch_[ IF( sel = 0,1,sel ) ], len( oVal ) ) ) + oGet:display() + ENDIF + ENDIF + + IF lSlctns + IF !lNumeric + FOR i = 1 TO len( cgo_[CGO_CH_] ) + IF substr( cgo_[CGO_CH_,i], 1, 1 ) == chr( 251 ) /*CHECKMARK*/ + aadd( nSlctns_,i ) + ENDIF + NEXT + ELSE + FOR i := 1 TO len( cgo_[CGO_CH_] ) + IF val( left( cgo_[CGO_CH_,i],4 ) )>0 + aadd( dd_,{val( left( cgo_[CGO_CH_,i],4 ) ),i} ) + ENDIF + NEXT + IF !empty( dd_ ) + asort( dd_,,,{|e_,f_| e_[1] 0 .AND. nKey <> K_MOVING + ScrolBarUpdate( cgo_[ CGO_SCROL ], nElem, cgo_[ CGO_LENSCR ], .t. ) + IF cgo_[ CGO_EXE_ ] <> NIL + eval( cgo_[ CGO_EXE_,nElem ] ) + ENDIF + ENDIF + + cgo_[CGO_POS] := nElem + cgo_[CGO_ROW] := nRel + + DO CASE + CASE nKey == K_F1 + // help() + RETURN AC_CONT + CASE nmode = AC_IDLE + RETURN AC_CONT + CASE nmode = AC_HITTOP + KEYBOARD CHR( K_CTRL_PGDN ) + RETURN AC_CONT + CASE nmode = AC_HITBOTTOM + KEYBOARD CHR( K_CTRL_PGUP ) + RETURN AC_CONT + CASE nmode = AC_EXCEPT + DO CASE + CASE nKey == K_F1 + // help() + RETURN AC_CONT + CASE nKey = K_ESC + RETURN AC_ABORT + CASE nKey == K_F9 // TAG ALL + IF cgo_[CGO_LSEL] + IF cgo_[CGO_LNUM] + FOR i := 1 TO len( cgo_[CGO_CH_] ) + IF cgo_[CGO_SEL_] + cgo_[CGO_CH_,i] := chr( 251 ) + substr( cgo_[ CGO_CH_,i ], 2 ) + ENDIF + NEXT + RETURN AC_ABORT + ELSE + RETURN AC_CONT + ENDIF + ELSE + RETURN AC_CONT + ENDIF + CASE nKey == K_F10 // UnTAG ALL + IF cgo_[CGO_LSEL] + FOR i := 1 TO len( cgo_[CGO_CH_] ) + cgo_[CGO_CH_,i] := " "+substr( cgo_[CGO_CH_,i],2 ) + NEXT + RETURN AC_ABORT + ELSE + RETURN AC_CONT + ENDIF + + CASE nKey = K_ENTER + IF cgo_[CGO_LSEL] + IF !cgo_[CGO_LNUM] + cgo_[CGO_CH_,cgo_[CGO_POS]] := IF( substr( cgo_[CGO_CH_,cgo_[CGO_POS]],1,1 )==CHECKMARK, ; + " ",CHECKMARK )+substr( cgo_[CGO_CH_,cgo_[CGO_POS]],2 ) + cgo_[CGO_POS] := min( cgo_[CGO_POS]+1,len( cgo_[CGO_CH_] ) ) + RETURN AC_ABORT + ELSE + IF( n:=val( substr( cgo_[CGO_CH_,cgo_[CGO_POS]],1,4 ) ) )>0 + cgo_[CGO_CH_,cgo_[CGO_POS]] := " "+substr( cgo_[CGO_CH_,cgo_[CGO_POS]],5 ) + cgo_[CGO_POS] := min( cgo_[CGO_POS]+1,len( cgo_[CGO_CH_] ) ) + FOR i := 1 TO len( cgo_[CGO_CH_] ) + IF( nn := val( left( cgo_[CGO_CH_,i],4 ) ) )>0 + IF nn > n + nn := nn - 1 + s := IF( nn > 0,pad( NTRIM( nn ),4 )," " ) + cgo_[CGO_CH_,i] := s + substr( cgo_[CGO_CH_,i],5 ) + ENDIF + ENDIF + NEXT + ELSE + nn := 0 + n := 0 + aeval( cgo_[CGO_CH_], {|e| n := val( left( e,4 ) ), nn := IF( n>nn,n,nn ) } ) + cgo_[CGO_CH_,cgo_[CGO_POS]] := pad( NTRIM( nn+1 ),4 ) + substr( cgo_[CGO_CH_,cgo_[CGO_POS]],5 ) + cgo_[CGO_POS] := min( cgo_[CGO_POS]+1, len( cgo_[CGO_CH_] ) ) + ENDIF + RETURN AC_ABORT + ENDIF + ELSE + RETURN AC_SELECT + ENDIF + + CASE nKey = K_CTRL_ENTER + RETURN AC_SELECT + CASE nKey = HB_K_RESIZE + RETURN AC_CONT + OTHERWISE + IF cgo_[CGO_LSEL] + cgo_[CGO_POS] := scan_f( cgo_[CGO_POS], cgo_[CGO_CH_], nKey, iif( !cgo_[CGO_LNUM],3,5 ) ) + RETURN AC_ABORT + ELSE + RETURN AC_GOTO + ENDIF + ENDCASE + CASE nmode = AC_NOITEM + RETURN AC_ABORT + OTHERWISE + RETURN AC_GOTO + ENDCASE + + RETURN AC_CONT + +//----------------------------------------------------------------------// + +STATIC FUNCTION scan_f( elem, a_, key, nFrom ) + LOCAL n := elem, na, c + + c := lower( chr( key ) ) + na := ascan( a_, {|e| lower( substr( e, nFrom, 1 ) ) == c }, min( elem + 1, len( a_ ) ) ) + IF na == 0 + na := ascan( a_,{|e| lower( substr( e, nFrom, 1 ) ) == c },1,elem-1 ) + ENDIF + IF na <> 0 + n := na + ENDIF + RETURN n + +//----------------------------------------------------------------------// + diff --git a/harbour/contrib/hbcuied/hbcuied.ch b/harbour/contrib/hbcuied/hbcuied.ch new file mode 100644 index 0000000000..642bb156de --- /dev/null +++ b/harbour/contrib/hbcuied/hbcuied.ch @@ -0,0 +1,610 @@ +/* + * $Id$ + */ + +/* + * Harbour Project source code: + * CUI Forms Editor + * + * Copyright 2011 Pritpal Bedi + * http://harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ +/* + * EkOnkar + * ( The LORD is ONE ) + * + * Harbour CUI Editor Source + * + * Pritpal Bedi + * 13Aug2011 + */ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ +/*----------------------------------------------------------------------*/ + +#ifndef __HBEDCUI_CH +#define __HBEDCUI_CH + +#define THE_FILL 'ø' +#define CLR_GET 'W+/W' +#define CLR_BOX 'W+/B' +#define OBJ_CLR_FIELD 'W+/W' + + +#define OBJ_TYPE 1 // N 1 +#define OBJ_ROW 2 // N 3 +#define OBJ_COL 3 // N 3 +#define OBJ_TEXT 4 // C 15 +#define OBJ_BOX_SHAPE 4 // C -- +#define OBJ_COLOR 5 // C 7 +#define OBJ_TO_ROW 6 // N 3 +#define OBJ_TO_COL 7 // N 3 +#define OBJ_ID 8 // C 15 +#define OBJ_SECTION 9 // N 4 +#define OBJ_ALIAS 10 // C 8 +#define OBJ_FIELD 11 // N 3 +#define OBJ_EQN 12 // C 240 +#define OBJ_F_TYPE 13 // C 1 +#define OBJ_F_LEN 14 // N 3 +#define OBJ_F_DEC 15 // N 2 +#define OBJ_F_PIC 16 // C 20 +#define OBJ_ALIGN 17 // C 1 +#define OBJ_PITCH 18 // N 2 +#define OBJ_FONT 19 // C 8 +#define OBJ_BOLD 20 // L 1 +#define OBJ_ITALIC 21 // L 1 +#define OBJ_UNDERLN 22 // L 1 +#define OBJ_S_SCRPT 23 // L 1 +#define OBJ_U_SCRPT 24 // L 1 +#define OBJ_HALF_H 25 // L 1 +#define OBJ_PRN_LEN 26 // N 3 +#define OBJ_ZERO 27 // L 1 +#define OBJ_REPEATED 28 // C 6 +#define OBJ_VERTICLE 29 // L 1 +#define OBJ_WRAP_SEMI 30 // L 1 +#define OBJ_FOR 31 // C 80 +#define OBJ_SEC_ROW 32 // N 3 +#define OBJ_ATTRB 33 // C 8 +#define OBJ_VAL 34 // C 1 +#define OBJ_OBJ_UNIQUE 35 // N 4 +#define OBJ_MDL_F_TYPE 36 // N 2 +#define OBJ_POINT 37 // N 2 +#define OBJ_COL_JUST 38 // N 2 +#define OBJ_PATTERN 39 // C 10 +#define OBJ_BORDER 40 // N 5 2 + +#define OBJ_INIT_VRBLS 40 + +// Run time addresses +#define OBJ_PRINT 4 +#define OBJ_SECTOR 9 +#define OBJ_UNIQUE 32 +#define CAL_UNIQUE 1 +#define CAL_SECTOR 2 +#define CAL_OBJ 3 +#define CAL_ATTRB 4 +#define CAL_NONE 5 +#define CAL_COUNT 6 +#define CAL_SUM 7 +#define CAL_AVERAGE 8 +#define CAL_HIGHEST 9 +#define CAL_LOWEST 10 + +#define OBJ_LEN_TYPE 1 +#define OBJ_LEN_ROW 3 +#define OBJ_LEN_COL 3 +#define OBJ_LEN_TEXT 15 +#define OBJ_LEN_COLOR 7 +#define OBJ_LEN_TO_ROW 3 +#define OBJ_LEN_TO_COL 3 +#define OBJ_LEN_ID 15 +#define OBJ_LEN_SECTION 4 +#define OBJ_LEN_ALIAS 8 +#define OBJ_LEN_FIELD 3 +#define OBJ_LEN_EQN 240 +#define OBJ_LEN_F_TYPE 1 +#define OBJ_LEN_F_LEN 3 +#define OBJ_LEN_F_DEC 2 +#define OBJ_LEN_F_PIC 20 +#define OBJ_LEN_ALIGN 1 +#define OBJ_LEN_PITCH 2 +#define OBJ_LEN_FONT 8 +#define OBJ_LEN_BOLD 1 +#define OBJ_LEN_ITALIC 1 +#define OBJ_LEN_UNDERLN 1 +#define OBJ_LEN_S_SCRPT 1 +#define OBJ_LEN_U_SCRPT 1 +#define OBJ_LEN_HALF_H 1 +#define OBJ_LEN_PRN_LEN 3 +#define OBJ_LEN_ZERO 1 +#define OBJ_LEN_REPEATED 6 +#define OBJ_LEN_VERTICLE 1 +#define OBJ_LEN_WRAP_SEMI 1 +#define OBJ_LEN_FOR 80 +#define OBJ_LEN_SEC_ROW 3 +#define OBJ_LEN_ATTRB 8 +#define OBJ_LEN_VAL 1 +#define OBJ_LEN_OBJ_UNIQUE 4 +#define OBJ_LEN_MDL_F_TYPE 2 +#define OBJ_LEN_POINT 2 +#define OBJ_LEN_COL_JUST 3 // N 3 +#define OBJ_LEN_PATTERN 10 // C 10 +#define OBJ_LEN_BORDER 5 // N 5 2 + +#define OBJ_OS_TYPE 1 // N 1 +#define OBJ_OS_ROW 2 // N 3 +#define OBJ_OS_COL 5 // N 3 +#define OBJ_OS_TEXT 8 // C 15 +#define OBJ_OS_COLOR 23 // C 7 +#define OBJ_OS_TO_ROW 30 // N 3 +#define OBJ_OS_TO_COL 33 // N 3 +#define OBJ_OS_ID 36 // C 15 +#define OBJ_OS_SECTION 51 // N 4 +#define OBJ_OS_ALIAS 55 // C 8 +#define OBJ_OS_FIELD 63 // N 3 +#define OBJ_OS_EQN 66 // C 240 +#define OBJ_OS_F_TYPE 306 // C 1 +#define OBJ_OS_F_LEN 307 // N 3 +#define OBJ_OS_F_DEC 310 // N 2 +#define OBJ_OS_F_PIC 312 // C 20 +#define OBJ_OS_ALIGN 332 // C 1 +#define OBJ_OS_PITCH 333 // N 2 +#define OBJ_OS_FONT 335 // C 8 +#define OBJ_OS_BOLD 343 // L 1 +#define OBJ_OS_ITALIC 344 // L 1 +#define OBJ_OS_UNDERLN 345 // L 1 +#define OBJ_OS_S_SCRPT 346 // L 1 +#define OBJ_OS_U_SCRPT 347 // L 1 +#define OBJ_OS_HALF_H 348 // L 1 +#define OBJ_OS_PRN_LEN 349 // N 3 +#define OBJ_OS_ZERO 352 // L 1 +#define OBJ_OS_REPEATED 353 // C 6 +#define OBJ_OS_VERTICLE 359 // L 1 +#define OBJ_OS_WRAP_SEMI 360 // L 1 +#define OBJ_OS_FOR 361 // C 80 +#define OBJ_OS_SEC_ROW 441 // N 3 +#define OBJ_OS_ATTRB 444 // C 8 +#define OBJ_OS_VAL 452 // C 1 +#define OBJ_OS_OBJ_UNIQUE 453 // N 4 +#define OBJ_OS_MDL_F_TYPE 457 // N 2 +#define OBJ_OS_POINT 459 // N 2 +#define OBJ_OS_COL_JUST 461 // N 3 +#define OBJ_OS_PATTERN 464 // C 10 +#define OBJ_OS_BORDER 474 // N 5 2 +// ---- +// TOTAL 474 + +#define VV_ID 1 // N 1 +#define VV_FIELD 2 // N 3 +#define VV_F_TYPE 3 // C 1 +#define VV_F_LEN 4 // N 3 +#define VV_F_DEC 5 // N 2 +#define VV_ATTRB 6 // C 8 +#define VV_EQN 7 // C 240 +#define VV_PRN_LEN 8 // N 3 +#define VV_F_PIC 9 // C 20 +#define VV_PITCH 10 // N 2 +#define VV_FONT 11 // C 8 +#define VV_BOLD 12 // L 1 +#define VV_ITALIC 13 // L 1 +#define VV_UNDERLN 14 // L 1 +#define VV_S_SCRPT 15 // L 1 +#define VV_U_SCRPT 16 // L 1 +#define VV_HALF_H 17 // L 1 +#define VV_ALIGN 18 // C 1 +#define VV_COLOR 19 // C 7 +#define VV_ZERO 20 // L 1 +#define VV_REPEATED 21 // C 6 +#define VV_VERTICLE 22 // L 1 +#define VV_WRAP_SEMI 23 // L 1 +#define VV_FOR 24 // C 80 +#define VV_OBJ_UNIQUE 25 // N 4 +#define VV_MDL_F_TYPE 26 // N 2 +#define VV_POINT 27 // N 2 +#define VV_COL_JUST 28 +#define VV_PATTERN 29 +#define VV_BORDER 30 + +#define VV_INIT_VRBLS 30 + +#define OBJ_REFRESH_ALL 1 +#define OBJ_REFRESH_LINE 2 +#define OBJ_REFRESH_NIL 0 + +#define OBJ_O_BOX 1 +#define OBJ_O_LINE 2 +#define OBJ_O_TEXT 3 +#define OBJ_O_FIELD 4 +#define OBJ_O_EXP 5 +#define OBJ_O_BMP 6 + +// Properties will be based on these attributes +#define DGN_MODULE 1 +#define DGN_REPORT 2 +#define DGN_DOCUMENT 3 +#define DGN_LABEL 4 +#define DGN_SCREEN 5 + +#define OBJ_MODE_SELECT 1 +#define OBJ_MODE_MOVE 2 +#define OBJ_MODE_IDLE 0 + +#define SCN_TOP 1 +#define SCN_LEFT 2 +#define SCN_BOTTOM 3 +#define SCN_RIGHT 4 +#define SCN_STATUS_ROW 5 +#define SCN_STATUS_COL 6 +#define SCN_STATUS_COL_TO 7 +#define SCN_MODE 8 +#define SCN_ROW_CUR 9 +#define SCN_COL_CUR 10 +#define SCN_ROW_REP 11 +#define SCN_COL_REP 12 +#define SCN_ROW_DIS 13 +#define SCN_COL_DIS 14 +#define SCN_ROW_RULER 15 +#define SCN_ROW_MENU 16 +#define SCN_COL_MAX 17 +#define SCN_ROW_PREV 18 +#define SCN_COL_PREV 19 +#define SCN_REP_LINES 20 +#define SCN_CLR_STATUS 21 +#define SCN_CLR_TEXT 22 +#define SCN_CLR_BOX 23 +#define SCN_CLR_FIELD 24 +#define SCN_CLR_HILITE 25 +#define SCN_CLR_WINDOW 26 +#define SCN_CLR_RULER 27 +#define SCN_CLR_MENU 28 +#define SCN_CLR_OVERALL 29 +#define SCN_CLR_PREV 30 +#define SCN_CLR_SELECT 31 +#define SCN_OBJ_HILITE 32 +#define SCN_OBJ_SELECTED 33 +#define SCN_FILE 34 // 'Untitled' +#define SCN_RULER 35 // C +#define SCN_DRAW_FILL 36 // C +#define SCN_OBJ_ID_ 37 // {} +#define SCN_REFRESH 38 // .F. +#define SCN_OBJ_COPIED 39 +#define SCN_BOX_SHAPE 40 +#define SCN_CHR_PREV 41 +#define SCN_DESIGN 42 +#define SCN_DESIGN_ID 43 +#define SCN_PROPERTY 44 +#define SCN_GRAPHICS 45 +#define SCN_TEXT_BLOCK_ 46 +#define SCN_SECTORS_ 47 +#define SCN_FIELDS 48 +#define SCN_LASTKEY 49 +#define SCN_FOR_ROWS 50 +#define SCN_COBJECT 51 // fOR tHREADED uSE +#define SCN_CRPT 52 // . +#define SCN_NWHERE 53 // . +#define SCN_LMSG 54 // . +#define SCN_NMODE 55 // . + +#define SCN_NUM_VAR 55 + + +#define REP_DESC 1 // C 70 +#define REP_TYPE 2 // N 3 +#define REP_IDX_NO 3 // N 3 +#define REP_IDX_EXP 4 // C 240 +#define REP_PG_SIZE 5 // C 12 +#define REP_PG_LEN 6 // N 5 +#define REP_PG_WID 7 // N 5 +#define REP_LINES 8 // N 2 +#define REP_MG_TOP 9 // N 3 +#define REP_MG_LEFT 10 // N 3 +#define REP_MG_BOTTOM 11 // N 3 +#define REP_EJ_BEFORE 12 // L 1 +#define REP_EJ_AFTER 13 // L 1 +#define REP_PLAIN 14 // N 2 +#define REP_FTR_PAG 15 // L 1 +#define REP_SMR_NEXT 16 // L 1 +#define REP_HDR_PAGES 17 // C 10 +#define REP_BNK_LINES 18 // N 3 +#define REP_BNK_AFTER 19 // N 3 +#define REP_DATA_BOX 20 // L 1 +#define REP_FILE 21 // C 80 +#define REP_COPIES 22 // N 3 +#define REP_TTL_PAGES 23 // C 10 +#define REP_INIT_CPI 24 // N 2 +#define REP_PRN_QLY 25 // C 1 +#define REP_RECONFIRM 26 // L 1 +#define REP_FTR_BOTTOM 27 // L 1 +#define REP_HTML 28 // L 1 +#define REP_PRINTER 29 // C 7 +#define REP_ORIENT 30 // C 1 +#define REP_PREVIEW 31 // L 1 +#define REP_GRAY 32 // L 1 +#define REP_WINDLG 33 // L 1 +#define REP_DUPLEX 34 // N 1 +#define REP_COLS 35 // N 3 +#define REP_ROWS 36 // N 3 + +#define REP_FOR 37 // C 240 +#define REP_WHILE 38 // C 125 +#define REP_FIRST 39 // C 125 +#define REP_EXE_PRE 40 // C 245 +#define REP_EXE_POST 41 // C 245 + +#define REP_INIT_VRBLS 41 + +#define REP_LEN_DESC 70 +#define REP_LEN_TYPE 3 +#define REP_LEN_IDX_NO 3 +#define REP_LEN_IDX_EXP 240 +#define REP_LEN_PG_SIZE 12 +#define REP_LEN_PG_LEN 5 +#define REP_LEN_PG_WID 5 +#define REP_LEN_LINES 2 +#define REP_LEN_MG_TOP 3 +#define REP_LEN_MG_LEFT 3 +#define REP_LEN_MG_BOTTOM 3 +#define REP_LEN_EJ_BEFORE 1 +#define REP_LEN_EJ_AFTER 1 +#define REP_LEN_PLAIN 2 +#define REP_LEN_FTR_PAG 1 +#define REP_LEN_SMR_NEXT 1 +#define REP_LEN_HDR_PAGES 10 +#define REP_LEN_BNK_LINES 3 +#define REP_LEN_BNK_AFTER 3 +#define REP_LEN_DATA_BOX 1 +#define REP_LEN_FILE 80 +#define REP_LEN_COPIES 3 +#define REP_LEN_TTL_PAGES 10 +#define REP_LEN_INIT_CPI 2 +#define REP_LEN_PRN_QLY 1 +#define REP_LEN_RECONFIRM 1 +#define REP_LEN_FTR_BOTTOM 1 +#define REP_LEN_HTML 1 +#define REP_LEN_PRINTER 7 +#define REP_LEN_ORIENT 1 +#define REP_LEN_PREVIEW 1 +#define REP_LEN_GRAY 1 +#define REP_LEN_WINDLG 1 +#define REP_LEN_DUPLEX 1 +#define REP_LEN_COLS 3 +#define REP_LEN_ROWS 3 + +#define REP_LEN_FOR 240 +#define REP_LEN_WHILE 125 +#define REP_LEN_FIRST 125 +#define REP_LEN_EXE_PRE 245 +#define REP_LEN_EXE_POST 245 + +#define REP_OS_DESC 1 // C 70 +#define REP_OS_TYPE 71 // N 3 +#define REP_OS_IDX_NO 74 // N 3 +#define REP_OS_IDX_EXP 77 // C 240 +#define REP_OS_PG_SIZE 317 // C 12 +#define REP_OS_PG_LEN 329 // N 5 +#define REP_OS_PG_WID 334 // N 5 +#define REP_OS_LINES 339 // N 2 +#define REP_OS_MG_TOP 341 // N 3 +#define REP_OS_MG_LEFT 344 // N 3 +#define REP_OS_MG_BOTTOM 347 // N 3 +#define REP_OS_EJ_BEFORE 350 // L 1 +#define REP_OS_EJ_AFTER 351 // L 1 +#define REP_OS_PLAIN 352 // N 2 +#define REP_OS_FTR_PAG 354 // L 1 +#define REP_OS_SMR_NEXT 355 // L 1 +#define REP_OS_HDR_PAGES 356 // C 10 +#define REP_OS_BNK_LINES 366 // N 3 +#define REP_OS_BNK_AFTER 369 // N 3 +#define REP_OS_DATA_BOX 372 // L 1 +#define REP_OS_FILE 373 // C 80 +#define REP_OS_COPIES 453 // N 3 +#define REP_OS_TTL_PAGES 456 // C 10 +#define REP_OS_INIT_CPI 466 // N 2 +#define REP_OS_PRN_QLY 468 // C 1 +#define REP_OS_RECONFIRM 469 // L 1 +#define REP_OS_FTR_BOTTOM 470 // L 1 +#define REP_OS_HTML 471 // L 1 +#define REP_OS_PRINTER 472 // C 7 +#define REP_OS_ORIENT 479 // C 1 +#define REP_OS_PREVIEW 480 // L 1 +#define REP_OS_GRAY 481 // L 1 +#define REP_OS_WINDLG 482 // L 1 +#define REP_OS_DUPLEX 483 // N 1 +#define REP_OS_COLS 484 // N 3 +#define REP_OS_ROWS 487 // N 3 + + +// TOTAL 490 + +#define REP_OS_FOR 1 // C 240 +#define REP_OS_WHILE 241 // C 125 +#define REP_OS_FIRST 366 // C 125 + +#define REP_OS_EXE_PRE 1 // C 245 +#define REP_OS_EXE_POST 246 // C 245 + + +#define SCT_ORDER 1 +#define SCT_ID 2 +#define SCT_SAY 3 +#define SCT_ROWS 4 +#define SCT_COLOR 5 +#define SCT_EQN 6 +#define SCT_EJECT 7 +#define SCT_RESET 8 + +#define SCT_INIT_VRBLS 8 + +#define SCT_LEN_ORDER 3 +#define SCT_LEN_ID 8 +#define SCT_LEN_SAY 5 +#define SCT_LEN_ROWS 3 +#define SCT_LEN_COLOR 7 +#define SCT_LEN_EQN 240 +#define SCT_LEN_EJECT 1 +#define SCT_LEN_RESET 1 + +#define SCT_OS_ORDER 1 // N 3 +#define SCT_OS_ID 4 // C 8 +#define SCT_OS_SAY 12 // C 5 +#define SCT_OS_ROWS 17 // N 3 +#define SCT_OS_COLOR 20 // C 7 +#define SCT_OS_EQN 27 // C 240 +#define SCT_OS_EJECT 267 // L 1 +#define SCT_OS_RESET 268 // L 1 + +#define SCT_ID_GRP01_H 200 +#define SCT_ID_GRP01_S 800 + +#define SCT_CLR_ {'W+/RB','W+/G','W+/R','W+/N','W+/GR'} + +#define SCT_INIT_GROUPS 20 + +#define REP_FOR_MOD 1 +#define REP_FOR_RPT 2 +#define REP_FOR_BRW 3 +#define REP_FOR_MDL 4 +#define REP_FOR_DOC 5 +#define REP_FOR_LAB 6 +#define REP_FOR_SCR 7 + +#define REP_SRC_MOD 100 +#define REP_SRC_RPT 200 +#define REP_SRC_BRW 300 +#define REP_SRC_MDL 400 +#define REP_SRC_DOC 500 +#define REP_SRC_LAB 600 +#define REP_SRC_SCR 700 + + +#translate B_MSG ; + [ ] ; + [ AT [, ] ] ; + [ TO [, ] ] ; + [ WIDTH ] ; + [ DEPTH ] ; + [ COLOR ] ; + [ CHOOSE ] ; + [ CHOOSECOLOR ] ; + [ CHCOLOR ] ; + [ INTO ] ; + [ WAIT ] ; + [ ] ; + [ ] ; + [ ] ; + [ TRIGGER ] ; + [ INITIAL ] ; + [ SELECTABLES ] ; + [ ABORT ] ; + [ ] ; + [ ] ; + [ ] ; + [ TAGGED ] ; + [ ] ; + [ HELP ] ; + [ EXECUTE ] ; + [ NUMBERED ] ; + [ ] ; + [ WINDOW ] ; + [ ICON ] ; + [ WVT ] ; + [ ALIGN ] ; + => ; + [ := ] VouchMsgBox (, , , , , , ; + {}, , {}, , , <.rest.>, ; + <.paste.>, <.shadow.>, , , , , ; + <.selections.>, <.leftright.>, <.cent.>, ,<.num.>,; + ,,,<.lNoXpp.>,,,, ) + + +#xtranslate B_GETS ; + HEADERS VALUES ; + [ SELECTABLES ] ; + [ AT [, ] ] ; + [ TO [, ] ] ; + [ TITLE ] ; + [ INTO ] ; + [ WHEN ] ; + [ VALID ] ; + [ PICTURE ] ; + [ HELP ] ; + [ ORDER ] ; + => ; + [ := ] VouchGetArray(, , , , , , , ; + , , , , , ) + + +#xtranslate B_CRT ,,, ; + [ TITLE ] ; + [ ICON ] ; + [ ] ; + [ ] ; + [ ] ; + [ ] ; + [ AT , ] ; + [ ] ; + INTO ; + => ; + := Vou_CreateOCrt( , , , , , , ; + <.lModal.>, <.lRowCols.>, <.lHidden.>, <.lCenter.>, ; + , , <.lNoTitleBar.> ) + +#define NTRIM( n ) ltrim( str( n ) ) + +#define COMPILE( cStr ) &( "{|v,w,x| " + cStr + " }" ) + + +#define K_MOVING 1001 +#define K_LEFT_DOWN 1002 +#define K_LEFT_DBLCLICK 1006 +#define K_LEFT_UP 1003 +#define K_RIGHT_DOWN 1004 +#define K_RIGHT_DBLCLICK 1007 +#define K_RIGHT_UP 1005 + +#define CHECKMARK chr( 251 ) + +#endif diff --git a/harbour/contrib/hbcuied/hbcuied.hbp b/harbour/contrib/hbcuied/hbcuied.hbp new file mode 100644 index 0000000000..407c75a8b2 --- /dev/null +++ b/harbour/contrib/hbcuied/hbcuied.hbp @@ -0,0 +1,32 @@ +# +# $Id$ +# + +-3rd=hbide_version=1.0 +-3rd=hbide_title=hbcuied +-3rd=hbide_output=hbcuied + +-w3 +-es2 +-inc +-mt +-gui + +-gtwvg + +..\gtwvg\gtwvg.hbc + +cu_main.prg +cu_desgn.prg +cu_field.prg +cu_menu.prg +cu_outpt.prg +cu_prpty.prg +cu_utlty.prg +cu_achoi.prg + +-ohbcuied + +-3rd=hbide_file=hbcuied.ch + +