/* * $Id$ */ /* * Harbour Project source code: * * Copyright 2009 Pritpal Bedi * www - 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-Qt IDE * * Pritpal Bedi * 23Nov2009 */ /*----------------------------------------------------------------------*/ /*----------------------------------------------------------------------*/ /*----------------------------------------------------------------------*/ #include "common.ch" #include "fileio.ch" #include "xbp.ch" #include "hbide.ch" STATIC aRegList /*----------------------------------------------------------------------*/ PROCEDURE AppSys() RETURN /*----------------------------------------------------------------------*/ FUNCTION hbide_setIde( oIde ) LOCAL oldIde STATIC ide oldIde := ide IF PCount() > 0 ide := oIde ENDIF RETURN oldIde /*----------------------------------------------------------------------*/ FUNCTION hbide_setProjectOutputPath( cPath ) LOCAL oldProjPath STATIC cProjPath := "" oldProjPath := cProjPath IF HB_ISSTRING( cPath ) cProjPath := cPath ENDIF RETURN oldProjPath /*----------------------------------------------------------------------*/ FUNCTION hbide_setProjectTitle( cTitle ) LOCAL oldProjTitle STATIC cProjTitle IF empty( cProjTitle ) cProjTitle := hbide_setIde():oPM:getCurrentProjectTitle() ENDIF oldProjTitle := cProjTitle IF HB_ISSTRING( cTitle ) cProjTitle := cTitle ENDIF RETURN oldProjTitle /*----------------------------------------------------------------------*/ FUNCTION hbide_execPopup( aPops, aqPos, qParent ) LOCAL i, qPop, qPoint, qAct, cAct, xRet, a_, qSub, b_, qSub_:={}, qAct_:={} qPop := QMenu( iif( HB_ISOBJECT( qParent ), qParent, NIL ) ) qPop:setStyleSheet( GetStyleSheet( "QMenuPop", hbide_setIde():nAnimantionMode ) ) FOR i := 1 TO Len( aPops ) IF empty( aPops[ i,1 ] ) aadd( qAct_, qPop:addSeparator() ) ELSE IF HB_ISOBJECT( aPops[ i, 1 ] ) aadd( qAct_, qPop:addAction( aPops[ i, 1 ] ) ) ELSEIF HB_ISARRAY( aPops[ i, 1 ] ) /* Sub-menu */ qSub := QMenu( qPop ) qSub:setStyleSheet( GetStyleSheet( "QMenuPop", hbide_setIde():nAnimantionMode ) ) FOR EACH a_ IN aPops[ i, 1 ] qSub:addAction( a_[ 1 ] ) NEXT qSub:setTitle( aPops[ i,2 ] ) aadd( qAct_, qPop:addMenu( qSub ) ) aadd( qSub_, qSub ) ELSE aadd( qAct_, qPop:addAction( aPops[ i, 1 ] ) ) ENDIF ENDIF NEXT IF HB_ISARRAY( aqPos ) qPoint := QPoint( aqPos[ 1 ], aqPos[ 2 ] ) ELSEIF HB_ISOBJECT( aqPos ) qPoint := aqPos ENDIF cAct := "" IF __objGetClsName( qAct := qPop:exec( qPoint ) ) == "QACTION" IF valtype( cAct := qAct:text() ) == "C" FOR EACH a_ IN aPops IF HB_ISOBJECT( a_[ 1 ] ) IF a_[ 1 ]:text() == cAct .AND. len( a_ ) >= 2 xRet := eval( aPops[ a_:__enumIndex(), 2 ] ) EXIT ENDIF ELSEIF HB_ISARRAY( a_[ 1 ] ) FOR EACH b_ IN a_[ 1 ] IF b_[ 1 ] == cAct xRet := eval( b_[ 2 ], cAct ) EXIT ENDIF NEXT ELSE IF a_[ 1 ] == cAct .AND. len( a_ ) >= 2 xRet := eval( aPops[ a_:__enumIndex(), 2 ], cAct ) EXIT ENDIF ENDIF NEXT ENDIF ENDIF qPop:setParent( QWidget() ) HB_SYMBOL_UNUSED( xRet ) RETURN cAct /*----------------------------------------------------------------------*/ FUNCTION hbide_menuAddSep( oMenu ) oMenu:addItem( { NIL, NIL, XBPMENUBAR_MIS_SEPARATOR, NIL } ) RETURN nil /*----------------------------------------------------------------------*/ FUNCTION hbide_createTarget( cFile, txt_ ) LOCAL hHandle := fcreate( cFile ) LOCAL cNewLine := hb_eol() IF hHandle != F_ERROR aeval( txt_, {| e | fWrite( hHandle, e + cNewLine ) } ) fClose( hHandle ) ENDIF RETURN hb_FileExists( cFile ) /*----------------------------------------------------------------------*/ FUNCTION hbide_posAndSize( qWidget ) RETURN hb_ntos( qWidget:x() ) + "," + hb_ntos( qWidget:y() ) + "," + ; hb_ntos( qWidget:width() ) + "," + hb_ntos( qWidget:height() ) + "," /*----------------------------------------------------------------------*/ FUNCTION hbide_showWarning( cMsg, cInfo, cTitle, qParent ) LOCAL oMB, nRet DEFAULT cTitle TO "Information" DEFAULT qParent TO SetAppWindow():oWidget oMB := QMessageBox( qParent ) oMB:setText( cMsg ) IF !empty( cInfo ) oMB:setInformativeText( cInfo ) ENDIF oMB:setIcon( QMessageBox_Critical ) oMB:setWindowFlags( Qt_Dialog ) oMB:setWindowTitle( cTitle ) nRet := oMB:exec() oMB:setParent( QWidget() ) RETURN nRet /*----------------------------------------------------------------------*/ FUNCTION hbide_getYesNo( cMsg, cInfo, cTitle, qParent ) LOCAL oMB, nRet DEFAULT cTitle TO "Option Please!" DEFAULT qParent TO hbide_setIde():oDlg:oWidget oMB := QMessageBox( qParent ) oMB:setText( ""+ cMsg +"" ) IF !empty( cInfo ) oMB:setInformativeText( cInfo ) ENDIF oMB:setIcon( QMessageBox_Information ) oMB:setWindowTitle( cTitle ) oMB:setWindowFlags( Qt_Dialog ) oMB:setStandardButtons( QMessageBox_Yes + QMessageBox_No ) nRet := oMB:exec() oMB:setParent( QWidget() ) RETURN nRet == QMessageBox_Yes /*----------------------------------------------------------------------*/ FUNCTION hbide_getYesNoCancel( cMsg, cInfo, cTitle ) LOCAL oMB, nRet DEFAULT cTitle TO "Option Please!" oMB := QMessageBox( SetAppWindow():oWidget ) oMB:setText( ""+ cMsg +"" ) IF !empty( cInfo ) oMB:setInformativeText( cInfo ) ENDIF oMB:setIcon( QMessageBox_Information ) oMB:setWindowFlags( Qt_Dialog ) oMB:setWindowTitle( cTitle ) oMB:setStandardButtons( QMessageBox_Yes + QMessageBox_No + QMessageBox_Cancel ) nRet := oMB:exec() oMB:setParent( QWidget() ) RETURN nRet /*----------------------------------------------------------------------*/ FUNCTION hbide_fetchAFile( oWnd, cTitle, aFlt, cDftDir, cDftSuffix, lAllowMulti ) LOCAL oDlg DEFAULT cTitle TO "Please Select a File" DEFAULT aFlt TO { { "All Files", "*" } } DEFAULT cDftDir TO hb_dirBase() DEFAULT lAllowMulti TO .f. oDlg := XbpFileDialog():new():create( oWnd, , { 10,10 } ) oDlg:title := cTitle oDlg:center := .t. oDlg:fileFilters := aFlt IF HB_ISSTRING( cDftSuffix ) oDlg:oWidget:setDefaultSuffix( cDftSuffix ) ENDIF RETURN oDlg:open( cDftDir, , lAllowMulti ) /*----------------------------------------------------------------------*/ FUNCTION hbide_saveAFile( oWnd, cTitle, aFlt, cDftFile, cDftSuffix ) LOCAL oDlg DEFAULT cTitle TO "Please Select a File" oDlg := XbpFileDialog():new():create( oWnd, , { 10,10 } ) oDlg:title := cTitle oDlg:center := .t. oDlg:fileFilters := aFlt IF HB_ISSTRING( cDftSuffix ) oDlg:oWidget:setDefaultSuffix( cDftSuffix ) ENDIF RETURN oDlg:saveAs( cDftFile, .f., .t. ) /*----------------------------------------------------------------------*/ /* Function to user select a existing folder * 25/12/2009 - 19:10:41 - vailtom */ FUNCTION hbide_fetchADir( oWnd, cTitle, cDftDir ) LOCAL oDlg, cFile DEFAULT cTitle TO "Please Select a Folder" DEFAULT cDftDir TO hb_dirBase() oDlg := XbpFileDialog():new():create( oWnd, , { 10,10 } ) oDlg:title := cTitle oDlg:center := .t. oDlg:oWidget:setFileMode( 4 ) cFile := oDlg:open( cDftDir, , .f. ) oDlg:destroy() IF HB_ISSTRING( cFile ) //cFile := strtran( cFile, "/", hb_ps() ) RETURN cFile ENDIF RETURN "" /*----------------------------------------------------------------------*/ FUNCTION hbide_getEol( cBuffer ) LOCAL cStyle IF chr( 13 ) + chr( 10 ) $ cBuffer cStyle := chr( 13 ) + chr( 10 ) ELSEIF chr( 13 ) $ cBuffer cStyle := chr( 13 ) ELSEIF chr( 10 ) $ cBuffer cStyle := chr( 10 ) ELSE cStyle := "" ENDIF RETURN cStyle /*----------------------------------------------------------------------*/ FUNCTION hbide_readSource( cTxtFile ) LOCAL cFileBody := hb_MemoRead( cTxtFile ) HB_TRACE( HB_TR_DEBUG, cFileBody ) cFileBody := StrTran( cFileBody, Chr( 13 ) ) RETURN hb_ATokens( cFileBody, Chr( 10 ) ) /*----------------------------------------------------------------------*/ FUNCTION hbide_evalAsString( cExp ) LOCAL cValue BEGIN SEQUENCE WITH {|| break() } cValue := Eval( hb_macroBlock( cExp ) ) RECOVER cValue := cExp END SEQUENCE IF !HB_ISSTRING( cValue ) cValue := "" ENDIF RETURN cValue /*----------------------------------------------------------------------*/ FUNCTION hbide_evalAsIs( cExp ) LOCAL xValue BEGIN SEQUENCE WITH {|| break() } xValue := Eval( hb_macroBlock( cExp ) ) RECOVER xValue := cExp END SEQUENCE RETURN xValue /*----------------------------------------------------------------------*/ FUNCTION hbide_setupMetaKeys( a_ ) LOCAL s, n, cKey, cVal LOCAL a4_1 := {} FOR EACH s IN a_ IF !( "#" == left( s,1 ) ) IF ( n := at( "=", s ) ) > 0 cKey := alltrim( substr( s, 1, n-1 ) ) cVal := hbide_evalAsString( alltrim( substr( s, n+1 ) ) ) aadd( a4_1, { "<"+ cKey +">", cVal } ) ENDIF ENDIF NEXT RETURN a4_1 /*----------------------------------------------------------------------*/ FUNCTION hbide_applyMetaData( s, a_ ) LOCAL k IF ! Empty( a_ ) FOR EACH k IN a_ s := StrTran( s, hbide_pathNormalized( k[ 2 ], .f. ), k[ 1 ] ) NEXT ENDIF RETURN s /*----------------------------------------------------------------------*/ FUNCTION hbide_parseWithMetaData( s, a_ ) LOCAL k IF ! Empty( a_ ) FOR EACH k IN a_ DESCEND s := StrTran( s, k[ 1 ], k[ 2 ] ) NEXT ENDIF RETURN s /*----------------------------------------------------------------------*/ FUNCTION hbide_ar2delString( a_, cDlm ) LOCAL s := "" aeval( a_, {|e| s += e + cDlm } ) RETURN substr( s, 1, Len( s ) - len( cDlm ) ) /*----------------------------------------------------------------------*/ FUNCTION hbide_arrayToMemo( a_ ) LOCAL s := "" aeval( a_, {|e| s += e + hb_eol() } ) s += hb_eol() RETURN s /*----------------------------------------------------------------------*/ FUNCTION hbide_arrayToMemoEx( a_ ) LOCAL s := "" aeval( a_, {|e| s += e + hb_eol() } ) s := substr( s, 1, Len( s ) - 2 ) RETURN s /*----------------------------------------------------------------------*/ FUNCTION hbide_arrayToMemoEx2( a_ ) RETURN hbide_arrayToMemoEx( a_ ) #if 0 LOCAL s := "", k LOCAL lNewPara := .t. FOR EACH k IN a_ IF empty( k ) s += hb_eol() + hb_eol() lNewPara := .t. ELSE s += iif( lNewPara, "", " " ) + k lNewPara := .f. ENDIF NEXT DO WHILE .t. IF right( s, 2 ) == hb_eol() s := substr( s, 1, Len( s ) - 2 ) ELSE EXIT ENDIF ENDDO RETURN s #endif /*----------------------------------------------------------------------*/ FUNCTION hbide_convertHtmlDelimiters( s ) s := StrTran( s, "&", "&" ) s := StrTran( s, "<", "<" ) s := StrTran( s, ">", ">" ) s := StrTran( s, '"', """ ) RETURN s /*----------------------------------------------------------------------*/ FUNCTION hbide_arrayToMemoHtml( a_ ) RETURN hbide_convertHtmlDelimiters( hbide_arrayToMemoEx( a_ ) ) /*----------------------------------------------------------------------*/ FUNCTION hbide_memoToArray( s ) LOCAL aLine := hb_ATokens( StrTran( RTrim( s ), Chr( 13 ) + Chr( 10 ), _EOL ), _EOL ) LOCAL nNewSize := 0 LOCAL line FOR EACH line IN aLine DESCEND IF ! Empty( line ) nNewSize := line:__enumIndex() EXIT ENDIF NEXT ASize( aLine, nNewSize ) RETURN aLine /*----------------------------------------------------------------------*/ FUNCTION hbide_isValidPath( cPath, cPathDescr ) DEFAULT cPathDescr TO '' IF hb_dirExists( cPath ) RETURN .T. ENDIF IF empty( cPathDescr ) MsgBox( 'The specified path is invalid "' + cPath + '"' ) ELSE //MsgBox( 'The specified path is invalid for ' + cPathDescr + ': "' + cPath + '"' ) MsgBox( 'The specified path is invalid for : "' + cPath + '"', cPathDescr ) ENDIF RETURN .F. /*----------------------------------------------------------------------*/ FUNCTION hbide_isValidText( cSourceFile ) LOCAL cExt hb_fNameSplit( cSourceFile, , , @cExt ) RETURN lower( cExt ) $ hbide_setIde():oINI:cTextFileExtensions /*----------------------------------------------------------------------*/ FUNCTION hbide_isValidSource( cSourceFile ) LOCAL cExt hb_fNameSplit( cSourceFile, , , @cExt ) RETURN lower( cExt ) $ ".c,.cpp,.prg,.res,.rc,.hb" /*----------------------------------------------------------------------*/ FUNCTION hbide_isSourcePPO( cSourceFile ) LOCAL cExt hb_fNameSplit( cSourceFile, , , @cExt ) RETURN lower( cExt ) == ".ppo" /*----------------------------------------------------------------------*/ FUNCTION hbide_isSourcePRG( cSourceFile ) LOCAL cExt hb_fNameSplit( cSourceFile, , , @cExt ) RETURN lower( cExt ) == ".prg" /*----------------------------------------------------------------------*/ FUNCTION hbide_sourceType( cSourceFile ) LOCAL cExt hb_fNameSplit( cSourceFile, , , @cExt ) RETURN lower( cExt ) /*----------------------------------------------------------------------*/ FUNCTION hbide_pathNormalized( cPath ) RETURN strtran( cPath, "\", "/" ) /*----------------------------------------------------------------------*/ FUNCTION hbide_pathFile( cPath, cFile ) cPath := iif( right( cPath, 1 ) $ "\/", substr( cPath, 1, Len( cPath ) - 1 ), cPath ) RETURN hbide_pathToOSPath( iif( empty( cPath ), cFile, cPath + "\" + cFile ) ) /*----------------------------------------------------------------------*/ FUNCTION hbide_pathStripLastSlash( cPath ) RETURN iif( right( cPath, 1 ) $ "\/", substr( cPath, 1, Len( cPath ) - 1 ), cPath ) /*----------------------------------------------------------------------*/ FUNCTION hbide_pathAppendLastSlash( cPath ) RETURN iif( right( cPath, 1 ) $ "\/", cPath, cPath + hb_ps() ) /*----------------------------------------------------------------------*/ FUNCTION hbide_pathToOSPath( cPath ) LOCAL n cPath := strtran( cPath, "//" , hb_ps() ) cPath := strtran( cPath, "/" , hb_ps() ) cPath := strtran( cPath, "\\" , hb_ps() ) cPath := strtran( cPath, "\" , hb_ps() ) IF ( n := at( ":", cPath ) ) > 0 cPath := substr( cPath, 1, n - 1 ) + substr( cPath, n ) ENDIF RETURN cPath /*----------------------------------------------------------------------*/ /* * This function fills an array with the list of regular expressions that will * identify the errors messages retrieved from during the build process. * 29/12/2009 - 12:43:26 - vailtom */ #define MSG_TYPE_ERR 1 #define MSG_TYPE_INFO 2 #define MSG_TYPE_WARN 3 #define CLR_MSG_ERR 'red' #define CLR_MSG_INFO 'brown' #define CLR_MSG_WARN 'blue' STATIC FUNCTION hbide_buildRegExpressList( aRegList ) AAdd( aRegList, { MSG_TYPE_WARN, hb_RegexComp( ".*: warning.*" ) } ) AAdd( aRegList, { MSG_TYPE_WARN, hb_RegexComp( ".*\) Warning W.*" ) } ) AAdd( aRegList, { MSG_TYPE_WARN, hb_RegexComp( "^Warning W([0-9]+).*" ) } ) AAdd( aRegList, { MSG_TYPE_ERR , hb_RegexComp( ".*: error.*" ) } ) AAdd( aRegList, { MSG_TYPE_ERR , hb_RegexComp( ".*\) Error E.*" ) } ) AAdd( aRegList, { MSG_TYPE_ERR , hb_RegexComp( "^Error E([0-9]+).*" ) } ) AAdd( aRegList, { MSG_TYPE_ERR , hb_RegexComp( "^Error: ." ) } ) AAdd( aRegList, { MSG_TYPE_ERR , hb_RegexComp( ".*:([0-9]+):([\w|\s]*)error.*" ) } ) AAdd( aRegList, { MSG_TYPE_ERR , hb_RegexComp( ".*:\(\.\w+\+.*\):.*" ) } ) AAdd( aRegList, { MSG_TYPE_ERR , hb_RegexComp( ".*: fatal\s.*" ) } ) AAdd( aRegList, { MSG_TYPE_INFO, hb_RegexComp( ".*: note.*" ) } ) AAdd( aRegList, { MSG_TYPE_INFO, hb_RegexComp( ".*: In function '.*" ) } ) AAdd( aRegList, { MSG_TYPE_INFO, hb_RegexComp( "^(\s*).*\s: see.*" ) } ) RETURN aRegList /*----------------------------------------------------------------------*//* * Catch source file name & line error from an msg status from compiler result. * 29/12/2009 - 13:22:29 - vailtom */ FUNCTION hbide_parseFNfromStatusMsg( cText, cFileName, nLine, lValidText ) LOCAL regLineN := hb_RegexComp( ".*(\(([0-9]+)\)|:([0-9]+):|\s([0-9]+):).*" ) LOCAL aList, nPos, cLine, n DEFAULT lValidText TO .T. cFileName := '' nLine := 0 /* Xbase++ */ IF "XBT" $ cText nPos := at( "(", cText ) n := at( ")", cText ) cFileName := substr( cText, 1, nPos - 1 ) cLine := substr( cText, nPos + 1, n - 1 - nPos ) n := at( ":", cLine ) cLine := substr( cLine, 1, n - 1 ) nLine := val( cLine ) RETURN !empty( cFileName ) ENDIF * Validate if current text is a error/warning/info message. * 29/12/2009 - 22:51:39 - vailtom IF lValidText nPos := aScan( aRegList, {| reg | !Empty( hb_RegEx( reg[ 2 ], cText ) ) } ) IF ( nPos <= 0 ) RETURN .F. ENDIF ENDIF aList := hb_RegEx( regLineN, cText ) IF !Empty( aList ) nLine := alltrim( aList[ 2 ] ) cText := Substr( cText, 1, At( nLine, cText ) - 1 ) cText := alltrim( cText ) + '(' nLine := strtran( nLine, ":", "" ) nLine := strtran( nLine, "(", "" ) nLine := strtran( nLine, ")", "" ) nLine := VAL( alltrim( nLine ) ) ENDIF IF ( nPos := hb_At( '(', cText ) ) > 0 cFileName := alltrim( Subst( cText, 1, nPos - 1 ) ) ELSE IF ( nPos := At( 'referenced from', Lower( cText ) ) ) != 0 cFileName := SubStr( cText, nPos + Len( 'referenced from' ) ) ELSE * GCC & MSVC filename detect... IF Subst( cText, 2, 1 ) == ':' nPos := hb_At( ':', cText, 3 ) ELSE nPos := hb_At( ':', cText ) ENDIF IF nPos != 0 cFileName := SubStr( cText, 1, nPos - 1 ) ENDIF ENDIF ENDIF cFileName := strtran( cFileName, "(", "" ) cFileName := strtran( cFileName, ")", "" ) cFileName := alltrim( cFileName ) cFileName := strtran( cFileName, "\\", "/" ) cFileName := strtran( cFileName, "\" , "/" ) IF ( nPos := Rat( ' ', cFileName ) ) != 0 cFileName := SubStr( cFileName, nPos + 1 ) ENDIF IF Subst( cFileName, 2, 1 ) == ':' nPos := hb_At( ':', cFileName, 3 ) ELSE nPos := hb_At( ':', cFileName ) ENDIF IF nPos != 0 cFileName := SubStr( cFileName, 1, nPos - 1 ) ENDIF cFileName := alltrim( cFileName ) RETURN !Empty( cFileName ) /*----------------------------------------------------------------------*/ /* * This function parses compiler result and hightlight errors & warnings using * regular expressions. (vailtom) * * More about Qt Color names: * http://www.w3.org/TR/SVG/types.html#ColorKeywords * * 28/12/2009 - 16:17:37 */ FUNCTION hbide_convertBuildStatusMsgToHtml( cText, oWidget ) LOCAL aColors := { CLR_MSG_ERR, CLR_MSG_INFO, CLR_MSG_WARN } LOCAL aLines, cIfError, cLine, nPos IF aRegList == NIL aRegList := {} hbide_BuildRegExpressList( aRegList ) ENDIF cText := StrTran( cText, Chr( 13 ) + Chr( 10 ), Chr( 10 ) ) cText := StrTran( cText, Chr( 13 ) , Chr( 10 ) ) cText := StrTran( cText, Chr( 10 ) + Chr( 10 ), Chr( 10 ) ) cText := StrTran( cText, " ", " " ) /* Convert some chars to valid HTML chars */ DO WHILE "<" $ cText cText := StrTran( cText, "<", "<" ) ENDDO DO WHILE ">" $ cText cText := StrTran( cText, ">", ">" ) ENDDO aLines := hb_aTokens( cText, Chr( 10 ) ) FOR EACH cLine IN aLines IF !Empty( cLine ) IF ( nPos := aScan( aRegList, {| reg | !Empty( hb_RegEx( reg[ 2 ], cLine ) ) } ) ) > 0 IF aRegList[ nPos,1 ] == MSG_TYPE_ERR cIfError := cLine ENDIF cLine := '' + cLine + '' ELSEIF "XBT" $ cLine cLine := '' + cLine + '' ELSE cLine := "" + cLine + "" ENDIF ENDIF oWidget:append( cLine ) NEXT RETURN cIfError /*----------------------------------------------------------------------*/ FUNCTION hbide_filesToSources( aFiles ) LOCAL aSrc := {} LOCAL s FOR EACH s IN aFiles IF hbide_isValidSource( s ) aadd( aSrc, s ) ENDIF NEXT RETURN aSrc /*----------------------------------------------------------------------*/ FUNCTION hbide_parseKeyValPair( s, cKey, cVal ) LOCAL n, lYes := .f. IF ( n := at( "=", s ) ) > 0 cKey := alltrim( substr( s, 1, n - 1 ) ) cVal := alltrim( substr( s, n + 1 ) ) lYes := ( !empty( cKey ) .and. !empty( cVal ) ) ENDIF RETURN lYes /*----------------------------------------------------------------------*/ FUNCTION hbide_parseFilter( s, cKey, cVal ) LOCAL n, n1, lYes := .f. IF ( n := at( "{", s ) ) > 0 IF ( n1 := at( "}", s ) ) > 0 cKey := alltrim( substr( s, n+1, n1-n-1 ) ) cVal := alltrim( substr( s, n1+1 ) ) lYes := .t. ENDIF ENDIF RETURN lYes /*----------------------------------------------------------------------*/ /* * Return the next untitled filename available. * 01/01/2010 - 19:40:17 - vailtom */ FUNCTION hbide_getNextUntitled() STATIC s_nCount := 0 RETURN ++s_nCount /*----------------------------------------------------------------------*/ /* * Return the next TAB_ID or IDE_ID available. * 02/01/2010 - 10:47:16 - vailtom */ FUNCTION hbide_getNextUniqueID() STATIC s_nCount := 0 IF s_nCount > 4294967295 s_nCount := 0 ENDIF RETURN ++s_nCount /*----------------------------------------------------------------------*/ FUNCTION hbide_getNextIDasString( cString ) STATIC hIDs := {=>} IF ! hb_hHasKey( hIDs, cString ) hIDs[ cString ] := 0 ENDIF RETURN cString + "_" + hb_ntos( ++hIDs[ cString ] ) /*----------------------------------------------------------------------*/ /* * Check if cFilename has a extension... and add cDefaultExt if not exist. * 01/01/2010 - 20:48:10 - vailtom */ FUNCTION hbide_checkDefaultExtension( cFileName, cDefaultExt ) LOCAL cPath, cFile, cExt hb_fNameSplit( cFileName, @cPath, @cFile, @cExt ) IF Empty( cExt ) cExt := cDefaultExt ENDIF RETURN cPath + hb_ps() + cFile + hb_ps() + cExt /*----------------------------------------------------------------------*/ function hbide_toString( x, lLineFeed, lInherited, lType, cFile, lForceLineFeed ) LOCAL s := '' LOCAL t := valtype( x ) LOCAL i, j DEFAULT lLineFeed TO .T. DEFAULT lInherited TO .F. DEFAULT lType TO .F. DEFAULT cFile TO "" DEFAULT lForceLineFeed TO .F. DO CASE CASE ( t == "C" ) s := iif( lType, "[C]=", "" ) + '"' + x + '"' CASE ( t == "N" ) s := iif( lType, "[N]=", "" ) + alltrim(str( x )) CASE ( t == "D" ) s := iif( lType, "[D]=", "" ) + "ctod('"+ dtoc(x) +"')" CASE ( t == "L" ) s := iif( lType, "[L]=", "" ) + iif( x, '.T.', '.F.' ) CASE ( t == "M" ) s := iif( lType, "[M]=", "" ) + '"' + x + '"' CASE ( t == "B" ) s := iif( lType, "[B]=", "" ) + '{|| ... }' CASE ( t == "U" ) s := iif( lType, "[U]=", "" ) + 'NIL' CASE ( t == "A" ) s := iif( lType, "[A]=", "" ) + "{" IF Len( x ) == 0 s += " " ELSE s += iif( valtype( x[1] ) == "A" .or. lForceLineFeed, hb_eol(), "" ) j := Len( x ) FOR i := 1 TO j s += iif( valtype( x[i] ) == "A", " ", " " ) + iif( lForceLineFeed, " ", "" ) + hbide_toString( x[i], .F. ) s += iif( i != j, ",", "" ) IF lLineFeed IF !lInherited .and. ( valtype( x[i] ) == "A" .or. lForceLineFeed ) s += hb_eol() ENDIF ENDIF NEXT ENDIF s += iif( !lForceLineFeed, " ", "" ) + "}" CASE ( t == "O" ) IF lInherited // E necessario linkar \harbour\lib\xhb.lib // s := iif( lType, "[O]=", "" ) + hb_dumpvar( x ) + iif( lLineFeed, hb_eol(), "" ) s := '' + iif( lLineFeed, hb_eol(), "" ) ELSE // s := iif( lType, "[O]=", "" ) + x:ClassName()+'():New()' + iif( lLineFeed, hb_eol(), "" ) s := iif( lType, "[O]=", "" ) + x:ClassName() + iif( lLineFeed, hb_eol(), "" ) ENDIF ENDCASE IF !empty( cFile ) memowrit( cFile, s ) ENDIF RETURN s /*----------------------------------------------------------------------*/ FUNCTION hbide_help( nOption ) LOCAL txt_ := {} LOCAL tit_ := '' SWITCH nOption CASE 1 tit_ := 'About hbIde' AAdd( txt_, "Harbour IDE ( HbIDE )" ) AAdd( txt_, "Developed by" ) AAdd( txt_, "Pritpal Bedi ( bedipritpal@hotmail.com )" ) AAdd( txt_, "" ) AAdd( txt_, "built with:" ) AAdd( txt_, HB_VERSION() ) AAdd( txt_, HB_COMPILER() ) AAdd( txt_, "Qt " + QT_VERSION_STR() ) AAdd( txt_, "" ) AAdd( txt_, "Visit the project website at:" ) AAdd( txt_, "http://harbour-project.org/" ) AAdd( txt_, "http://hbide.vouch.info/" ) EXIT CASE 2 tit_ := 'Mailing List' AAdd( txt_, "Harbour Development Mailing List" ) AAdd( txt_, "" ) AAdd( txt_, "Please visit the home page:" ) AAdd( txt_, "http://groups.google.com/group/harbour-devel/" ) EXIT CASE 3 tit_ := 'Mailing List' AAdd( txt_, "Harbour Users Mailing List" ) AAdd( txt_, "" ) AAdd( txt_, "Please visit the home page:" ) AAdd( txt_, "http://groups.google.com/group/harbour-users/" ) EXIT CASE 4 tit_ := 'About Harbour' AAdd( txt_, "About Harbour" ) AAdd( txt_, "" ) AAdd( txt_, '"Harbour is the Free Open Source Software implementation' ) AAdd( txt_, 'of a multi-platform, multi-threading, object-oriented, scriptable' ) AAdd( txt_, 'programming language, backwards compatible with Clipper/xBase.' ) AAdd( txt_, 'Harbour consists of a compiler and runtime libraries with multiple' ) AAdd( txt_, 'UI and database backends, its own make system and a large' ) AAdd( txt_, 'collection of libraries and interfaces to many popular APIs."' ) AAdd( txt_, "" ) AAdd( txt_, "Get downloads, samples, contribs and much more at:" ) AAdd( txt_, "http://harbour-project.org/" ) EXIT END IF !Empty( txt_ ) MsgBox( hbide_arrayToMemo( txt_ ), tit_ ) ENDIF RETURN nil /*----------------------------------------------------------------------*/ FUNCTION hbide_getUniqueFuncName() LOCAL t, b, c, n t := 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789' n := Len( t ) b := '' DO WHILE Len( b ) != 10 c := Substr( t, HB_RANDOMINT( 1, n ), 1 ) IF !( c $ b ) IF Empty( b ) .AND. IsDigit( c ) LOOP ENDIF b += c ENDIF ENDDO b += '( ' RETURN b /*----------------------------------------------------------------------*/ FUNCTION hbide_findProjTreeItem( oIde, cNodeText, cType ) LOCAL oItem, a_ FOR EACH a_ IN oIde:aProjData IF a_[ TRE_TYPE ] == cType .AND. a_[ TRE_OITEM ]:caption == cNodeText oItem := a_[ TRE_OITEM ] EXIT ENDIF NEXT RETURN oItem /*----------------------------------------------------------------------*/ FUNCTION hbide_expandChildren( oIde, oItem ) LOCAL a_ oItem:expand( .t. ) FOR EACH a_ IN oIde:aProjData IF a_[ TRE_OPARENT ] == oItem a_[ TRE_OITEM ]:expand( .t. ) ENDIF NEXT RETURN nil /*----------------------------------------------------------------------*/ FUNCTION hbide_collapseProjects( oIde ) LOCAL a_ FOR EACH a_ IN oIde:aProjData IF a_[ TRE_TYPE ] == "Project Name" a_[ TRE_OITEM ]:expand( .f. ) ENDIF NEXT RETURN nil /*----------------------------------------------------------------------*/ FUNCTION hbide_expandProjects( oIde ) LOCAL a_ FOR EACH a_ IN oIde:aProjData IF a_[ TRE_TYPE ] == "Project Name" hbide_expandChildren( oIde, a_[ TRE_OITEM ] ) ENDIF NEXT RETURN nil /*----------------------------------------------------------------------*/ FUNCTION hbide_buildLinesLabel( nFrom, nTo, nW, nMax ) LOCAL n, i, s := "" n := min( nMax, nTo - nFrom ) FOR i := 0 TO n IF ( ( nFrom + i ) % 10 ) == 0 s += "" + padl( hb_ntos( nFrom + i ), nW ) + "
" ELSE //s += padl( hb_ntos( nFrom + i ), nW ) + hb_eol() s += padl( hb_ntos( nFrom + i ), nW ) + "
" ENDIF NEXT RETURN s /*----------------------------------------------------------------------*/ FUNCTION hbide_parseMacros( cP ) LOCAL lHas, n, n1, cMacro IF !empty( cP ) DO WHILE .t. lHas := .f. IF ( n := at( "${" , cP ) ) > 0 IF ( n1 := at( "}" , cP ) ) > 0 lHas := .t. cMacro := substr( cP, n + 2, n1 - n - 2 ) cP := substr( cP, 1, n - 1 ) + hbide_macro2value( cMacro ) + substr( cP, n1 + 1 ) ENDIF ENDIF IF ! lHas EXIT ENDIF ENDDO ENDIF RETURN cP /*----------------------------------------------------------------------*/ FUNCTION hbide_macro2value( cMacro ) LOCAL cVal, cMacroL, oEdit, cFile, cPath, cExt LOCAL oIde := hbide_setIDE() cMacro := alltrim( cMacro ) cMacroL := lower( cMacro ) oEdit := oIde:oEM:getEditorCurrent() IF !empty( oEdit ) hb_fNameSplit( oEdit:sourceFile, @cPath, @cFile, @cExt ) ELSE cPath := ""; cFile := ""; cExt := "" ENDIF DO CASE CASE cMacroL == "source_fullname" cVal := hbide_pathToOSPath( cPath + cFile + cExt ) CASE cMacroL == "source_path" cVal := hbide_pathToOSPath( cPath ) CASE cMacroL == "source_fullname_less_ext" cVal := hbide_pathToOSPath( cPath + cFile ) CASE cMacroL == "source_name" cVal := cFile + cExt CASE cMacroL == "source_name_less_ext" cVal := cFile CASE cMacroL == "source_ext" cVal := cExt CASE cMacroL == "project_title" cVal := hbide_setProjectTitle() CASE cMacroL == "project_path" cVal := oIde:oPM:getProjectPathFromTitle( hbide_setProjectTitle() ) CASE cMacroL == "project_output_path" cVal := hbide_setProjectOutputPath() OTHERWISE cVal := hb_GetEnv( cMacro ) ENDCASE RETURN cVal /*----------------------------------------------------------------------*/ FUNCTION hbide_getShellCommandsTempFile( aCmd ) LOCAL cExt LOCAL fhnd LOCAL cCmdFileName LOCAL cCmdFile LOCAL tmp #if defined( __PLATFORM__WINDOWS ) cExt := ".bat" #elif defined( __PLATFORM__OS2 ) cExt := ".cmd" #elif defined( __PLATFORM__UNIX ) cExt := ".sh" #endif IF ! Empty( cExt ) cCmdFile := "" FOR EACH tmp IN aCmd tmp := hbide_parseMacros( tmp ) cCmdFile += tmp + hb_eol() NEXT IF ( fhnd := hb_FTempCreateEx( @cCmdFileName, NIL, NIL, cExt ) ) != F_ERROR FWrite( fhnd, cCmdFile ) FClose( fhnd ) ENDIF ENDIF RETURN cCmdFileName /*----------------------------------------------------------------------*/ FUNCTION hbide_getShellCommand() LOCAL cShellCmd #if defined( __PLATFORM__WINDOWS ) cShellCmd := hb_getenv( "COMSPEC" ) #elif defined( __PLATFORM__OS2 ) cShellCmd := hb_getenv( "COMSPEC" ) #elif defined( __PLATFORM__UNIX ) cShellCmd := hb_getenv( "SHELL" ) #endif RETURN cShellCmd /*----------------------------------------------------------------------*/ FUNCTION hbide_getOS() LOCAL cOS #if defined( __PLATFORM__WINDOWS ) cOS := "win" #elif defined( __PLATFORM__OS2 ) cOS := "os" #elif defined( __PLATFORM__UNIX ) cOS := "nix" #endif RETURN cOS /*----------------------------------------------------------------------*/ FUNCTION hbide_fetchADate( qParent, cTitle, cPrompt, dDefault ) LOCAL qDate, oUI, nRet DEFAULT cTitle TO "A Date Value" DEFAULT cPrompt TO "What" oUI := hbide_getUI( "fetchdate", qParent ) oUI:setWindowTitle( cTitle ) oUI:labelPrompt:setText( cPrompt ) IF dDefault != NIL qDate := QDate() qDate:setYear( year( dDefault ) ) qDate:setMonth( month( dDefault ) ) qDate:setDay( day( dDefault ) ) oUI:editDate:setDate( qDate ) ENDIF oUI:buttonOk:connect( "clicked()", {|| oUI:done( 1 ) } ) oUI:buttonCancel:connect( "clicked()", {|| oUI:done( 0 ) } ) nRet := oUI:exec() oUI:buttonOk:disconnect( "clicked()" ) oUI:buttonCancel:disconnect( "clicked()" ) IF nRet == 1 qDate := oUI:editDate:date() RETURN stod( strzero( qDate:year(), 4 ) + strzero( qDate:month(),2 ) + strzero( qDate:day(), 2 ) ) ENDIF RETURN NIL /*------------------------------------------------------------------------*/ FUNCTION hbide_fetchAString( qParent, cDefault, cWhat, cTitle ) LOCAL qGo, cText DEFAULT cDefault TO "" DEFAULT cWhat TO "" DEFAULT cTitle TO "A String Value" qGo := QInputDialog( qParent ) qGo:setTextValue( cDefault ) qGo:setLabelText( cWhat ) qGo:setWindowTitle( cTitle ) qGo:exec() cText := qGo:textValue() qGo:setParent( QWidget() ) RETURN cText /*----------------------------------------------------------------------*/ /* * Harbour Project source code: * * Copyright 2010 Viktor Szakats (harbour syenar.net) * www - http://harbour-project.org * */ #define HBIDE_HBP_PTYPE_FILES "files" #define HBIDE_HBP_PTYPE_OPTIONS "options" #define HBIDE_HBP_PTYPE_HBIDEPARAMS "hbideparams" FUNCTION hbide_fetchHbpData( cHBPFileName ) LOCAL aParamList aParamList := hbide_HBPGetParamList( cHBPFileName ) RETURN { hbide_HBPParamListFilter( aParamList, HBIDE_HBP_PTYPE_OPTIONS ), ; hbide_HBPParamListFilter( aParamList, HBIDE_HBP_PTYPE_FILES ) } /*----------------------------------------------------------------------*/ FUNCTION hbide_HBPParamListFilter( aParams, nType ) LOCAL aArray := {} LOCAL tmp LOCAL cParamNQ FOR EACH tmp IN aParams DO CASE CASE Lower( Left( tmp[ 1 ], 7 ) ) == "#hbide." IF nType == HBIDE_HBP_PTYPE_HBIDEPARAMS AAdd( aArray, tmp[ 1 ] ) ENDIF CASE Left( tmp[ 1 ], 1 ) == "#" /* misc comment line, always skip */ CASE Empty( tmp[ 1 ] ) /* empty line, always skip */ OTHERWISE cParamNQ := hbide_HBPStrStripQuote( tmp[ 1 ] ) IF Left( cParamNQ, 1 ) == "-" /* in conformance with hbmk2, skip remaining hbmk2 parameters if -skip is found */ IF Lower( cParamNQ ) == "-skip" .AND. ( nType == HBIDE_HBP_PTYPE_FILES .OR. nType == HBIDE_HBP_PTYPE_OPTIONS ) EXIT ENDIF IF nType == HBIDE_HBP_PTYPE_OPTIONS AAdd( aArray, cParamNQ ) ENDIF ELSE IF nType == HBIDE_HBP_PTYPE_FILES AAdd( aArray, cParamNQ ) ENDIF ENDIF ENDCASE NEXT RETURN aArray /*----------------------------------------------------------------------*/ /* Load entire .hbp files, with empty lines and comments for further processing. [vszakats] */ FUNCTION hbide_HBPGetParamList( cFileName ) LOCAL aParams := {} hbide_HBPLoad( aParams, cFileName ) RETURN aParams /*----------------------------------------------------------------------*/ /* Recursive .hbp/.hbm files are not currently supported. It can be added, but it makes updating the options much more complicated. [vszakats] */ #define HBIDE_HBP_EOL Chr( 10 ) STATIC PROCEDURE hbide_HBPLoad( aParams, cFileName ) LOCAL cFile LOCAL cLine LOCAL cParam LOCAl cParamNQ IF hb_FileExists( cFileName ) cFile := MemoRead( cFileName ) /* NOTE: Intentionally using MemoRead() which handles EOF char. */ IF ! hb_eol() == HBIDE_HBP_EOL cFile := StrTran( cFile, hb_eol(), HBIDE_HBP_EOL ) ENDIF IF ! hb_eol() == Chr( 13 ) + Chr( 10 ) cFile := StrTran( cFile, Chr( 13 ) + Chr( 10 ), HBIDE_HBP_EOL ) ENDIF FOR EACH cLine IN hb_ATokens( cFile, HBIDE_HBP_EOL ) IF Empty( cLine ) .OR. ; Left( cLine, 1 ) == "#" AAdd( aParams, { cLine, cFileName, cLine:__enumIndex() } ) ELSE FOR EACH cParam IN hb_ATokens( cLine,, .T. ) cParamNQ := hbide_HBPStrStripQuote( cParam ) IF ! Empty( cParamNQ ) #if 0 DO CASE CASE !( Left( cParamNQ, 1 ) == "-" ) .AND. Len( cParamNQ ) >= 1 .AND. Left( cParamNQ, 1 ) == "@" .AND. ; !( Lower( hbide_HBPExtGet( cParamNQ ) ) == ".clp" ) /* skip recurse */ CASE !( Left( cParamNQ, 1 ) == "-" ) .AND. ; ( Lower( hbide_HBPExtGet( cParamNQ ) ) == ".hbm" .OR. ; Lower( hbide_HBPExtGet( cParamNQ ) ) == ".hbp" ) /* skip recurse */ OTHERWISE AAdd( aParams, { cParam, cFileName, cLine:__enumIndex() } ) ENDCASE #endif AAdd( aParams, { cParam, cFileName, cLine:__enumIndex() } ) ENDIF NEXT ENDIF NEXT ENDIF RETURN /*----------------------------------------------------------------------*/ STATIC FUNCTION hbide_HBPStrStripQuote( cString ) RETURN iif( Left( cString, 1 ) == '"' .AND. Right( cString, 1 ) == '"',; SubStr( cString, 2, Len( cString ) - 2 ),; cString ) /*----------------------------------------------------------------------*/ STATIC FUNCTION hbide_HBPExtGet( cFileName ) LOCAL cExt hb_FNameSplit( cFileName, , , @cExt ) RETURN cExt /*----------------------------------------------------------------------*/ // /*----------------------------------------------------------------------*/ FUNCTION hbide_parseHbpFilter( s, cFilt, cPath ) LOCAL n, n1 cFilt := "" cPath := s IF ( n := at( "{", s ) ) > 0 IF ( n1 := at( "}", s ) ) > 0 cFilt := substr( s, n + 1, n1 - n + 1 ) cPath := alltrim( substr( s, n1 + 1 ) ) RETURN .t. ENDIF ENDIF RETURN .f. /*----------------------------------------------------------------------*/ FUNCTION hbide_outputLine( cLine, nOccur ) DEFAULT cLine TO "-" DEFAULT nOccur TO 100 RETURN "" + replicate( cLine, nOccur ) + "" /*----------------------------------------------------------------------*/ FUNCTION hbide_fetchSubPaths( aPaths, cRootPath, lSubs ) LOCAL aDir, a_ DEFAULT lSubs TO .t. IF !( right( cRootPath, 1 ) == hb_ps() ) cRootPath += hb_ps() ENDIF cRootPath := hbide_pathToOSPath( cRootPath ) aadd( aPaths, cRootPath ) IF lSubs aDir := directory( cRootPath + "*", "D" ) FOR EACH a_ IN aDir IF a_[ 5 ] == "D" .AND. !( left( a_[ 1 ], 1 ) == "." ) hbide_fetchSubPaths( @aPaths, cRootPath + a_[ 1 ] ) ENDIF NEXT ENDIF RETURN NIL /*----------------------------------------------------------------------*/ FUNCTION hbide_image( cName ) DEFAULT cName TO "" RETURN hbide_pathToOsPath( ":/resources" + "/" + cName + ".png" ) /*----------------------------------------------------------------------*/ FUNCTION hbide_uic( cName ) LOCAL tmp DEFAULT cName TO "" tmp := hbide_pathToOsPath( hb_DirBase() + "resources" + "/" + cName + ".uic" ) IF ! hb_FileExists( tmp ) MsgBox( "Error: File " + tmp + " is missing. Please check your installation." ) QUIT ENDIF RETURN tmp /*----------------------------------------------------------------------*/ FUNCTION hbide_ui( cName ) LOCAL tmp DEFAULT cName TO "" tmp := hbide_pathToOsPath( hb_DirBase() + "resources" + "/" + cName + ".ui" ) IF ! hb_FileExists( tmp ) MsgBox( "Error: File " + tmp + " is missing. Please check your installation." ) QUIT ENDIF RETURN tmp /*----------------------------------------------------------------------*/ FUNCTION hbide_isPrevParent( cRoot, cPath ) LOCAL cLRoot, cLPath cLRoot := hbide_pathNormalized( cRoot, .t. ) cLPath := hbide_pathNormalized( cPath, .t. ) IF hb_FileMatch( left( cLPath, Len( cLRoot ) ), cLRoot ) RETURN .t. ENDIF RETURN .f. /*----------------------------------------------------------------------*/ FUNCTION hbide_space2amp( cStr ) RETURN strtran( cStr, " ", chr( 38 ) ) /*----------------------------------------------------------------------*/ FUNCTION hbide_amp2space( cStr ) RETURN strtran( cStr, chr( 38 ), " " ) /*----------------------------------------------------------------------*/ FUNCTION hbide_stripFilter( cSrc ) LOCAL n, n1 DO WHILE .t. IF ( n := at( "{", cSrc ) ) == 0 EXIT ENDIF IF ( n1 := at( "}", cSrc ) ) == 0 EXIT ENDIF cSrc := substr( cSrc, 1, n - 1 ) + substr( cSrc, n1 + 1 ) ENDDO RETURN cSrc /*----------------------------------------------------------------------*/ FUNCTION hbide_stripRoot( cRoot, cPath ) LOCAL cLRoot, cLPath, cP IF !empty( cRoot ) .AND. ! ( right( cRoot, 1 ) $ "/\" ) cRoot += "/" ENDIF cLRoot := hbide_pathNormalized( cRoot, .t. ) cLPath := hbide_pathNormalized( cPath, .f. ) IF hb_FileMatch( left( lower( cLPath ), Len( cLRoot ) ), cLRoot ) cP := substr( cLPath, Len( cRoot ) + 1 ) RETURN cP ENDIF RETURN cPath /*----------------------------------------------------------------------*/ FUNCTION hbide_syncRoot( cRoot, cPath ) LOCAL cPth, cFile, cExt LOCAL cPathProc := hb_PathJoin( cPath, cRoot ) hb_fNameSplit( cPath, @cPth, @cFile, @cExt ) //HB_TRACE( HB_TR_DEBUG, "hbide_syncRoot( cRoot, cPath )", cPathProc, hbide_pathToOSpath( cPathProc + "/" + cFile + cExt ) ) RETURN hbide_pathToOSpath( cPathProc + "/" + cFile + cExt ) /*----------------------------------------------------------------------*/ FUNCTION hbide_array2cmdParams( aHbp ) LOCAL cCmd := " " aeval( aHbp, {|e| cCmd += e + " " } ) RETURN cCmd /*----------------------------------------------------------------------*/ FUNCTION hbide_syncProjPath( cRoot, cSource ) IF left( cSource, 1 ) $ "./\" .OR. substr( cSource, 2, 1 ) == ":" RETURN cSource ENDIF IF !empty( cRoot ) .AND. ! ( right( cRoot, 1 ) $ "/\" ) cRoot += "/" ENDIF RETURN cRoot + cSource /*----------------------------------------------------------------------*/ FUNCTION hbide_popupBrwContextMenu( qTextBrowser, p ) LOCAL aMenu := {} aadd( aMenu, { "Back" , {|| qTextBrowser:backward() } } ) aadd( aMenu, { "Forward" , {|| qTextBrowser:forward() } } ) aadd( aMenu, { "Home" , {|| qTextBrowser:home() } } ) aadd( aMenu, { "" } ) aadd( aMenu, { "Reload" , {|| qTextBrowser:reload() } } ) aadd( aMenu, { "" } ) aadd( aMenu, { "Select All", {|| qTextBrowser:selectAll() } } ) aadd( aMenu, { "Copy" , {|| qTextBrowser:copy() } } ) aadd( aMenu, { "Print" , {|| NIL } } ) RETURN hbide_execPopup( aMenu, qTextBrowser:mapToGlobal( QPoint( p ) ), qTextBrowser ) /*----------------------------------------------------------------------*/ FUNCTION hbide_groupSources( cMode, a_ ) LOCAL cTyp, s, d_, n LOCAL aSrc := { ".prg", ".c", ".cpp", ".h", ".ch", ".hbp", ".hbc", ".rc", ".res", ".obj", ".o", ".lib", ".a" } LOCAL aTxt := { {} , {} , {} , {} , {} , {} , {} , {} , {} , {} , {} , {} , {} } LOCAL aRst := {} IF cMode == "az" asort( a_, , , {|e,f| lower( hbide_stripFilter( e ) ) < lower( hbide_stripFilter( f ) ) } ) ELSEIF cMode == "za" asort( a_, , , {|e,f| lower( hbide_stripFilter( f ) ) < lower( hbide_stripFilter( e ) ) } ) ELSEIF cMode == "org" asort( a_, , , {|e,f| lower( hbide_stripFilter( e ) ) < lower( hbide_stripFilter( f ) ) } ) FOR EACH s IN a_ s := alltrim( s ) IF !( left( s, 1 ) == "#" ) cTyp := hbide_sourceType( s ) IF ( n := ascan( aSrc, {|e| cTyp == e } ) ) > 0 aadd( aTxt[ n ], s ) ELSE aadd( aRst, s ) ENDIF ENDIF NEXT a_:= {} FOR EACH d_ IN aTxt IF !empty( d_ ) FOR EACH s IN d_ aadd( a_, s ) NEXT ENDIF NEXT IF !empty( aRst ) FOR EACH s IN aRst aadd( a_, s ) NEXT ENDIF ENDIF RETURN a_ /*----------------------------------------------------------------------*/ FUNCTION hbide_imageForProjectType( cType ) cType := left( cType, 8 ) RETURN iif( cType == "Lib", "fl_lib", iif( cType == "Dll", "fl_dll", "fl_exe" ) ) /*----------------------------------------------------------------------*/ FUNCTION hbide_imageForFileType( cType ) cType := lower( cType ) SWITCH cType CASE ".exe" RETURN "fl_exe" CASE ".lib" CASE ".a" RETURN "fl_lib" CASE ".rc" CASE ".res" RETURN "source_res" //"fl_res" CASE ".prg" RETURN "source_prg" //"fl_prg" CASE ".c" RETURN "source_c" CASE ".cpp" RETURN "source_cpp" //"fl_c" CASE ".o" CASE ".obj" RETURN "source_o" //"fl_obj" CASE ".hbp" RETURN "project" CASE ".hbc" RETURN "envconfig" CASE ".h" CASE ".ch" RETURN "source_h" OTHERWISE RETURN "source_unknown" //"fl_txt" ENDSWITCH RETURN NIL /*----------------------------------------------------------------------*/ FUNCTION hbide_array2string( a_, cDlm ) LOCAL s := "" aeval( a_, {|e| s += e + cDlm } ) RETURN s /*----------------------------------------------------------------------*/ FUNCTION hbide_nArray2string( a_ ) LOCAL cString := "" LOCAL n FOR EACH n IN a_ cString += hb_ntos( n ) cString += " " NEXT RETURN cString /*----------------------------------------------------------------------*/ FUNCTION hbide_string2nArray( s ) LOCAL b_, a_:= {} b_:= hb_atokens( s, " " ) FOR EACH s IN b_ s := alltrim( s ) IF Len( s ) > 0 aadd( a_, val( s ) ) ENDIF NEXT RETURN a_ /*----------------------------------------------------------------------*/ FUNCTION hbide_array2rect( a_ ) RETURN QRect( a_[ 1 ], a_[ 2 ], a_[ 3 ], a_[ 4 ] ) /*----------------------------------------------------------------------*/ FUNCTION hbide_parseSourceComponents( cCompositeSource ) LOCAL a_ a_:= hb_atokens( cCompositeSource, "," ) asize( a_, 7 ) DEFAULT a_[ 1 ] TO "" DEFAULT a_[ 2 ] TO "" DEFAULT a_[ 3 ] TO "" DEFAULT a_[ 4 ] TO "" DEFAULT a_[ 5 ] TO "" DEFAULT a_[ 6 ] TO "Main" DEFAULT a_[ 7 ] TO "" // a_[ 1 ] := alltrim( a_[ 1 ] ) a_[ 2 ] := val( alltrim( a_[ 2 ] ) ) a_[ 3 ] := val( alltrim( a_[ 3 ] ) ) a_[ 4 ] := val( alltrim( a_[ 4 ] ) ) a_[ 5 ] := alltrim( a_[ 5 ] ) a_[ 6 ] := alltrim( a_[ 6 ] ) a_[ 7 ] := hbide_string2nArray( a_[ 7 ] ) RETURN a_ /*----------------------------------------------------------------------*/ FUNCTION hbide_parseUserToolbarComponents( cCompositeTool ) LOCAL a_ a_:= hb_atokens( cCompositeTool, "," ) asize( a_, 7 ) DEFAULT a_[ 1 ] TO "" DEFAULT a_[ 2 ] TO "" DEFAULT a_[ 3 ] TO "" DEFAULT a_[ 4 ] TO "" DEFAULT a_[ 5 ] TO "" DEFAULT a_[ 6 ] TO "" DEFAULT a_[ 7 ] TO "" a_[ 1 ] := alltrim( a_[ 1 ] ) a_[ 2 ] := alltrim( a_[ 2 ] ) a_[ 3 ] := alltrim( a_[ 3 ] ) a_[ 4 ] := alltrim( a_[ 4 ] ) a_[ 5 ] := alltrim( a_[ 5 ] ) a_[ 6 ] := alltrim( a_[ 6 ] ) a_[ 7 ] := alltrim( a_[ 7 ] ) RETURN a_ /*----------------------------------------------------------------------*/ FUNCTION hbide_parseToolComponents( cCompositeTool ) LOCAL a_ a_:= hb_atokens( cCompositeTool, "," ) asize( a_, 12 ) DEFAULT a_[ 1 ] TO "" DEFAULT a_[ 2 ] TO "" DEFAULT a_[ 3 ] TO "" DEFAULT a_[ 4 ] TO "" DEFAULT a_[ 5 ] TO "" DEFAULT a_[ 6 ] TO "" DEFAULT a_[ 7 ] TO "-1" DEFAULT a_[ 8 ] TO "YES" DEFAULT a_[ 9 ] TO "" DEFAULT a_[10 ] TO "" DEFAULT a_[11 ] TO "" DEFAULT a_[12 ] TO "" a_[ 1 ] := alltrim( a_[ 1 ] ) a_[ 2 ] := alltrim( a_[ 2 ] ) a_[ 3 ] := alltrim( a_[ 3 ] ) a_[ 4 ] := alltrim( a_[ 4 ] ) a_[ 5 ] := alltrim( a_[ 5 ] ) a_[ 6 ] := alltrim( a_[ 6 ] ) a_[ 7 ] := alltrim( a_[ 7 ] ) a_[ 8 ] := alltrim( a_[ 8 ] ) a_[ 9 ] := alltrim( a_[ 9 ] ) a_[10 ] := alltrim( a_[10 ] ) a_[11 ] := alltrim( a_[11 ] ) a_[12 ] := alltrim( a_[12 ] ) RETURN a_ /*----------------------------------------------------------------------*/ FUNCTION hbide_parseKeywordsComponents( cStr ) LOCAL a_ a_:= hb_atokens( cStr, "~" ) asize( a_, 2 ) DEFAULT a_[ 1 ] TO "" DEFAULT a_[ 2 ] TO "" a_[ 1 ] := alltrim( a_[ 1 ] ) a_[ 2 ] := alltrim( a_[ 2 ] ) RETURN a_ /*----------------------------------------------------------------------*/ FUNCTION hbide_parseThemeComponent( cComponent ) LOCAL i, a_, n a_:= hb_aTokens( cComponent, "," ) aSize( a_, 6 ) DEFAULT a_[ 1 ] TO "" DEFAULT a_[ 2 ] TO "" DEFAULT a_[ 3 ] TO "" DEFAULT a_[ 4 ] TO "" DEFAULT a_[ 5 ] TO "" DEFAULT a_[ 6 ] TO "" a_[ 1 ] := alltrim( a_[ 1 ] ) a_[ 2 ] := alltrim( a_[ 2 ] ) a_[ 3 ] := alltrim( a_[ 3 ] ) a_[ 4 ] := alltrim( a_[ 4 ] ) a_[ 5 ] := alltrim( a_[ 5 ] ) a_[ 6 ] := alltrim( a_[ 6 ] ) FOR i := 2 TO 6 IF !empty( a_[ i ] ) a_[ i ] := hb_aTokens( a_[ i ], " " ) FOR EACH n IN a_[ i ] n := val( n ) NEXT ELSE a_[ i ] := {} ENDIF NEXT RETURN a_ /*----------------------------------------------------------------------*/ FUNCTION hbide_SetWrkFolderLast( cPathFile ) LOCAL cPth, cOldPath STATIC cPath IF empty( cPath ) cPath := hb_dirBase() ENDIF cOldPath := cPath IF HB_ISSTRING( cPathFile ) hb_fNameSplit( cPathFile, @cPth ) cPath := cPth ENDIF RETURN cOldPath /*----------------------------------------------------------------------*/ FUNCTION hbide_getUI( cUI, qParent ) IF hbide_setIde():nModeUI == UI_MODE_FUNC SWITCH Lower( cUI ) CASE "findinfilesex" ; RETURN hbqtui_Findinfilesex( qParent ) CASE "updown" ; RETURN hbqtui_UpDown( qParent ) CASE "updown_v" ; RETURN hbqtui_UpDown_v( qParent ) CASE "searchreplace" ; RETURN hbqtui_SearchReplace( qParent ) CASE "finddialog" ; RETURN hbqtui_FindDialog( qParent ) CASE "environments" ; RETURN hbqtui_Environments( qParent ) CASE "environ" ; RETURN hbqtui_Environ( qParent ) CASE "shortcuts" ; RETURN hbqtui_Shortcuts( qParent ) CASE "docwriter" ; RETURN hbqtui_Docwriter( qParent ) CASE "toolsutilities" ; RETURN hbqtui_Toolsutilities( qParent ) CASE "funclist" ; RETURN hbqtui_Funclist( qParent ) CASE "docviewgenerator" ; RETURN hbqtui_Docviewgenerator( qParent ) CASE "selectproject" ; RETURN hbqtui_Selectproject( qParent ) CASE "projectpropertiesex" ; RETURN hbqtui_Projectpropertiesex( qParent ) CASE "selectionlist" ; RETURN hbqtui_Selectionlist( qParent ) CASE "themesex" ; RETURN hbqtui_Themesex( qParent ) CASE "setup" ; RETURN hbqtui_Setup( qParent ) CASE "mainwindow" ; RETURN hbqtui_Mainwindow( qParent ) CASE "skeletons" ; RETURN hbqtui_Skeletons( qParent ) CASE "editor" ; RETURN hbqtui_Editor( qParent ) CASE "dbstruct" ; RETURN hbqtui_DbStruct( qParent ) CASE "fetchdate" ; RETURN hbqtui_FetchDate( qParent ) CASE "tables" ; RETURN hbqtui_Tables( qParent ) CASE "format" ; RETURN hbqtui_Format( qParent ) CASE "changelog" ; RETURN hbqtui_Changelog( qParent ) ENDSWITCH ENDIF RETURN NIL /*----------------------------------------------------------------------*/ /* An interface component function which will be called by Reports Manager whenever a request is made. Application will supply the required info in this case it is hbIDE. */ FUNCTION app_image( cName ) RETURN hbide_image( cName ) /*----------------------------------------------------------------------*/ FUNCTION hbide_isCompilerSource( cSource, cIncList ) LOCAL cExt, aExt DEFAULT cIncList TO ".c,.cpp,.prg,.hb,.rc,.res,.hbm,.hbc,.qrc,.ui,.hbp" cIncList := lower( cIncList ) aExt := hb_aTokens( lower( cIncList ), "," ) hb_FNameSplit( cSource, , , @cExt ) cExt := lower( cExt ) RETURN ascan( aExt, {|e| cExt == e } ) > 0 /*----------------------------------------------------------------------*/ FUNCTION hbide_prepareSourceForHbp( cSource ) IF ! empty( cSource ) .AND. !( left( cSource,1 ) $ "-#" ) .AND. ! lower( left( cSource, 5 ) ) == "-3rd=" IF ! hbide_isCompilerSource( cSource ) RETURN "-3rd=hbide_file=" + cSource ENDIF ENDIF RETURN cSource /*----------------------------------------------------------------------*/ FUNCTION hbide_synchronizeForHbp( aHbp ) LOCAL s LOCAL txt_:={} FOR EACH s IN aHbp aadd( txt_, hbide_prepareSourceForHbp( s ) ) NEXT RETURN txt_ /*----------------------------------------------------------------------*/ FUNCTION hbide_setClose( lYes ) LOCAL yes STATIC sYes := .f. yes := sYes IF HB_ISLOGICAL( lYes ) sYes := lYes ENDIF RETURN yes /*----------------------------------------------------------------------*/ FUNCTION hbide_setAdsAvailable( lYes ) LOCAL yes STATIC sYes := .f. yes := sYes IF HB_ISLOGICAL( lYes ) sYes := lYes ENDIF RETURN yes /*----------------------------------------------------------------------*/