From ba2bc6c27bec534463cf628543e91ce8259cd076 Mon Sep 17 00:00:00 2001 From: Pritpal Bedi Date: Sat, 13 Aug 2011 01:15:15 +0000 Subject: [PATCH] 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. --- harbour/ChangeLog | 29 + harbour/contrib/hbcuied/cu_achoi.prg | 817 ++++++++++ harbour/contrib/hbcuied/cu_desgn.prg | 1410 +++++++++++++++++ harbour/contrib/hbcuied/cu_field.prg | 521 +++++++ harbour/contrib/hbcuied/cu_main.prg | 104 ++ harbour/contrib/hbcuied/cu_menu.prg | 237 +++ harbour/contrib/hbcuied/cu_outpt.prg | 520 +++++++ harbour/contrib/hbcuied/cu_prpty.prg | 194 +++ harbour/contrib/hbcuied/cu_utlty.prg | 2140 ++++++++++++++++++++++++++ harbour/contrib/hbcuied/hbcuied.ch | 610 ++++++++ harbour/contrib/hbcuied/hbcuied.hbp | 32 + 11 files changed, 6614 insertions(+) create mode 100644 harbour/contrib/hbcuied/cu_achoi.prg create mode 100644 harbour/contrib/hbcuied/cu_desgn.prg create mode 100644 harbour/contrib/hbcuied/cu_field.prg create mode 100644 harbour/contrib/hbcuied/cu_main.prg create mode 100644 harbour/contrib/hbcuied/cu_menu.prg create mode 100644 harbour/contrib/hbcuied/cu_outpt.prg create mode 100644 harbour/contrib/hbcuied/cu_prpty.prg create mode 100644 harbour/contrib/hbcuied/cu_utlty.prg create mode 100644 harbour/contrib/hbcuied/hbcuied.ch create mode 100644 harbour/contrib/hbcuied/hbcuied.hbp 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 + +