/*
* getConfigFilePaths - get the path to the directory containing the config files
* shfolder.dll is loaded explicitly for compatability with Win98 -- calling
* SHGetFolderPathA directly doesn't work, probably due to order of linking
*/
static void getConfigFilePaths( void )
{
char path[FILENAME_MAX];
#ifdef __NT__
HINSTANCE library = LoadLibrary( "shfolder.dll" );
if ( library ) {
GetFolderPath getpath = (GetFolderPath)GetProcAddress( library,
"SHGetFolderPathA" );
if( SUCCEEDED( getpath( NULL, CSIDL_APPDATA | CSIDL_FLAG_CREATE, NULL, 0,
path ) ) ) {
if( strlen( path ) + strlen( "\\" CONFIG_DIR ) + 12 < FILENAME_MAX ) {
strcat( path, "\\" CONFIG_DIR );
if( access( path, F_OK ) ) { /* make sure CONFIG_DIR diretory is present */
mkdir( path ); /* if not, create it */
}
}
}
FreeLibrary( library );
}
else { /* should only get here on old machines */
GetWindowsDirectory( path, FILENAME_MAX ); /* that don't have shfolder.dll */
}
#else
GetWindowsDirectory( path, FILENAME_MAX );
#endif
AddString2( &iniPath, path ); /* these freed in WriteProfile */
VarAddGlobalStr( "IniPath", iniPath ); /* make accessable to scripts */
strcat( path, "\\" INI_FILE );
AddString2( &iniFile, path);
strcpy( path, iniPath );
strcat( path, "\\" CONFIG_INI );
AddString2( &cfgFile, path);
} /* getConfigFilePaths */
/*
* VerifyTmpDir - make sure TmpDir is valid
*/
void VerifyTmpDir( void )
{
int i;
char *env_tmpdir;
if( EditVars.TmpDir != NULL ) {
i = strlen( EditVars.TmpDir ) - 1;
if( EditVars.TmpDir[i] == FILE_SEP && i > 2 ) {
/* this sucks -- we need the '\' IFF it is [drive]:\ */
EditVars.TmpDir[i] = 0;
}
if( IsDirectory( EditVars.TmpDir ) ) {
/* strip the following file_sep char for [drive]:\ */
if( EditVars.TmpDir[i] == FILE_SEP ) {
EditVars.TmpDir[i] = 0;
}
return;
}
}
env_tmpdir = getenv( "tmp" );
if( env_tmpdir != NULL ) {
if( env_tmpdir[strlen( env_tmpdir ) - 1] == '\\' ) {
char buf[FILENAME_MAX];
strcpy( buf, env_tmpdir );
buf[strlen( buf ) - 1] = '\0';
AddString2( &EditVars.TmpDir, buf );
} else {
AddString2( &EditVars.TmpDir, env_tmpdir );
}
} else {
// _mkdir( altTmpDir, DIRFLAGS );
AddString2( &EditVars.TmpDir, altTmpDir );
}
} /* VerifyTmpDir */
static void dlgDataToGlobal( dlg_data *data )
{
LangInit( data->Language );
EditFlags.PPKeywordOnly = data->PPKeywordOnly;
EditFlags.CMode = data->CMode;
EditFlags.ReadEntireFile = data->ReadEntireFile;
EditFlags.ReadOnlyCheck = data->ReadOnlyCheck;
EditFlags.IgnoreCtrlZ = data->IgnoreCtrlZ;
EditFlags.CRLFAutoDetect = data->CRLFAutoDetect;
EditFlags.WriteCRLF = data->WriteCRLF;
EditFlags.EightBits = data->EightBits;
EditFlags.RealTabs = data->RealTabs;
EditFlags.AutoIndent = data->AutoIndent;
EditFlags.IgnoreTagCase = data->IgnoreTagCase;
EditFlags.TagPrompt = data->TagPrompt;
EditFlags.ShowMatch = data->ShowMatch;
EditVars.TabAmount = data->TabAmount;
EditVars.HardTab = data->HardTab;
EditVars.ShiftWidth = data->ShiftWidth;
/*
* language specific variables with extra handling
*/
if( strcmp( EditVars.TagFileName, data->TagFileName ) ) {
AddString2( &EditVars.TagFileName, data->TagFileName );
}
if( strcmp( EditVars.GrepDefault, data->GrepDefault ) ) {
AddString2( &EditVars.GrepDefault, data->GrepDefault );
}
}
/*
* SetGadgetString
*/
void SetGadgetString( char *str )
{
if( str == NULL ) {
if( GadgetString == NULL ) {
AddString2( &GadgetString, WindowBordersG );
}
return;
}
if( strlen( str ) < strlen( WindowBordersG ) ) {
AddString2( &GadgetString, WindowBordersG );
} else {
AddString2( &GadgetString, str );
}
} /* SetGadgetString */
/*
* updateHist - add a string to a history list
*/
static void updateHist( history_data *hist, char *str )
{
if( hist->curr < hist->max ) {
AddString2( &hist->data[hist->curr], str );
hist->curr++;
}
} /* updateHist */
/*
* LoadHistory - load history from file
*/
void LoadHistory( char *cmd )
{
FILE *f;
char str[MAX_INPUT_LINE];
int cnt;
read_state rs;
int i;
historyLoaded = true;
while( EditVars.HistoryFile != NULL ) {
f = fopen( EditVars.HistoryFile, "rt" );
if( f == NULL ) {
break;
}
cnt = 0;
rs = READ_NONE;
while( fgets( str, MAX_INPUT_LINE, f ) != NULL ) {
for( i = strlen( str ); i && isWSorCtrlZ( str[i - 1 ]); --i ) {
str[i - 1] = 0;
}
if( cnt == 0 ) {
cnt = atoi( str );
rs++;
if( rs >= READ_LAST ) {
break;
}
continue;
}
switch( rs ) {
case READ_CMD:
updateHist( &EditVars.CLHist, str );
break;
case READ_FIND:
updateHist( &EditVars.FindHist, str );
break;
case READ_FILTER:
updateHist( &EditVars.FilterHist, str );
break;
case READ_LASTFILES:
updateHist( &EditVars.LastFilesHist, str );
break;
}
cnt--;
}
fclose( f );
break;
}
if( cmd != NULL ) {
AddString2( &EditVars.CLHist.data[EditVars.CLHist.curr % EditVars.CLHist.max], cmd );
EditVars.CLHist.curr++;
}
} /* LoadHistory */
vi_rc DoHelp( char *data )
{
char *hfile;
char *tstr;
int token;
vi_rc rc;
char path[FILENAME_MAX];
char tmp[MAX_STR];
int i;
RemoveLeadingSpaces( data );
token = Tokenize( helpCmds, data, false );
if( token == TOK_INVALID ) {
if( data[0] == 0 ) {
strcpy( tmp, "Topics: " );
for( i = 0; i < nHelpFiles; i++ ) {
if( i != 0 ) {
strcat( tmp, ", " );
}
strcat( tmp, GetTokenString( helpCmds, i ) );
}
Message1( "%s", tmp );
} else {
Error( "No help on topic %s", data );
}
return( DO_NOT_CLEAR_MESSAGE_WINDOW );
}
hfile = helpFiles[token];
GetFromEnv( hfile, path );
if( path[0] == 0 ) {
Error( "Help file %s not found", hfile );
return( DO_NOT_CLEAR_MESSAGE_WINDOW );
}
EditFlags.ViewOnly = true;
rc = EditFile( path, false );
EditFlags.ViewOnly = false;
if( rc != ERR_NO_ERR ) {
return( rc );
}
tstr = GetTokenString( helpCmds, token );
strcpy( tmp, tstr );
strlwr( tmp );
strcat( tmp, " Help" );
tmp[0] = toupper( tmp[0] );
CurrentFile->read_only = false;
AddString2( &(CurrentFile->name), tmp );
SetFileWindowTitle( CurrentWindow, CurrentInfo, true );
DisplayFileStatus();
return( ERR_NO_ERR );
} /* DoHelp */
/*
* WindowBorderData - set up window border data
*/
void WindowBorderData( window_id wn, char *data, int col )
{
wind *w;
w = Windows[wn];
if( !w->has_border ) {
return;
}
AddString2( &(w->borderdata), data );
w->bordercol = col;
} /* WindowBorderData */
static vi_rc getFile( char *fname )
{
char dir[MAX_STR];
char *dirptr, ch;
vi_rc rc;
NextWord1( fname, dir );
rc = EditFile( dir, FALSE );
if( rc != ERR_NO_ERR ) {
return( rc );
}
dirptr = dir;
if( isFgrep ) {
if( caseIgn ) {
ch = '~';
} else {
ch = '@';
}
dirptr += 2;
strcpy( dirptr, origString );
MakeExpressionNonRegular( dirptr );
dirptr--;
*dirptr = ch;
if( IsMagicCharRegular( ch ) ) {
dirptr--;
*dirptr = '\\';
}
} else {
strcpy( dir, origString );
}
AddString2( &(EditVars.FindHist.data[EditVars.FindHist.curr % EditVars.FindHist.max] ), origString );
EditVars.FindHist.curr += 1;
ColorFind( dirptr, FINDFL_NOERROR );
SetLastFind( origString );
return( rc );
}
/*
* AutoSaveInit - initialize for auto-save
*/
void AutoSaveInit( void )
{
char path[FILENAME_MAX];
char path2[FILENAME_MAX];
char as_path[FILENAME_MAX];
char asl_path[FILENAME_MAX];
int len;
int cnt;
FILE *f;
int pid;
int ch;
int handle;
int off;
// int old_len;
int i;
/*
* initialize tmpname
*/
#ifdef __UNIX__
strcpy( currTmpName,"aaaaaaaaaaaa.tmp" );
#else
strcpy( currTmpName,"aaaaaaaa.tmp" );
#endif
pid = getpid();
itoa( pid, path, 36 );
len = strlen( path );
memcpy( &currTmpName[TMP_FNAME_LEN - len], path, len );
#ifdef __QNX__
{
int len2, len3;
int nid, uid;
nid = getnid();
itoa( nid, path, 36 );
len2 = strlen( path );
memcpy( &currTmpName[TMP_FNAME_LEN - len - len2], path, len2 );
uid = getuid();
itoa( uid, path, 36 );
len3 = strlen( path );
memcpy( &currTmpName[TMP_FNAME_LEN - len - len2 - len3], path, len3 );
memcpy( &checkFileName[EXTRA_EXT_OFF], path, len3 );
memcpy( &checkFileTmpName[EXTRA_EXT_OFF], path, len3 );
memcpy( &lockFileName[EXTRA_EXT_OFF], path, len3 );
}
#endif
/*
* check if we need to recover lost files
*/
if( EditFlags.RecoverLostFiles ) {
cnt = 0;
MakeTmpPath( as_path, checkFileName );
MakeTmpPath( asl_path, lockFileName );
off = strlen( as_path ) - 5;
for( ch = START_CHAR; ch <= END_CHAR; ch++ ) {
as_path[off] = ch;
asl_path[off] = ch;
handle = sopen3( as_path, O_RDONLY | O_TEXT, SH_DENYRW );
if( handle < 0 ) {
continue;
}
f = fdopen( handle, "r" );
if( f != NULL ) {
while( fgets( path2, FILENAME_MAX, f ) != NULL ) {
for( i = strlen( path2 ); i && isWSorCtrlZ( path2[i - 1] ); --i ) {
path2[i - 1] = '\0';
}
NextWord1( path2, path );
RemoveLeadingSpaces( path2 );
NewFile( path, FALSE );
AddString2( &(CurrentFile->name), path2 );
SetFileWindowTitle( CurrentWindow, CurrentInfo, TRUE );
FileSPVAR();
CurrentFile->modified = TRUE;
CurrentFile->check_readonly = TRUE;
FTSRunCmds( path2 );
cnt++;
}
fclose( f );
remove( as_path );
} else {
close( handle );
}
remove( asl_path );
}
if( cnt == 0 ) {
MyPrintf( "No files recovered!\n" );
ExitEditor( -1 );
}
Message1( "%d files recovered", cnt );
}
if( EditVars.AutoSaveInterval == 0 ) {
return;
}
// old_len = strlen( lockFileName );
MakeTmpPath( path, lockFileName );
len = strlen( path ) - strlen( lockFileName );
off = len + CHAR_OFF;
for( ch = START_CHAR; ch <= END_CHAR; ch++ ) {
path[off] = ch;
lockFileHandle = sopen4( path, O_CREAT | O_TRUNC | O_RDWR | O_TEXT, SH_DENYRW, PMODE_RW );
if( lockFileHandle > 0 ) {
break;
}
}
if( lockFileHandle < 0 ) {
// MyPrintf( "Too many editors running!\n" );
MyPrintf( "Error opening temp file - '%s'\n", strerror( errno ) );
ExitEditor( -1 );
}
lockFileName[CHAR_OFF] = ch;
checkFileName[CHAR_OFF] = ch;
checkFileTmpName[CHAR_OFF] = ch;
} /* AutoSaveInit */
/*
* CmdDlgProc - callback routine for command dialog
*/
BOOL WINEXP CmdDlgProc( HWND hwnd, UINT msg, UINT wparam, LONG lparam )
{
int curr;
int i;
int cmd;
DWORD index;
char str[MAX_INPUT_LINE];
history_data *h;
char *ptr;
lparam = lparam;
switch( msg ) {
case WM_INITDIALOG:
CenterWindowInRoot( hwnd );
EditSubClass( hwnd, CMD_EDIT, &CLHist );
SetDlgItemText( hwnd, CMD_EDIT, cmdStr );
curr = CLHist.curr + CLHist.max - 1;
for( i = 0; i < CLHist.max; i++ ) {
if( CLHist.data[curr % CLHist.max] != NULL ) {
SendDlgItemMessage( hwnd, CMD_LISTBOX, LB_ADDSTRING, 0,
(LONG) CLHist.data[curr % CLHist.max] );
}
curr--;
if( curr < 0 ) {
break;
}
}
return( TRUE );
case WM_CLOSE:
PostMessage( hwnd, WM_COMMAND, IDCANCEL, 0L );
return( TRUE );
case WM_COMMAND:
switch( LOWORD( wparam ) ) {
case CMD_LISTBOX:
cmd = GET_WM_COMMAND_CMD( wparam, lparam );
if( cmd == LBN_SELCHANGE || cmd == LBN_DBLCLK ) {
index = SendDlgItemMessage( hwnd, CMD_LISTBOX, LB_GETCURSEL, 0, 0L );
if( index == LB_ERR ) {
break;
}
SendDlgItemMessage( hwnd, CMD_LISTBOX, LB_GETTEXT, index, (LONG) str );
SetDlgItemText( hwnd, CMD_EDIT, str );
if( cmd == LBN_DBLCLK ) {
PostMessage( hwnd, WM_COMMAND, IDOK, 0L );
}
}
break;
case IDCANCEL:
RemoveEditSubClass( hwnd, CMD_EDIT );
EndDialog( hwnd, FALSE );
break;
case IDOK:
GetDlgItemText( hwnd, CMD_EDIT, cmdStr, cmdLen );
h = &CLHist;
curr = h->curr + h->max - 1;
ptr = NULL;
if( curr >= 0 ) {
ptr = h->data[curr % h->max];
}
if( ptr == NULL || strcmp( ptr, cmdStr ) ) {
AddString2( &(h->data[h->curr % h->max]), cmdStr );
h->curr += 1;
}
RemoveEditSubClass( hwnd, CMD_EDIT );
EndDialog( hwnd, TRUE );
break;
default:
return( FALSE );
}
return( TRUE );
}
return( FALSE );
} /* CmdDlgProc */
/*
* FancyDoReplace - get strings, search for one, replace with other
*/
vi_rc FancyDoReplace( void )
{
#ifdef __WIN__
static char *lastReplace;
vi_rc rc;
char find[MAX_INPUT_LINE + 1], replace[MAX_INPUT_LINE + 1];
fancy_find ff;
bool is_forward = TRUE;
bool old_ci;
bool old_sw;
if( CurrentFile == NULL ) {
// you cant search if theres no file!
return( ERR_NO_FILE );
}
old_ci = EditFlags.CaseIgnore;
old_sw = EditFlags.SearchWrap;
if( lastFind != NULL ) {
strcpy( find, lastFind );
ff.use_regexp = lastFindWasRegExp;
ff.case_ignore = lastFindWasCaseIgnore;
ff.search_forward = is_forward;
ff.search_wrap = lastFindWasWrap;
} else {
find[0] = 0;
}
if( lastReplace != NULL ) {
strcpy( replace, lastReplace );
} else {
replace[0] = 0;
}
ff.find = find;
ff.findlen = sizeof( find );
ff.replace = replace;
ff.replacelen = sizeof( replace );
if( !GetReplaceStringDialog( &ff ) ) {
return( ERR_NO_ERR );
}
EditFlags.CaseIgnore = ff.case_ignore;
EditFlags.SearchWrap = ff.search_wrap;
if( !ff.use_regexp ) {
MakeExpressionNonRegular( find );
// MakeExpressionNonRegular( replace );
}
AddString2( &lastReplace, replace );
EditFlags.LastSearchWasForward = is_forward;
/*NOTE: does not use is_forward (how about %s?this/that/?)
does not use selection_only
*/
rc = TwoPartSubstitute( find, replace, ff.prompt, ff.search_wrap );
EditFlags.CaseIgnore = old_ci;
EditFlags.SearchWrap = old_sw;
lastFindWasRegExp = ff.use_regexp;
lastFindWasCaseIgnore = ff.case_ignore;
lastFindWasForward = ff.search_forward;
lastFindWasWrap = ff.search_wrap;
return( rc );
#else
return( ERR_NO_ERR );
#endif
} /* FancyDoReplace */
/*
* SetLastFind - set the last find string
*/
void SetLastFind( char* newLastFind )
{
AddString2( &lastFind, newLastFind );
} /* SetLastFind */
/*
* setLineCol - set up line and column to start search at
*/
static vi_rc setLineCol( char *st, i_mark *pos, find_type flags )
{
fcb *cfcb;
line *cline;
bool wrapped;
/*
* get next position
*/
if( st[0] == 0 ) {
if( lastFind == NULL ) {
return( ERR_NO_PREVIOUS_SEARCH_STRING );
}
if( lastPos.line != 0 && currPos.column == CurrentPos.column &&
currPos.line == CurrentPos.line ) {
*pos = lastPos;
if( flags & FINDFL_FORWARD ) {
pos->column += 1;
} else {
pos->column -= 2;
}
} else {
*pos = CurrentPos;
if( flags & FINDFL_FORWARD ) {
pos->column += 0;
} else {
pos->column -= 2;
}
}
AddString2( &sStr, lastFind );
} else {
if( !(flags & FINDFL_NOCHANGE) ) {
AddString2( &lastFind, st );
}
AddString2( &sStr, st );
*pos = CurrentPos;
if( flags & FINDFL_FORWARD ) {
pos->column += 0;
} else {
pos->column -= 2;
}
}
/*
* wrap if needed
*/
if( flags & FINDFL_NEXTLINE ) {
wrapped = FALSE;
if( flags & FINDFL_FORWARD ) {
pos->column = 0;
pos->line += 1;
if( IsPastLastLine( pos->line ) ) {
pos->line = 1;
wrapped = TRUE;
}
} else {
pos->line -= 1;
if( pos->line == 0 ) {
CFindLastLine( &pos->line );
wrapped = TRUE;
}
CGimmeLinePtr( pos->line, &cfcb, &cline );
pos->column = cline->len - 1;
if( pos->column < 0 ) {
pos->column = 0;
}
}
if( wrapped && !(flags & FINDFL_WRAP) ) {
if( flags & FINDFL_FORWARD ) {
return( ERR_FIND_END_OF_FILE );
} else {
return( ERR_FIND_TOP_OF_FILE );
}
}
}
return( ERR_NO_ERR );
} /* setLineCol */
/*
* getFindString - get string and search for it
*/
static vi_rc getFindString( range *r, bool is_forward, bool is_fancy, bool search_again )
{
vi_rc rc;
char st[MAX_INPUT_LINE + 1];
char *res;
char *prompt;
#ifdef __WIN__
bool old_ci;
bool old_sw;
bool old_no;
fancy_find ff;
#endif
is_fancy = is_fancy;
search_again = search_again;
#ifdef __WIN__
old_ci = EditFlags.CaseIgnore;
old_sw = EditFlags.SearchWrap;
old_no = EditFlags.NoReplaceSearchString;
if( is_fancy ) {
if( lastFindStr != NULL ) {
strcpy( st, lastFindStr );
ff.use_regexp = lastFindWasRegExp;
ff.case_ignore = lastFindWasCaseIgnore;
ff.search_forward = is_forward;
ff.search_wrap = lastFindWasWrap;
} else {
st[0] = 0;
}
ff.find = st;
ff.findlen = sizeof( st );
if( !search_again ) {
if( !GetFindStringDialog( &ff ) ) {
return( RANGE_REQUEST_CANCELLED );
}
} else {
st[0] = 0;
EditFlags.NoReplaceSearchString = TRUE;
}
is_forward = ff.search_forward;
EditFlags.CaseIgnore = ff.case_ignore;
EditFlags.SearchWrap = ff.search_wrap;
if( !ff.use_regexp ) {
/* we need to add the string without any changes */
if( !EditFlags.NoReplaceSearchString ) {
AddString2( &lastFindStr, st );
lastFindWasRegExp = FALSE;
}
MakeExpressionNonRegular( st );
}
res = st;
} else {
#endif
if( is_forward ) {
prompt = "/";
} else {
prompt = "?";
}
st[0] = prompt[0];
rc = PromptForString( prompt, st + 1, sizeof( st ) - 1, &FindHist );
if( rc != ERR_NO_ERR ) {
if( rc == NO_VALUE_ENTERED ) {
return( ERR_NO_ERR );
}
return( rc );
}
res = &st[1]; // skip prompt
#ifdef __WIN__
}
#endif
if( is_forward ) {
rc = processFind( r, res, GetFindForward );
} else {
rc = processFind( r, res, GetFindBackwards );
}
#ifdef __WIN__
EditFlags.NoReplaceSearchString = old_no;
EditFlags.CaseIgnore = old_ci;
EditFlags.SearchWrap = old_sw;
lastFindWasRegExp = ff.use_regexp;
lastFindWasCaseIgnore = ff.case_ignore;
lastFindWasForward = ff.search_forward;
lastFindWasWrap = ff.search_wrap;
#endif
EditFlags.LastSearchWasForward = is_forward;
return( rc );
} /* getFindString */
/*
* SelectLineInFile - select a line in a given file
*/
vi_rc SelectLineInFile( selflinedata *sfd )
{
int i, winflag;
int leftcol = 0, key2;
bool done = FALSE, redraw = TRUE;
bool hiflag = FALSE, drawbord = FALSE;
int farx, text_lines;
linenum pagetop = 1, lln = 1;
char tmp[MAX_STR];
hilst *ptr;
linenum cln;
linenum endline;
vi_rc rc;
vi_key key;
/*
* create the window
*/
cln = sfd->cln;
endline = sfd->f->fcbs.tail->end_line;
farx = sfd->wi->x2;
if( sfd->show_lineno ) {
farx++;
}
if( sfd->hilite != NULL ) {
hiflag = TRUE;
}
rc = NewWindow2( &cWin, sfd->wi );
if( rc != ERR_NO_ERR ) {
return( rc );
}
if( !sfd->is_menu ) {
WindowAuxUpdate( cWin, WIND_INFO_HAS_SCROLL_GADGETS, TRUE );
DrawBorder( cWin );
}
oWin = sfd->eiw;
isMenu = sfd->is_menu;
PushMouseEventHandler( SelectLineMouseHandler );
KillCursor();
text_lines = WindowAuxInfo( cWin, WIND_INFO_TEXT_LINES );
sfd->sl = -1;
if( sfd->title != NULL ) {
WindowTitle( cWin, sfd->title );
}
pagetop = text_lines * (cln / text_lines);
if( cln % text_lines != 0 ) {
pagetop++;
}
key = 0;
if( LastEvent == VI_KEY( MOUSEEVENT ) ) {
DisplayMouse( TRUE );
}
/*
* now, allow free scrolling and selection
*/
while( !done ) {
if( redraw ) {
if( sfd->show_lineno ) {
MySprintf(tmp, "%l/%l", cln, endline );
i = sfd->wi->x2 - sfd->wi->x1;
WindowBorderData( cWin, tmp, i - strlen( tmp ) );
drawbord = TRUE;
}
if( hiflag ) {
ptr = sfd->hilite;
ptr += cln - 1;
if( ptr->_char == (char)-1 ) {
if( cln > lln ) {
cln++;
} else if( cln < lln ) {
cln--;
}
}
}
if( drawbord ) {
DrawBorder( cWin );
}
displayGenericLines( sfd->f, pagetop, leftcol, cln, &(sfd->wi->hilight), sfd->hilite, sfd->vals, sfd->valoff );
}
lln = cln;
redraw = TRUE;
drawbord = FALSE;
mouseLine = -1;
rlMenu = FALSE;
if( key == VI_KEY( MOUSEEVENT ) ) {
DisplayMouse( TRUE );
}
key = GetNextEvent( TRUE );
if( hiflag && ((key >= VI_KEY( ALT_A ) && key <= VI_KEY( ALT_Z )) ||
(key >='a' && key <= 'z') || (key >= 'A' && key <= 'Z') ||
(key >= '1' && key <= '9')) ) {
i = 0;
if( key >= VI_KEY( ALT_A ) && key <= VI_KEY( ALT_Z ) ) {
key2 = key - VI_KEY( ALT_A ) + 'A';
} else if( key >= 'a' && key <= 'z' ) {
key2 = key - 'a' + 'A';
} else {
key2 = key;
}
ptr = sfd->hilite;
while( ptr->_char != '\0' ) {
if( toupper( ptr->_char ) == key2 ) {
cln = i + 1;
key = VI_KEY( ENTER );
break;
}
++i;
++ptr;
}
}
/*
* check if a return-event has been selected
*/
if( sfd->retevents != NULL ) {
i = 0;
if( key == VI_KEY( MOUSEEVENT ) ) {
if( mouseWin == oWin && LastMouseEvent == MOUSE_PRESS ) {
DisplayMouse( FALSE );
sfd->event = sfd->retevents[mouseLine];
key = VI_KEY( ENTER );
}
} else {
while( sfd->retevents[i] != 0 ) {
if( key == sfd->retevents[i] ) {
sfd->event = key;
key = VI_KEY( ENTER );
break;
}
i++;
}
}
}
/*
* process key stroke
*/
switch( key ) {
case VI_KEY( MOUSEEVENT ):
DisplayMouse( FALSE );
if( hiflag ) {
ptr = sfd->hilite;
ptr += mouseLine;
if( ptr->_char == (char) -1 ) {
break;
}
}
if( rlMenu && sfd->allow_rl != NULL ) {
*(sfd->allow_rl) = rlMenuNum;
done = TRUE;
break;
}
if( mouseScroll != MS_NONE ) {
switch( mouseScroll ) {
case MS_UP: goto evil_up;
case MS_DOWN: goto evil_down;
case MS_PAGEUP: goto evil_pageup;
case MS_PAGEDOWN: goto evil_pagedown;
case MS_EXPOSEDOWN:
adjustCLN( &cln, &pagetop, pagetop + text_lines - cln - 1, endline, text_lines );
adjustCLN( &cln, &pagetop, 1, endline, text_lines );
drawbord = TRUE;
break;
case MS_EXPOSEUP:
adjustCLN( &cln, &pagetop, pagetop - cln, endline, text_lines );
adjustCLN( &cln, &pagetop, -1, endline, text_lines );
drawbord = TRUE;
break;
}
break;
}
switch( LastMouseEvent ) {
case MOUSE_DRAG:
if( mouseWin != cWin ) {
break;
}
cln = mouseLine + pagetop;
break;
case MOUSE_RELEASE:
if( !sfd->is_menu ) {
break;
}
if( mouseWin == cWin ) {
cln = mouseLine + pagetop;
if( cln <= endline ) {
goto evil_enter;
}
}
break;
case MOUSE_DCLICK:
if( mouseWin != cWin ) {
AddCurrentMouseEvent();
done = TRUE;
} else {
cln = mouseLine + pagetop;
if( cln <= endline ) {
goto evil_enter;
}
}
break;
case MOUSE_PRESS_R:
if( mouseWin != cWin ) {
AddCurrentMouseEvent();
done = TRUE;
}
break;
case MOUSE_PRESS:
if( mouseWin != cWin ) {
AddCurrentMouseEvent();
done = TRUE;
} else {
cln = mouseLine + pagetop;
}
break;
}
break;
case VI_KEY( ESC ):
done = TRUE;
break;
evil_enter:
case VI_KEY( ENTER ):
case ' ':
/*
* see if we need to do a callback for this
*/
if( sfd->checkres != NULL ) {
line *cline;
fcb *cfcb;
char data[64];
i = cln - 1;
GimmeLinePtr( cln, sfd->f, &cfcb, &cline );
strcpy( data, cline->data );
RemoveLeadingSpaces( data );
winflag = FALSE;
strcpy( tmp, sfd->vals[i] );
rc = sfd->checkres( data, tmp, &winflag );
if( winflag ) {
if( winflag == 2 ) {
winflag = TRUE;
} else {
winflag = FALSE;
}
}
if( winflag ) {
MoveWindowToFront( cWin );
}
if( rc == ERR_NO_ERR ) {
AddString2( &(sfd->vals[i]), tmp );
redraw = TRUE;
}
break;
/*
* no value window, so just return line selected
*/
} else {
if( isMenu && InvokeMenuHook( CurrentMenuNumber, cln ) == -1 ) {
break;
}
sfd->sl = cln;
done = TRUE;
}
break;
case VI_KEY( LEFT ):
case 'h':
if( sfd->allow_rl != NULL ) {
*(sfd->allow_rl) = -1;
done = TRUE;
}
break;
case VI_KEY( RIGHT ):
case 'l':
if( sfd->allow_rl != NULL ) {
*(sfd->allow_rl) = 1;
done = TRUE;
}
break;
evil_up:
case VI_KEY( UP ):
case 'k':
drawbord = adjustCLN( &cln, &pagetop, -1, endline, text_lines );
break;
evil_down:
case VI_KEY( DOWN ):
case 'j':
drawbord = adjustCLN( &cln, &pagetop, 1, endline, text_lines );
break;
case VI_KEY( CTRL_PAGEUP ):
drawbord = adjustCLN( &cln, &pagetop, -cln + 1, endline, text_lines );
break;
case VI_KEY( CTRL_PAGEDOWN ):
drawbord = adjustCLN( &cln, &pagetop, endline - cln, endline, text_lines );
break;
evil_pageup:
case VI_KEY( PAGEUP ):
case VI_KEY( CTRL_B ):
drawbord = adjustCLN( &cln, &pagetop, -text_lines, endline, text_lines );
break;
evil_pagedown:
case VI_KEY( PAGEDOWN ):
case VI_KEY( CTRL_F ):
drawbord = adjustCLN( &cln, &pagetop, text_lines, endline, text_lines );
break;
case VI_KEY( HOME ):
drawbord = TRUE;
cln = 1;
pagetop = 1;
break;
case VI_KEY( END ):
drawbord = TRUE;
cln = endline;
pagetop = endline - text_lines + 1;
if( pagetop < 1 ) {
pagetop = 1;
}
break;
default:
redraw = FALSE;
break;
}
}
PopMouseEventHandler();
CloseAWindow( cWin );
RestoreCursor();
SetWindowCursor();
return( rc );
} /* SelectLineInFile */
/*
* RepDlgProc - callback routine for find & replace dialog
*/
BOOL WINEXP RepDlgProc( HWND hwnd, UINT msg, UINT wparam, LONG lparam )
{
int curr;
int i;
int cmd;
DWORD index;
char find[MAX_INPUT_LINE];
history_data *h;
char *ptr;
RECT pos;
lparam = lparam;
switch( msg ) {
case WM_INITDIALOG:
if( findData.posx == -1 && findData.posy == -1 ) {
CenterWindowInRoot( hwnd );
} else {
SetWindowPos( hwnd, (HWND)NULLHANDLE, findData.posx, findData.posy,
0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOREDRAW | SWP_NOZORDER );
}
EditSubClass( hwnd, REP_FIND, &FindHist );
CheckDlgButton( hwnd, REP_IGNORE_CASE, findData.case_ignore );
CheckDlgButton( hwnd, REP_REGULAR_EXPRESSIONS, findData.use_regexp );
// CheckDlgButton( hwnd, REP_SEARCH_BACKWARDS, !findData.search_forward );
CheckDlgButton( hwnd, REP_SEARCH_WRAP, findData.search_wrap );
CheckDlgButton( hwnd, REP_PROMPT_ON_REPLACE, findData.prompt );
// CheckDlgButton( hwnd, REP_SELECTION_ONLY, findData.selection );
SetDlgItemText( hwnd, REP_FIND, findData.find );
SetDlgItemText( hwnd, REP_REPLACE, findData.replace );
curr = FindHist.curr + FindHist.max - 1;
for( i = 0; i < FindHist.max; i++ ) {
if( FindHist.data[curr % FindHist.max] != NULL ) {
SendDlgItemMessage( hwnd, REP_LISTBOX, LB_ADDSTRING, 0,
(LONG) FindHist.data[curr % FindHist.max] );
}
curr--;
if( curr < 0 ) {
break;
}
}
return( TRUE );
case WM_CLOSE:
GetWindowRect( hwnd, &pos );
findData.posx = pos.left;
findData.posy = pos.top;
PostMessage( hwnd, WM_COMMAND, GET_WM_COMMAND_MPS( IDCANCEL, 0, 0 ) );
return( TRUE );
case WM_COMMAND:
switch( LOWORD( wparam ) ) {
case REP_LISTBOX:
cmd = GET_WM_COMMAND_CMD( wparam, lparam );
if( cmd == LBN_SELCHANGE || cmd == LBN_DBLCLK ) {
index = SendDlgItemMessage( hwnd, REP_LISTBOX, LB_GETCURSEL, 0, 0L );
if( index == LB_ERR ) {
break;
}
SendDlgItemMessage( hwnd, REP_LISTBOX, LB_GETTEXT, index, (LONG) find );
SetDlgItemText( hwnd, REP_FIND, find );
if( cmd == LBN_DBLCLK ) {
PostMessage( hwnd, WM_COMMAND, GET_WM_COMMAND_MPS( IDOK, 0, 0 ) );
}
}
break;
case IDCANCEL:
GetWindowRect( hwnd, &pos );
findData.posx = pos.left;
findData.posy = pos.top;
RemoveEditSubClass( hwnd, REP_FIND );
EndDialog( hwnd, FALSE );
break;
case IDOK:
GetDlgItemText( hwnd, REP_FIND, findData.find, findData.findlen );
GetDlgItemText( hwnd, REP_REPLACE, findData.replace, findData.replacelen );
findData.case_ignore = IsDlgButtonChecked( hwnd, REP_IGNORE_CASE );
findData.use_regexp = IsDlgButtonChecked( hwnd, REP_REGULAR_EXPRESSIONS );
// findData.search_forward = !IsDlgButtonChecked( hwnd, REP_SEARCH_BACKWARDS );
findData.search_wrap = IsDlgButtonChecked( hwnd, REP_SEARCH_WRAP );
findData.prompt = IsDlgButtonChecked( hwnd, REP_PROMPT_ON_REPLACE );
// findData.selection = IsDlgButtonChecked( hwnd, REP_SELECTION_ONLY );
h = &FindHist;
curr = h->curr + h->max - 1;
ptr = NULL;
if( curr >= 0 ) {
ptr = h->data[curr % h->max];
}
if( ptr == NULL || strcmp( ptr, findData.find ) ) {
AddString2( &(h->data[h->curr % h->max]), findData.find );
h->curr += 1;
}
GetWindowRect( hwnd, &pos );
findData.posx = pos.left;
findData.posy = pos.top;
RemoveEditSubClass( hwnd, REP_FIND );
EndDialog( hwnd, TRUE );
break;
default:
return( FALSE );
}
return( TRUE );
}
return( FALSE );
} /* RepDlgProc */
/*
* processSetToken - set value for set token
*/
static vi_rc processSetToken( int j, char *value, int *winflag, bool isnonbool )
{
char fn[MAX_STR], str[MAX_STR];
#ifndef VICOMP
char tmp[3];
char settokstr[TOK_MAX_LEN + 1];
char save[MAX_STR];
vi_rc rc = ERR_NO_ERR;
int i, clr, k;
bool newset;
bool set1, toggle, *ptr;
jmp_buf jmpaddr;
cursor_type ct;
char *name;
command_rtn fptr;
event_bits eb;
bool redisplay = FALSE;
#endif
bool bvalue;
#ifdef VICOMP
winflag = winflag;
isnonbool = isnonbool;
#endif
/*
* set up value for boolean set commands
*/
if( j < 0 ) {
j *= -1;
bvalue = FALSE;
} else {
bvalue = TRUE;
}
#ifndef VICOMP
if( !(*winflag) ) {
toggle = TRUE;
set1 = isnonbool;
} else {
toggle = FALSE;
#endif
if( j >= SET1_T_ ) {
#ifndef VICOMP
if( EditFlags.CompileScript ) {
#endif
if( !bvalue ) {
j *= -1;
}
itoa( j, str, 10 );
StrMerge( 2, WorkLine->data, str, SingleBlank );
return( ERR_NO_ERR );
#ifndef VICOMP
}
set1 = FALSE;
j -= SET1_T_;
} else {
set1 = TRUE;
#endif
}
#ifndef VICOMP
}
*winflag = FALSE;
/*
* process boolean settings
*/
if( !set1 ) {
if( j >= SET2_T_ ) {
return( ERR_INVALID_SET_COMMAND );
}
ptr = &(((bool *)&EditFlags)[j]);
newset = bvalue;
if( toggle ) {
newset = !(*ptr);
}
switch( j ) {
case SET2_T_MODELESS:
if( (newset && !EditFlags.Modeless) ||
(!newset && EditFlags.Modeless) ) {
for( k = 0; k < MAX_EVENTS; k++ ) {
fptr = EventList[k].rtn;
eb = EventList[k].b;
EventList[k].rtn = EventList[k].alt_rtn;
EventList[k].alt_rtn = fptr;
EventList[k].b = EventList[k].alt_b;
EventList[k].alt_b = eb;
}
if( !EditFlags.Modeless ) {
if( MenuWindow != NO_WINDOW ) {
UpdateCurrentStatus( CSTATUS_INSERT );
}
EditFlags.WasOverstrike = FALSE;
NewCursor( CurrentWindow, EditVars.InsertCursorType );
} else {
if( MenuWindow != NO_WINDOW ) {
UpdateCurrentStatus( CSTATUS_COMMAND );
}
NewCursor( CurrentWindow, EditVars.NormalCursorType );
// nomodeless must be line based or it dies!
EditFlags.LineBased = TRUE;
}
/* re-position cursor in window
*/
SetWindowCursor();
}
EditFlags.Modeless = newset;
break;
case SET2_T_UNDO:
if( EditFlags.Undo && !newset ) {
FreeAllUndos();
}
EditFlags.Undo = newset;
break;
case SET2_T_STATUSINFO:
EditFlags.StatusInfo = newset;
#ifdef __WIN__
ResizeRoot();
#endif
rc = NewStatusWindow();
break;
case SET2_T_WINDOWGADGETS:
EditFlags.WindowGadgets = newset;
ResetAllWindows();
*winflag = TRUE;
redisplay = TRUE;
break;
case SET2_T_REALTABS:
EditFlags.RealTabs = newset;
redisplay = TRUE;
break;
case SET2_T_CLOCK:
EditFlags.Clock = newset;
redisplay = TRUE;
break;
case SET2_T_TOOLBAR:
EditFlags.Toolbar = newset;
#ifdef __WIN__
ResizeRoot();
#endif
break;
case SET2_T_COLORBAR:
EditFlags.Colorbar = newset;
#ifdef __WIN__
if( Root == NULL ) {
EditFlags.Colorbar = FALSE;
} else {
RefreshColorbar();
}
#endif
break;
case SET2_T_SSBAR:
EditFlags.SSbar = newset;
#ifdef __WIN__
if( Root == NULL ) {
EditFlags.SSbar = FALSE;
} else {
RefreshSSbar();
}
#endif
break;
case SET2_T_FONTBAR:
EditFlags.Fontbar = newset;
#ifdef __WIN__
if( Root == NULL ) {
EditFlags.Fontbar = FALSE;
} else {
RefreshFontbar();
}
#endif
break;
case SET2_T_MARKLONGLINES:
EditFlags.MarkLongLines = newset;
break;
case SET2_T_MENUS:
EditFlags.Menus = newset;
InitMenu();
break;
case SET2_T_LINENUMBERS:
if( toggle ) {
newset = !EditFlags.LineNumbers;
}
if( newset != EditFlags.LineNumbers ) {
EditFlags.LineNumbers = newset;
rc = LineNumbersSetup();
*winflag = TRUE;
}
break;
case SET2_T_CURRENTSTATUS:
EditFlags.CurrentStatus = newset;
InitMenu();
break;
case SET2_T_DISPLAYSECONDS:
EditFlags.DisplaySeconds = newset;
redisplay = TRUE;
break;
case SET2_T_PPKEYWORDONLY:
EditFlags.PPKeywordOnly = newset;
redisplay = TRUE;
break;
case SET2_T_LASTEOL:
#ifndef __WIN__
*ptr = TRUE;
toggle = FALSE;
break;
#endif
default:
*ptr = newset;
break;
}
if( msgFlag ) {
if( !newset ) {
tmp[0] = 'n';
tmp[1] = 'o';
tmp[2] = 0;
} else {
tmp[0] = 0;
}
MySprintf( fn, "%s%s set", tmp, GetTokenStringCVT( SetTokens2, j, settokstr, TRUE ) );
}
if( toggle ) {
strcpy( save, BoolStr[(int) newset] );
(*winflag) += 1;
}
/*
* process value settings
*/
} else {
if( toggle ) {
rc = GetNewValueDialog( value );
if( rc != ERR_NO_ERR ) {
return( rc );
}
strcpy( save, value );
}
#endif /* VICOMP */
RemoveLeadingSpaces( value );
if( value[0] == '"' ) {
NextWord( value, fn, "\"" );
EliminateFirstN( value, 1 );
} else {
NextWord1( value, fn );
}
#ifndef VICOMP
if( EditFlags.CompileScript ) {
#endif
itoa( j, str, 10 );
strcat( WorkLine->data, str );
if( fn[0] == '\0' )
return( ERR_NO_ERR );
switch( j ) {
case SET1_T_STATUSSTRING:
case SET1_T_FILEENDSTRING:
case SET1_T_HISTORYFILE:
case SET1_T_TMPDIR:
case SET1_T_TAGFILENAME:
StrMerge( 4, WorkLine->data, SingleBlank, SingleQuote, fn, SingleQuote );
break;
case SET1_T_COMMANDCURSORTYPE:
case SET1_T_OVERSTRIKECURSORTYPE:
case SET1_T_INSERTCURSORTYPE:
StrMerge( 2, WorkLine->data, SingleBlank, fn );
if( NextWord1( value, fn ) <= 0 ) {
break;
}
StrMerge( 2, WorkLine->data, SingleBlank, fn );
break;
case SET1_T_TILECOLOR:
StrMerge( 2, WorkLine->data, SingleBlank, fn );
if( NextWord1( value, fn ) <= 0 ) {
return( ERR_INVALID_SET_COMMAND );
}
if( NextWord1( value, str ) <= 0 ) {
return( ERR_INVALID_SET_COMMAND );
}
StrMerge( 4, WorkLine->data, fn, SingleBlank, str, SingleBlank );
break;
case SET1_T_STATUSSECTIONS:
StrMerge( 2, WorkLine->data, SingleBlank, fn );
while( NextWord1( value, fn ) > 0 ) {
#ifdef VICOMP
int k;
#endif
k = atoi( fn );
if( k <= 0 ) {
break;
}
StrMerge( 2, WorkLine->data, SingleBlank, fn );
}
break;
default:
StrMerge( 2, WorkLine->data, SingleBlank, fn );
break;
}
return( ERR_NO_ERR );
#ifndef VICOMP
}
switch( j ) {
case SET1_T_STATUSSECTIONS:
if( EditVars.StatusSections != NULL ) {
MemFree( EditVars.StatusSections );
EditVars.StatusSections = NULL;
EditVars.NumStatusSections = 0;
}
for( ;; ) {
k = atoi( fn );
if( k <= 0 ) {
break;
}
EditVars.StatusSections = MemReAlloc( EditVars.StatusSections,
sizeof( short ) * (EditVars.NumStatusSections + 1) );
EditVars.StatusSections[EditVars.NumStatusSections] = k;
EditVars.NumStatusSections++;
if( NextWord1( value, fn ) <= 0 ) {
break;
}
}
if( EditVars.StatusSections == NULL ) {
MySprintf( fn, "statussections turned off" );
} else {
MySprintf( fn, "statussections set" );
}
break;
case SET1_T_FILEENDSTRING:
AddString2( &EditVars.FileEndString, fn );
ResetAllWindows();
redisplay = TRUE;
break;
case SET1_T_STATUSSTRING:
AddString2( &EditVars.StatusString, fn );
if( StatusWindow != NO_WINDOW ) {
ClearWindow( StatusWindow );
UpdateStatusWindow();
}
if( msgFlag ) {
MySprintf( fn, "statusstring set to %s", EditVars.StatusString );
}
break;
case SET1_T_GREPDEFAULT:
AddString2( &EditVars.GrepDefault, fn );
break;
case SET1_T_TILECOLOR:
if( EditVars.TileColors == NULL ) {
EditVars.TileColors = (type_style *) MemAlloc( sizeof( type_style ) * ( EditVars.MaxTileColors + 1 ) );
for( i = 0; i <= EditVars.MaxTileColors; ++i ) {
EditVars.TileColors[i].foreground = -1;
EditVars.TileColors[i].background = -1;
EditVars.TileColors[i].font = -1;
}
}
clr = atoi( fn );
if( clr > EditVars.MaxTileColors ) {
return( ERR_INVALID_SET_COMMAND );
}
if( NextWord1( value, fn ) <= 0 ) {
return( ERR_INVALID_SET_COMMAND );
}
EditVars.TileColors[clr].foreground = atoi( fn );
if( NextWord1( value, fn ) <= 0 ) {
return( ERR_INVALID_SET_COMMAND );
}
EditVars.TileColors[clr].background = atoi( fn );
EditVars.TileColors[clr].font = FONT_DEFAULT;
if( msgFlag ) {
MySprintf( fn, "tilecolor %d set", clr );
}
break;
case SET1_T_GADGETSTRING:
SetGadgetString( fn );
if( msgFlag ) {
MySprintf( fn, "gadget string set to %s", EditVars.GadgetString );
}
ResetAllWindows();
break;
case SET1_T_SHELLPROMPT:
AddString2( &EditVars.SpawnPrompt, fn );
if( msgFlag ) {
MySprintf( fn, "prompt string set to %s", EditVars.SpawnPrompt );
}
break;
case SET1_T_FIGNORE:
if( fn[0] == 0 ) {
MemFreePtr( (void **)&EditVars.FIgnore );
EditVars.CurrFIgnore = 0;
if( msgFlag ) {
MySprintf( fn, "fignore reset" );
}
} else {
EditVars.FIgnore = MemReAlloc( EditVars.FIgnore, EXTENSION_LENGTH * (EditVars.CurrFIgnore + 1) );
str[0] = '.';
str[1] = 0;
strcat( str, fn );
str[EXTENSION_LENGTH - 1] = 0;
strcpy( &EditVars.FIgnore[EXTENSION_LENGTH * EditVars.CurrFIgnore], str );
EditVars.CurrFIgnore++;
if( msgFlag ) {
MySprintf( fn, "%s added to fignore", str );
}
}
break;
case SET1_T_HISTORYFILE:
AddString2( &EditVars.HistoryFile, fn );
if( msgFlag ) {
MySprintf( fn, "history file set to %s", EditVars.HistoryFile );
}
break;
case SET1_T_TAGFILENAME:
AddString2( &EditVars.TagFileName, fn );
if( msgFlag ) {
MySprintf( fn, "tag file name set to %s", EditVars.TagFileName );
}
break;
case SET1_T_FILENAME:
if( CurrentFile != NULL ) {
AddString2( &(CurrentFile->name), fn );
SetFileWindowTitle( CurrentWindow, CurrentInfo, TRUE );
if( msgFlag ) {
MySprintf( fn, "filename set to %s", CurrentFile->name );
}
FileSPVAR();
}
break;
case SET1_T_TMPDIR:
AddString2( &EditVars.TmpDir, fn );
VerifyTmpDir();
if( msgFlag ) {
MySprintf( fn, "tmpdir set to %s", EditVars.TmpDir );
}
break;
case SET1_T_WORD:
AddString2( &EditVars.WordDefn, fn );
InitWordSearch( EditVars.WordDefn );
if( msgFlag ) {
MySprintf( fn, "word set to %s", EditVars.WordDefn );
}
break;
case SET1_T_WORDALT:
AddString2( &EditVars.WordAltDefn, fn );
if( msgFlag ) {
MySprintf( fn, "wordalt set to %s", EditVars.WordAltDefn );
}
break;
case SET1_T_MAGICSTRING:
AddString2( &EditVars.Majick, fn );
if( msgFlag ) {
MySprintf( fn, "magicstring set to %s", EditVars.Majick );
}
break;
case SET1_T_COMMANDCURSORTYPE:
case SET1_T_OVERSTRIKECURSORTYPE:
case SET1_T_INSERTCURSORTYPE:
i = setjmp( jmpaddr );
if( i != 0 ) {
return( ERR_INVALID_SET_COMMAND );
}
StartExprParse( fn, jmpaddr );
ct.height = GetConstExpr();
if( NextWord1( value, fn ) <= 0 ) {
ct.width = 100;
} else {
i = setjmp( jmpaddr );
if( i != 0 ) {
return( ERR_INVALID_SET_COMMAND );
}
StartExprParse( fn, jmpaddr );
ct.width = GetConstExpr();
}
if( j == SET1_T_COMMANDCURSORTYPE ) {
EditVars.NormalCursorType = ct;
name = "command";
} else if( j == SET1_T_OVERSTRIKECURSORTYPE ) {
EditVars.OverstrikeCursorType = ct;
name = "overstrike";
} else {
EditVars.InsertCursorType = ct;
name = "insert";
}
if( msgFlag ) {
MySprintf( fn, "%s cursor type set to %d,%d", name,
ct.height, ct.width );
}
break;
default:
i = setjmp( jmpaddr );
if( i != 0 ) {
return( ERR_INVALID_SET_COMMAND );
}
StartExprParse( fn, jmpaddr );
i = GetConstExpr();
if( i < 0 ) {
i = 0;
}
switch( j ) {
case SET1_T_WRAPMARGIN:
EditVars.WrapMargin = i;
break;
case SET1_T_CURSORBLINKRATE:
SetCursorBlinkRate( i );
break;
case SET1_T_MAXPUSH:
EditVars.MaxPush = i;
if( EditVars.MaxPush < 1 ) {
EditVars.MaxPush = 1;
}
InitFileStack();
break;
case SET1_T_RADIX:
EditVars.Radix = i;
break;
case SET1_T_AUTOSAVEINTERVAL:
EditVars.AutoSaveInterval = i;
SetNextAutoSaveTime();
break;
case SET1_T_LANGUAGE:
if( i < LANG_NONE || i >= LANG_MAX ) {
return( ERR_INVALID_SET_COMMAND );
}
if( CurrentInfo != NULL ) {
LangFini( CurrentInfo->fsi.Language );
LangInit( i );
redisplay = TRUE;
}
break;
case SET1_T_MOVECOLOR:
EditVars.MoveColor = i;
break;
case SET1_T_RESIZECOLOR:
EditVars.ResizeColor = i;
break;
case SET1_T_MOUSEDCLICKSPEED:
EditVars.MouseDoubleClickSpeed = i;
break;
case SET1_T_MOUSESPEED:
SetMouseSpeed( i );
break;
case SET1_T_MOUSEREPEATDELAY:
EditVars.MouseRepeatDelay = i;
break;
case SET1_T_CURRENTSTATUSCOLUMN:
EditVars.CurrentStatusColumn = i;
InitMenu();
break;
case SET1_T_ENDOFLINECHAR:
EditVars.EndOfLineChar = i;
break;
case SET1_T_EXITATTR:
EditVars.ExitAttr = (char) i;
break;
case SET1_T_INACTIVEWINDOWCOLOR:
EditVars.InactiveWindowColor = i;
break;
case SET1_T_TABAMOUNT:
EditVars.TabAmount = i;
break;
case SET1_T_SHIFTWIDTH:
EditVars.ShiftWidth = i;
break;
case SET1_T_PAGELINESEXPOSED:
EditVars.PageLinesExposed = i;
break;
case SET1_T_HARDTAB:
EditVars.HardTab = i;
redisplay = TRUE;
break;
case SET1_T_STACKK:
if( EditFlags.Starting ) {
EditVars.StackK = i;
}
break;
case SET1_T_LINENUMWINWIDTH:
EditVars.LineNumWinWidth = i;
break;
case SET1_T_MAXWINDOWTILEX:
EditVars.MaxWindowTileX = i;
break;
case SET1_T_MAXWINDOWTILEY:
EditVars.MaxWindowTileY = i;
break;
case SET1_T_MAXSWAPK:
SwapBlockInit( i );
break;
case SET1_T_MAXEMSK:
#ifndef NOEMS
EMSBlockInit( i );
#endif
break;
case SET1_T_MAXXMSK:
#ifndef NOXMS
XMSBlockInit( i );
#endif
break;
case SET1_T_MAXFILTERHISTORY:
FilterHistInit( i );
break;
case SET1_T_MAXCLHISTORY:
CLHistInit( i );
break;
case SET1_T_MAXFINDHISTORY:
FindHistInit( i );
break;
case SET1_T_MAXLASTFILESHISTORY:
LastFilesHistInit( i );
break;
case SET1_T_MAXTILECOLORS:
k = (EditVars.TileColors == NULL) ? 0 : EditVars.MaxTileColors + 1;
EditVars.MaxTileColors = i;
EditVars.TileColors = MemReAlloc( EditVars.TileColors, sizeof( type_style ) * ( EditVars.MaxTileColors + 1 ) );
for( ; k <= EditVars.MaxTileColors; ++k ) {
EditVars.TileColors[k].foreground = -1;
EditVars.TileColors[k].background = -1;
EditVars.TileColors[k].font = -1;
}
break;
case SET1_T_CLOCKX:
EditVars.ClockX = i;
GetClockStart();
break;
case SET1_T_CLOCKY:
EditVars.ClockY = i;
GetClockStart();
break;
case SET1_T_SPINX:
EditVars.SpinX = i;
GetSpinStart();
break;
case SET1_T_SPINY:
EditVars.SpinY = i;
GetSpinStart();
break;
case SET1_T_MAXLINELEN:
/* file save fails if 1 line is > MAX_IO_BUFFER */
i = __min( i, MAX_IO_BUFFER );
EditVars.MaxLine = i;
StaticStart();
WorkLine = MemReAlloc( WorkLine, sizeof( line ) + EditVars.MaxLine + 2 );
break;
case SET1_T_TOOLBARBUTTONHEIGHT:
EditVars.ToolBarButtonHeight = i;
#ifdef __WIN__
ResizeRoot();
#endif
break;
case SET1_T_TOOLBARBUTTONWIDTH:
EditVars.ToolBarButtonWidth = i;
#ifdef __WIN__
ResizeRoot();
#endif
break;
case SET1_T_TOOLBARCOLOR:
EditVars.ToolBarColor = i;
#ifdef __WIN__
if( GetToolbarWindow() != NULL ) {
InvalidateRect( GetToolbarWindow(), NULL, TRUE );
UpdateWindow( GetToolbarWindow() );
}
#endif
break;
default:
return( ERR_INVALID_SET_COMMAND );
}
if( msgFlag ) {
MySprintf( fn, "%s set to %d", GetTokenStringCVT( SetTokens1, j, settokstr, TRUE ), i );
}
break;
}
}
if( msgFlag && rc == ERR_NO_ERR && !EditFlags.Quiet ) {
setMessage( fn, redisplay );
rc = DO_NOT_CLEAR_MESSAGE_WINDOW;
}
if( rc == ERR_NO_ERR && toggle ) {
strcpy( value, save );
}
return( rc );
#endif /* VICOMP */
} /* processSetToken */
/*
* doInitializeEditor - do just that
*/
static void doInitializeEditor( int argc, char *argv[] )
{
int i, arg, cnt, ocnt, startcnt = 0;
unsigned ln;
int k, j;
char tmp[FILENAME_MAX], c[1];
char buff[MAX_STR], file[MAX_STR], **list;
char cmd[MAX_STR * 2];
char *parm;
char *startup[MAX_STARTUP];
char *startup_parms[MAX_STARTUP];
vi_rc rc;
vi_rc rc1;
/*
* Make sure WATCOM is setup and if it is not, make a best guess.
*/
watcom_setup_env();
/*
* If EDPATH is not set, use system default %WATCOM%\EDDAT.
*/
if( getenv( "EDPATH" ) == NULL ) {
char *watcom;
watcom = getenv( "WATCOM" );
if( watcom != NULL ) {
char edpath[FILENAME_MAX];
sprintf( edpath, "%s%c%s", watcom, DIR_SEP, "eddat" );
if( setenv( "EDPATH", edpath, 0 ) != 0 ) {
/*
* Bail out silently on error, as we will get error message later on.
*/
}
}
}
/*
* misc. set up
*/
MaxMemFree = MemSize();
StaticStart();
FTSInit();
BoundDataInit();
EditFlags.Starting = TRUE;
InitCommandLine();
ChkExtendedKbd();
SSInitBeforeConfig();
GetCWD1( &HomeDirectory );
GetCWD1( &CurrentDirectory );
SetCWD( HomeDirectory );
if( cfgFN == NULL ){
AddString( &cfgFN, CFG_NAME );
}
checkFlags( &argc, argv, startup, startup_parms, &startcnt );
ScreenInit();
SetWindowSizes();
EditFlags.ClockActive = FALSE;
SetInterrupts();
#ifndef __WIN__
InitColors();
#else
InitClrPick();
InitFtPick();
SubclassGenericInit();
CursorOp( COP_INIT );
#endif
InitSavebufs();
InitKeyMaps();
/*
* initial configuration
*/
EditVars.Majick = MemStrDup( "()~@" );
EditVars.FileEndString = MemStrDup( "[END_OF_FILE]" );
MatchInit();
SetGadgetString( NULL );
WorkLine = MemAlloc( sizeof( line ) + EditVars.MaxLine + 2 );
WorkLine->len = -1;
ln = 0;
if( cfgFN[0] != 0 ) {
c[0] = 0;
rc = Source( cfgFN, c, &ln );
if( rc == ERR_FILE_NOT_FOUND ) {
#ifdef __WIN__
CloseStartupDialog();
MessageBox( (HWND)NULLHANDLE, "Could not locate configuration information; please make sure your EDPATH environment variable is set correctly",
EditorName, MB_OK );
ExitEditor( -1 );
#else
rc = ERR_NO_ERR;
#endif
}
} else {
rc = ERR_NO_ERR;
}
if( wantNoReadEntireFile ) {
EditFlags.ReadEntireFile = FALSE;
}
VerifyTmpDir();
while( LostFileCheck() );
HookScriptCheck();
if( EditFlags.Quiet ) {
EditFlags.Spinning = EditFlags.Clock = FALSE;
}
ExtendedMemoryInit();
/*
* more misc. setup
*/
if( EditVars.WordDefn == NULL ) {
AddString( &EditVars.WordDefn, &WordDefnDefault[6] );
InitWordSearch( EditVars.WordDefn );
}
if( EditVars.WordAltDefn == NULL ) {
AddString( &EditVars.WordAltDefn, WordDefnDefault );
}
if( EditVars.TagFileName == NULL ) {
AddString( &EditVars.TagFileName, "tags" );
}
DotBuffer = MemAlloc( (maxdotbuffer + 2) * sizeof( vi_key ) );
AltDotBuffer = MemAlloc( (maxdotbuffer + 2) * sizeof( vi_key ) );
DotCmd = MemAlloc( (maxdotbuffer + 2) * sizeof( vi_key ) );
SwapBlockInit( EditVars.MaxSwapBlocks );
ReadBuffer = MemAlloc( MAX_IO_BUFFER + 6 );
WriteBuffer = MemAlloc( MAX_IO_BUFFER + 6 );
FindHistInit( EditVars.FindHist.max );
FilterHistInit( EditVars.FilterHist.max );
CLHistInit( EditVars.CLHist.max );
LastFilesHistInit( EditVars.LastFilesHist.max );
GetClockStart();
GetSpinStart();
SelRgnInit();
SSInitAfterConfig();
#if defined( VI_RCS )
ViRCSInit();
#endif
/*
* create windows
*/
StartWindows();
InitMouse();
rc1 = NewMessageWindow();
if( rc1 != ERR_NO_ERR ) {
FatalError( rc1 );
}
DoVersion();
rc1 = InitMenu();
if( rc1 != ERR_NO_ERR ) {
FatalError( rc1 );
}
EditFlags.SpinningOurWheels = TRUE;
EditFlags.ClockActive = TRUE;
EditFlags.DisplayHold = TRUE;
rc1 = NewStatusWindow();
if( rc1 != ERR_NO_ERR ) {
FatalError( rc1 );
}
EditFlags.DisplayHold = FALSE;
MaxMemFreeAfterInit = MemSize();
/*
* start specified file(s)
*/
arg = argc - 1;
k = 1;
cmd[0] = 'e';
cmd[1] = 0;
EditFlags.WatchForBreak = TRUE;
/*
* look for a tag: if there is one, set it up as the file to start
*/
if( cTag != NULL && !EditFlags.NoInitialFileLoad ) {
#if defined( __NT__ ) && !defined( __WIN__ )
{
if( !EditFlags.Quiet ) {
SetConsoleActiveScreenBuffer( OutputHandle );
}
}
#endif
rc1 = LocateTag( cTag, file, buff );
cFN = file;
if( rc1 ) {
if( rc1 == ERR_TAG_NOT_FOUND ) {
Error( GetErrorMsg( rc1 ), cTag );
ExitEditor( 0 );
}
FatalError( rc1 );
}
}
while( !EditFlags.NoInitialFileLoad ) {
if( cFN == nullFN && !EditFlags.UseNoName ) {
break;
}
#ifdef __NT__
{
int k2 = k;
int arg2 = arg;
char path[_MAX_PATH];
int found = 0;
int fd;
/*
* check for the existence of a file name containing spaces, and open it if
* there is one
*/
memset( path, 0, _MAX_PATH );
while( argv[k2] != NULL && strlen( path ) +
strlen( argv[k2] ) < _MAX_PATH ) {
strcat( path, argv[k2] );
fd = open( path, O_RDONLY );
if( fd != -1 ) {
close( fd );
found = 1;
break;
}
k2++;
arg2--;
strcat( path, " " );
}
if( found ) {
rc1 = NewFile( path, FALSE );
if( rc1 != ERR_NO_ERR ) {
FatalError( rc1 );
}
k = k2 + 1;
arg = arg2 - 1;
cFN = argv[k];
if( arg < 1 ) {
break;
}
continue;
}
}
#endif
strcat( cmd, SingleBlank );
strcat( cmd, cFN );
ocnt = cnt = ExpandFileNames( cFN, &list );
if( !cnt ) {
cnt = 1;
} else {
cFN = list[0];
}
for( j = 0; j < cnt; j++ ) {
rc1 = NewFile( cFN, FALSE );
if( rc1 != ERR_NO_ERR && rc1 != NEW_FILE ) {
FatalError( rc1 );
}
if( EditFlags.BreakPressed ) {
break;
}
if( cnt > 0 && j < cnt - 1 ) {
cFN = list[j + 1];
}
}
if( ocnt > 0 ) {
MemFreeList( ocnt, list );
}
if( EditFlags.BreakPressed ) {
ClearBreak();
break;
}
k++;
arg--;
if( cTag != NULL || arg < 1 ) {
break;
}
cFN = argv[k];
}
if( EditFlags.StdIOMode ) {
rc1 = NewFile( "stdio", FALSE );
if( rc1 != ERR_NO_ERR ) {
FatalError( rc1 );
}
}
EditFlags.WatchForBreak = EditFlags.Starting = FALSE;
/*
* if there was a tag, do the appropriate search
*/
if( cTag != NULL && !EditFlags.NoInitialFileLoad ) {
if( buff[0] != '/' ) {
i = atoi( buff );
rc1 = GoToLineNoRelCurs( i );
} else {
rc1 = FindTag( buff );
}
if( rc1 > 0 ) {
Error( GetErrorMsg( rc1 ) );
}
}
/*
* try to run startup file
*/
if( EditFlags.RecoverLostFiles ) {
startcnt = 0;
}
for( i = 0; i < startcnt; i++ ) {
GetFromEnv( startup[i], tmp );
AddString2( &cfgFN, tmp );
if( cfgFN[0] != 0 ) {
if( startup_parms[i] != NULL ) {
parm = startup_parms[i];
} else {
c[0] = 0;
parm = c;
}
#if defined( __NT__ ) && !defined( __WIN__ )
{
if( !EditFlags.Quiet ) {
SetConsoleActiveScreenBuffer( OutputHandle );
}
}
#endif
ln = 0;
rc = Source( cfgFN, parm, &ln );
}
}
if( rc > ERR_NO_ERR ) {
Error( "%s on line %u of \"%s\"", GetErrorMsg( rc ), ln, cfgFN );
}
if( argc == 1 ) {
LoadHistory( NULL );
} else {
LoadHistory( cmd );
}
if( EditVars.GrepDefault == NULL ) {
AddString( &EditVars.GrepDefault, "*.(c|h)" );
}
if( goCmd[0] != 0 ) {
KeyAddString( goCmd );
}
if( keysToPush != NULL ) {
KeyAddString( keysToPush );
}
#ifdef __WIN__
if( lineToGoTo != 0 ) {
SetCurrentLine( lineToGoTo );
NewCursor( CurrentWindow, EditVars.NormalCursorType );
}
#endif
AutoSaveInit();
HalfPageLines = WindowAuxInfo( CurrentWindow, WIND_INFO_TEXT_LINES ) / 2 - 1;
#if defined( _M_X64 )
VarAddGlobalStr( "OSX64", "1" );
#elif defined( _M_IX86 ) && !defined( _M_I86 )
VarAddGlobalStr( "OS386", "1" );
#endif
if( EditVars.StatusString == NULL ) {
AddString( &EditVars.StatusString, "L:$6L$nC:$6C" );
}
UpdateStatusWindow();
#ifdef __WIN__
if( CurrentInfo == NULL ) {
// no file loaded - screen is disconcertenly empty - reassure
DisplayFileStatus();
}
#endif
NewCursor( CurrentWindow, EditVars.NormalCursorType );
#if defined( __NT__ ) && !defined( __WIN__ )
{
SetConsoleActiveScreenBuffer( OutputHandle );
}
#endif
} /* doInitializeEditor */
/*
* checkFlags - check for command line flags
*/
static void checkFlags( int *argc, char *argv[], char *start[],
char *parms[], int *startcnt )
{
int ch;
#ifndef __WIN__
int len;
#endif
cFN = NULL;
for( ;; ) {
#ifndef __WIN__
ch = GetOpt( argc, argv, "#-ndvqzirc:k:p:s:t:", NULL );
#else
ch = GetOpt( argc, argv, "#-ndvqzirIP:c:k:p:s:t:", NULL );
#endif
if( ch == -1 ) {
break;
}
switch( ch ) {
case '#':
#ifndef __WIN__
strncpy( goCmd, OptArg, sizeof( goCmd ) -2 );
goCmd[sizeof( goCmd ) - 2] = 0;
len = strlen( goCmd );
goCmd[len] = 'G';
goCmd[len + 1] = 0;
#else
lineToGoTo = atoi( OptArg );
#endif
break;
#ifdef __WIN__
case 'P':
SetInitialWindowSize( OptArg );
break;
case 'I':
cFN = GetInitialFileName();
break;
#endif
#ifdef __IDE__
case 'X':
IDEInit();
EditFlags.UseIDE = TRUE;
break;
#endif
case '-':
EditFlags.StdIOMode = TRUE;
EditFlags.NoInitialFileLoad = TRUE;
break;
case 'r':
EditFlags.RecoverLostFiles = TRUE;
EditFlags.NoInitialFileLoad = TRUE;
break;
case 'i':
EditFlags.IgnoreLostFiles = TRUE;
break;
case 'z':
EditFlags.IgnoreCtrlZ = TRUE;
break;
case 'q':
EditFlags.Quiet = TRUE;
break;
case 'v':
EditFlags.ViewOnly = TRUE;
break;
case 'c':
EditFlags.BoundData = FALSE;
AddString2( &cfgFN, OptArg );
break;
case 'd':
EditFlags.BoundData = FALSE;
AddString2( &cfgFN, "" );
break;
case 'k':
keysToPush = OptArg;
break;
case 'p':
if( *startcnt <= 0 ) {
Quit( NULL, "No script to give parm list\n" );
}
parms[(*startcnt - 1)] = OptArg;
break;
case 's':
if( *startcnt < MAX_STARTUP ) {
start[*startcnt] = OptArg;
parms[*startcnt] = NULL;
(*startcnt)++;
} else {
Quit( NULL, "Too many scripts\n" );
}
break;
case 't':
cTag = OptArg;
break;
case 'n':
wantNoReadEntireFile = TRUE;
break;
}
}
/*
* now, check for null file name
*/
if( cFN == NULL ) {
if( (*argc) == 1 ) {
cFN = nullFN;
} else {
// cFN = argv[(*argc)-1];
cFN = argv[1];
}
}
} /* checkFlags */
/*
* SetConfigFileName
*/
void SetConfigFileName( char *fn )
{
AddString2( &cfgFN, fn );
} /* SetConfigFileName */
