diff options
Diffstat (limited to 'commands.c')
| -rw-r--r-- | commands.c | 1064 |
1 files changed, 1064 insertions, 0 deletions
diff --git a/commands.c b/commands.c new file mode 100644 index 0000000..69dabe2 --- /dev/null +++ b/commands.c @@ -0,0 +1,1064 @@ +/* $XConsortium: commands.c,v 1.33 91/10/21 14:32:18 eswu Exp $ */ + +/* + * COPYRIGHT 1987 + * DIGITAL EQUIPMENT CORPORATION + * MAYNARD, MASSACHUSETTS + * ALL RIGHTS RESERVED. + * + * THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE AND + * SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT CORPORATION. + * DIGITAL MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THIS SOFTWARE FOR + * ANY PURPOSE. IT IS SUPPLIED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * + * IF THE SOFTWARE IS MODIFIED IN A MANNER CREATING DERIVATIVE COPYRIGHT RIGHTS, + * APPROPRIATE LEGENDS MAY BE PLACED ON THE DERIVATIVE WORK IN ADDITION TO THAT + * SET FORTH ABOVE. + * + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose and without fee is hereby granted, provided + * that the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Digital Equipment Corporation not be + * used in advertising or publicity pertaining to distribution of the software + * without specific, written prior permission. + */ +/* $XFree86: xc/programs/xedit/commands.c,v 1.29 2002/11/05 06:57:05 paulo Exp $ */ + +#include <X11/Xfuncs.h> +#include <X11/Xos.h> +#include "xedit.h" +#ifdef CRAY +#include <unistd.h> +#endif +#include <stdlib.h> +#include <string.h> +#include <dirent.h> +#include <pwd.h> +#include <sys/stat.h> +#include <X11/Xmu/SysUtil.h> +#include <X11/IntrinsicP.h> +#include <X11/Xaw/TextSrcP.h> + +void ResetSourceChanged(xedit_flist_item*); +static void ResetDC(Widget, XtPointer, XtPointer); + +static void AddDoubleClickCallback(Widget, Bool); +static Bool ReallyDoLoad(char*, char*); +static char *makeBackupName(String, String, unsigned); + +extern Widget scratch, texts[3], labels[3]; +static Boolean double_click = FALSE; + +#define DC_UNSAVED 1 +#define DC_LOADED 2 +#define DC_CLOBBER 3 +#define DC_KILL 4 +#define DC_SAVE 5 +static int dc_state; + +/* Function Name: AddDoubleClickCallback(w) + * Description: Adds a callback that will reset the double_click flag + * to false when the text is changed. + * Arguments: w - widget to set callback upon. + * state - If true add the callback, else remove it. + * Returns: none. + */ +static void +AddDoubleClickCallback(Widget w, Bool state) +{ + Arg args[1]; + static XtCallbackRec cb[] = { {NULL, NULL}, {NULL, NULL} }; + + if (XtIsSubclass(w, asciiSrcObjectClass)) { + if (state) + XtAddCallback(w, XtNcallback, ResetDC, NULL); + else + XtRemoveCallback(w, XtNcallback, ResetDC, NULL); + } + else { + if (state) + cb[0].callback = ResetDC; + else + cb[0].callback = NULL; + + XtSetArg(args[0], XtNcallback, cb); + XtSetValues(w, args, ONE); + } +} + +/* Function Name: ResetDC + * Description: Resets the double click flag. + * Arguments: w - the text widget. + * junk, garbage - *** NOT USED *** + * Returns: none. + */ + +/* ARGSUSED */ +static void +ResetDC(Widget w, XtPointer junk, XtPointer garbage) +{ + double_click = FALSE; + + AddDoubleClickCallback(w, FALSE); +} + +/*ARGSUSED*/ +void +QuitAction(Widget w, XEvent *event, String *params, Cardinal *num_params) +{ + DoQuit(w, NULL, NULL); +} + +/*ARGSUSED*/ +void +DoQuit(Widget w, XtPointer client_data, XtPointer call_data) +{ + unsigned i; + Bool source_changed = False; + + if (!double_click || (dc_state && dc_state != DC_UNSAVED)) { + for (i = 0; i < flist.num_itens; i++) + if (flist.itens[i]->flags & CHANGED_BIT) { + source_changed = True; + break; + } + } + if(!source_changed) { +#ifndef __UNIXOS2__ + XeditLispCleanUp(); +#endif + exit(0); + } + + XeditPrintf("Unsaved changes. Save them, or Quit again.\n"); + Feep(); + double_click = TRUE; + dc_state = DC_UNSAVED; + AddDoubleClickCallback(XawTextGetSource(textwindow), True); +} + +static char * +makeBackupName(String buf, String filename, unsigned len) +{ + if (app_resources.backupNamePrefix + && strlen(app_resources.backupNamePrefix)) { + if (strchr(app_resources.backupNamePrefix, '/')) + XmuSnprintf(buf, len, "%s%s%s", app_resources.backupNamePrefix, + filename, app_resources.backupNameSuffix); + else { + char fname[BUFSIZ]; + char *name, ch; + + strncpy(fname, filename, sizeof(fname) - 1); + fname[sizeof(fname) - 1] = '\0'; + if ((name = strrchr(fname, '/')) != NULL) + ++name; + else + name = filename; + ch = *name; + *name = '\0'; + ++name; + XmuSnprintf(buf, len, "%s%s%c%s%s", + fname, app_resources.backupNamePrefix, ch, name, + app_resources.backupNameSuffix); + } + } + else + XmuSnprintf(buf, len, "%s%s", + filename, app_resources.backupNameSuffix); + + return (strcmp(filename, buf) ? buf : NULL); +} + +#if defined(USG) && !defined(CRAY) +int rename (from, to) + char *from, *to; +{ + (void) unlink (to); + if (link (from, to) == 0) { + unlink (from); + return 0; + } else { + return -1; + } +} +#endif + +/*ARGSUSED*/ +void +SaveFile(Widget w, XEvent *event, String *params, Cardinal *num_params) +{ + DoSave(w, NULL, NULL); +} + +/*ARGSUSED*/ +void +DoSave(Widget w, XtPointer client_data, XtPointer call_data) +{ + String name = GetString(filenamewindow); + String filename = ResolveName(name); + char buf[BUFSIZ]; + FileAccess file_access; + xedit_flist_item *item; + Boolean exists; + Widget source = XawTextGetSource(textwindow); + + if (!filename) { + XeditPrintf("Save: Can't resolve pathname -- nothing saved.\n"); + Feep(); + return; + } + else if (*name == '\0') { + XeditPrintf("Save: No filename specified -- nothing saved.\n"); + Feep(); + return; + } + else { + struct stat st; + + if (stat(filename, &st) == 0 && !S_ISREG(st.st_mode)) { + XmuSnprintf(buf, sizeof(buf), + "Save: file %s is not a regular file -- nothing saved.\n", + name); + XeditPrintf(buf); + Feep(); + return; + } + } + + item = FindTextSource(NULL, filename); + if (item != NULL && item->source != source) { + if (!double_click || (dc_state && dc_state != DC_LOADED)) { + XmuSnprintf(buf, sizeof(buf), + "Save: file %s is already loaded, " + "Save again to unload it -- nothing saved.\n", + name); + XeditPrintf(buf); + Feep(); + double_click = TRUE; + dc_state = DC_LOADED; + AddDoubleClickCallback(XawTextGetSource(textwindow), True); + return; + } + KillTextSource(item); + item = FindTextSource(source = XawTextGetSource(textwindow), NULL); + double_click = FALSE; + dc_state = 0; + } + else if (item && !(item->flags & CHANGED_BIT)) { + if (!double_click || (dc_state && dc_state != DC_SAVE)) { + XeditPrintf("Save: No changes need to be saved, " + "Save again to override.\n"); + Feep(); + double_click = TRUE; + dc_state = DC_SAVE; + AddDoubleClickCallback(XawTextGetSource(textwindow), True); + return; + } + double_click = FALSE; + dc_state = 0; + } + + file_access = CheckFilePermissions(filename, &exists); + if (!item || strcmp(item->filename, filename)) { + if (file_access == WRITE_OK && exists) { + if (!double_click || (dc_state && dc_state != DC_CLOBBER)) { + XmuSnprintf(buf, sizeof(buf), + "Save: file %s already exists, " + "Save again to overwrite it -- nothing saved.\n", + name); + XeditPrintf(buf); + Feep(); + double_click = TRUE; + dc_state = DC_CLOBBER; + AddDoubleClickCallback(XawTextGetSource(textwindow), True); + return; + } + double_click = FALSE; + dc_state = 0; + } + if (!item) + item = FindTextSource(source, NULL); + } + + if (app_resources.enableBackups && exists) { + char backup_file[BUFSIZ]; + + if (makeBackupName(backup_file, filename, sizeof(backup_file)) == NULL + || rename(filename, backup_file) != 0) { + XmuSnprintf(buf, sizeof(buf),"error backing up file: %s\n", + filename); + XeditPrintf(buf); + } + } + + switch( file_access = MaybeCreateFile(filename)) { + case NO_READ: + case READ_OK: + XmuSnprintf(buf, sizeof(buf), + "File %s could not be opened for writing.\n", name); + Feep(); + break; + case WRITE_OK: + if ( XawAsciiSaveAsFile(source, filename) ) { + int i; + Arg args[1]; + char label_buf[BUFSIZ]; + + /* Keep file protection mode */ + if (item && item->mode) + chmod(filename, item->mode); + + XmuSnprintf(label_buf, sizeof(label_buf), + "%s Read - Write", name); + XtSetArg(args[0], XtNlabel, label_buf); + for (i = 0; i < 3; i++) + if (XawTextGetSource(texts[i]) == source) + XtSetValues(labels[i], args, 1); + + XmuSnprintf(buf, sizeof(buf), "Saved file: %s\n", name); + + if (item && item->source != scratch) { + XtSetArg(args[0], XtNlabel, filename); + XtSetValues(item->sme, args, 1); + + XtSetArg(args[0], XtNeditType, XawtextEdit); + XtSetValues(item->source, args, 1); + + XtFree(item->name); + XtFree(item->filename); + item->name = XtNewString(name); + item->filename = XtNewString(filename); + item->flags = EXISTS_BIT; + } + else { + item = flist.itens[0]; + XtRemoveCallback(scratch, XtNcallback, SourceChanged, + (XtPointer)item); + item->source = scratch = + XtVaCreateWidget("textSource", international ? + multiSrcObjectClass : asciiSrcObjectClass, + topwindow, + XtNtype, XawAsciiFile, + XtNeditType, XawtextEdit, + NULL, NULL); + ResetSourceChanged(item); + XtAddCallback(scratch, XtNcallback, SourceChanged, + (XtPointer)item); + + item = AddTextSource(source, name, filename, EXISTS_BIT, + file_access); + XtAddCallback(item->source, XtNcallback, SourceChanged, + (XtPointer)item); + } + item->flags |= EXISTS_BIT; + ResetSourceChanged(item); + } + else { + XmuSnprintf(buf, sizeof(buf), "Error saving file: %s\n", name); + Feep(); + } + break; + default: + XmuSnprintf(buf, sizeof(buf), "%s %s", + "Internal function MaybeCreateFile()", + "returned unexpected value.\n"); + Feep(); + break; + } + + XeditPrintf(buf); +} + +/*ARGSUSED*/ +void +DoLoad(Widget w, XtPointer client_data, XtPointer call_data) +{ + if (ReallyDoLoad(GetString(filenamewindow), ResolveName(NULL))) { + SwitchDirWindow(False); + XtSetKeyboardFocus(topwindow, textwindow); + } +} + +static Bool +ReallyDoLoad(char *name, char *filename) +{ + Arg args[5]; + Cardinal num_args = 0; + char buf[BUFSIZ]; + xedit_flist_item *item; + Widget source = XawTextGetSource(textwindow); + + if (!filename) { + XeditPrintf("Load: Can't resolve pathname.\n"); + Feep(); + return (False); + } + else if (*name == '\0') { + XeditPrintf("Load: No file specified.\n"); + Feep(); + } + if ((item = FindTextSource(NULL, filename)) != NULL) { + SwitchTextSource(item); + return (True); + } + else { + struct stat st; + + if (stat(filename, &st) == 0 && !S_ISREG(st.st_mode)) { + if (S_ISDIR(st.st_mode)) { + char path[BUFSIZ + 1]; + + strncpy(path, filename, sizeof(path) - 2); + path[sizeof(path) - 2] = '\0'; + if (*path) { + if (path[strlen(path) - 1] != '/') + strcat(path, "/"); + } + else + strcpy(path, "./"); + XtSetArg(args[0], XtNlabel, ""); + XtSetValues(dirlabel, args, 1); + SwitchDirWindow(True); + DirWindowCB(dirwindow, path, NULL); + return (False); + } + } + } + + { + Boolean exists; + int flags; + FileAccess file_access; + + switch( file_access = CheckFilePermissions(filename, &exists) ) { + case NO_READ: + if (exists) + XmuSnprintf(buf, sizeof(buf), "File %s, %s", name, + "exists, and could not be opened for reading.\n"); + else + XmuSnprintf(buf, sizeof(buf), "File %s %s %s", name, + "does not exist, and", + "the directory could not be opened for writing.\n"); + + XeditPrintf(buf); + Feep(); + return (False); + case READ_OK: + XtSetArg(args[num_args], XtNeditType, XawtextRead); num_args++; + XmuSnprintf(buf, sizeof(buf), "File %s opened READ ONLY.\n", + name); + break; + case WRITE_OK: + XtSetArg(args[num_args], XtNeditType, XawtextEdit); num_args++; + XmuSnprintf(buf, sizeof(buf), "File %s opened read - write.\n", + name); + break; + default: + XmuSnprintf(buf, sizeof(buf), "%s %s", + "Internal function MaybeCreateFile()", + "returned unexpected value.\n"); + XeditPrintf(buf); + Feep(); + return (False); + } + + XeditPrintf(buf); + + if (exists) { + flags = EXISTS_BIT; + XtSetArg(args[num_args], XtNstring, filename); num_args++; + } + else { + flags = 0; + XtSetArg(args[num_args], XtNstring, NULL); num_args++; + } + + source = XtVaCreateWidget("textSource", international ? + multiSrcObjectClass : asciiSrcObjectClass, + topwindow, + XtNtype, XawAsciiFile, + XtNeditType, XawtextEdit, + NULL, NULL); + XtSetValues(source, args, num_args); + + item = AddTextSource(source, name, filename, flags, file_access); + XtAddCallback(item->source, XtNcallback, SourceChanged, + (XtPointer)item); + if (exists && file_access == WRITE_OK) { + struct stat st; + + if (stat(filename, &st) == 0) + item->mode = st.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO); + } + SwitchTextSource(item); + ResetSourceChanged(item); + } + + return (True); +} + +/* Function Name: SourceChanged + * Description: A callback routine called when the source has changed. + * Arguments: w - the text source that has changed. + * client_data - xedit_flist_item associated with text buffer. + * call_data - NULL is unchanged + * Returns: none. + */ +/*ARGSUSED*/ +void +SourceChanged(Widget w, XtPointer client_data, XtPointer call_data) +{ + xedit_flist_item *item = (xedit_flist_item*)client_data; + Bool changed = (Bool)(long)call_data; + + if (changed) { + if (item->flags & CHANGED_BIT) + return; + item->flags |= CHANGED_BIT; + } + else { + if (item->flags & CHANGED_BIT) + ResetSourceChanged(item); + return; + } + + if (flist.pixmap) { + Arg args[1]; + Cardinal num_args; + int i; + + num_args = 0; + XtSetArg(args[num_args], XtNleftBitmap, flist.pixmap); ++num_args; + XtSetValues(item->sme, args, num_args); + + for (i = 0; i < 3; i++) + if (XawTextGetSource(texts[i]) == item->source) + XtSetValues(labels[i], args, num_args); + } +} + +/* Function Name: ResetSourceChanged. + * Description: Sets the source changed to FALSE, and + * registers a callback to set it to TRUE when + * the source has changed. + * Arguments: item - item with widget to register the callback on. + * Returns: none. + */ + +void +ResetSourceChanged(xedit_flist_item *item) +{ + Arg args[1]; + Cardinal num_args; + int i; + + num_args = 0; + XtSetArg(args[num_args], XtNleftBitmap, None); ++num_args; + XtSetValues(item->sme, args, num_args); + + dc_state = 0; + double_click = FALSE; + for (i = 0; i < 3; i++) { + if (XawTextGetSource(texts[i]) == item->source) + XtSetValues(labels[i], args, num_args); + AddDoubleClickCallback(XawTextGetSource(texts[i]), False); + } + + num_args = 0; + XtSetArg(args[num_args], XtNsourceChanged, False); ++num_args; + XtSetValues(item->source, args, num_args); + + item->flags &= ~CHANGED_BIT; +} + +/*ARGSUSED*/ +void +KillFile(Widget w, XEvent *event, String *params, Cardinal *num_params) +{ + xedit_flist_item *item = FindTextSource(XawTextGetSource(textwindow), NULL); + + if (item->source == scratch) { + Feep(); + return; + } + + if (item->flags & CHANGED_BIT) { + if (!double_click || (dc_state && dc_state != DC_KILL)) { + XeditPrintf("Kill: Unsaved changes. Kill again to override.\n"); + Feep(); + double_click = TRUE; + dc_state = DC_KILL; + AddDoubleClickCallback(XawTextGetSource(textwindow), True); + return; + } + double_click = FALSE; + dc_state = 0; + } + KillTextSource(item); +} + +/*ARGSUSED*/ +void +FindFile(Widget w, XEvent *event, String *params, Cardinal *num_params) +{ + char *string = GetString(filenamewindow); + char *slash = NULL; + XawTextBlock block; + XawTextPosition end = XawTextSourceScan(XawTextGetSource(filenamewindow), + 0, XawstAll, XawsdRight, 1, True); + + if (string) + slash = strrchr(string, '/'); + block.firstPos = 0; + block.format = FMT8BIT; + block.ptr = string; + block.length = slash ? slash - string + 1 : 0; + + if (block.length != end) + XawTextReplace(filenamewindow, 0, end, &block); + XawTextSetInsertionPoint(filenamewindow, end); + XtSetKeyboardFocus(topwindow, filenamewindow); + line_edit = False; +} + +/*ARGSUSED*/ +void +LoadFile(Widget w, XEvent *event, String *params, Cardinal *num_params) +{ + if (line_edit) + LineEdit(textwindow); + else if (ReallyDoLoad(GetString(filenamewindow), ResolveName(NULL))) { + SwitchDirWindow(False); + XtSetKeyboardFocus(topwindow, textwindow); + } +} + +/*ARGSUSED*/ +void +CancelFindFile(Widget w, XEvent *event, String *params, Cardinal *num_params) +{ + Arg args[1]; + xedit_flist_item *item; + + XtSetKeyboardFocus(topwindow, textwindow); + + item = FindTextSource(XawTextGetSource(textwindow), NULL); + + if (item->source != scratch) + XtSetArg(args[0], XtNstring, item->name); + else + XtSetArg(args[0], XtNstring, NULL); + + XtSetValues(filenamewindow, args, 1); + + if (XtIsManaged(XtParent(dirwindow))) + SwitchDirWindow(False); + + line_edit = False; +} + +static int +compar(_Xconst void *a, _Xconst void *b) +{ + return (strcmp(*(char **)a, *(char **)b)); +} + +/*ARGSUSED*/ +void +FileCompletion(Widget w, XEvent *event, String *params, Cardinal *num_params) +{ + XawTextBlock block; + String text; + int length; + char **matches, *save, *dir_name, *file_name, match[257]; + unsigned n_matches, len, mlen, buflen; + DIR *dir; + Bool changed, slash = False, dot = False, has_dot = False; +#define SM_NEVER 0 +#define SM_HINT 1 +#define SM_ALWAYS 2 + int show_matches; + + text = GetString(filenamewindow); + + if (!text) { + Feep(); + return; + } + else if (line_edit) { + Feep(); + line_edit = 0; + } + + { + XawTextPosition pos = XawTextGetInsertionPoint(w); + char *cslash = strchr(&text[pos], '/'), *cdot = strchr(&text[pos], '.'); + + if (cslash != NULL || cdot != NULL) { + if (cslash != NULL && (cdot == NULL || cdot > cslash)) { + length = cslash - text; + slash = True; + } + else { + length = cdot - text; + has_dot = True; + } + } + else + length = strlen(text); + } + + if (*num_params == 1 && length == strlen(text)) { + switch (params[0][0]) { + case 'n': /* Never */ + case 'N': + show_matches = SM_NEVER; + break; + case 'h': /* Hint */ + case 'H': + show_matches = SM_HINT; + break; + case 'a': /* Always */ + case 'A': + show_matches = SM_ALWAYS; + break; + default: + show_matches = SM_NEVER; + XtAppWarning(XtWidgetToApplicationContext(w), + "Bad argument to file-completion, " + "must be Never, Hint or Always"); + break; + } + } + else + show_matches = SM_NEVER; + + matches = NULL; + n_matches = buflen = 0; + save = XtMalloc(length + 1); + memmove(save, text, length); + save[length] = '\0'; + + if (save[0] == '~' && save[1]) { + char *slash2 = strchr(save, '/'); + int nlen; + + if (slash2) { + struct passwd *pw; + char home[BUFSIZ]; + char *name; + int slen = strlen(save), diff = slash2 - save; + + *slash2 = '\0'; + name = save + 1; + if ((nlen = strlen(name)) != 0) + pw = getpwnam(name); + else + pw = getpwuid(getuid()); + + if (pw) { + char fname[BUFSIZ]; + int hlen; + + strncpy(home, pw->pw_dir, sizeof(home) - 1); + home[sizeof(home) - 1] = '\0'; + hlen = strlen(home); + strncpy(fname, slash2 + 1, sizeof(fname) - 1); + fname[sizeof(fname) - 1] = '\0'; + save = XtRealloc(save, slen - diff + hlen + 2); + (void)memmove(&save[hlen], slash2, slen - diff + 1); + (void)memmove(save, home, hlen); + save[hlen] = '/'; + strcpy(&save[hlen + 1], fname); + + /* expand directory */ + block.length = strlen(save); + block.ptr = save; + block.firstPos = 0; + block.format = FMT8BIT; + XawTextReplace(filenamewindow, 0, length, &block); + XawTextSetInsertionPoint(filenamewindow, length = block.length); + } + else + *slash2 = '/'; + } + } + + if ((file_name = strrchr(save, '/')) != NULL) { + *file_name = '\0'; + ++file_name; + dir_name = save; + if (!file_name[0]) + slash = True; + if (!dir_name[0]) + dir_name = "/"; + } + else { + dir_name = "."; + dot = True; + file_name = save; + } + len = strlen(file_name); + + if ((dir = opendir(dir_name)) != NULL) { + char path[BUFSIZ], *pptr; + struct dirent *ent; + int isdir = 0, first = 1, bytes; + + XmuSnprintf(path, sizeof(path), "%s/", dir_name); + pptr = path + strlen(path); + bytes = sizeof(path) - (pptr - path) - 1; + + mlen = 0; + match[0] = '\0'; + (void)readdir(dir); /* "." */ + (void)readdir(dir); /* ".." */ + while ((ent = readdir(dir)) != NULL) { + unsigned d_namlen = strlen(ent->d_name); + + if (d_namlen >= len && strncmp(ent->d_name, file_name, len) == 0) { + char *tmp = &(ent->d_name[len]), *mat = match; + struct stat st; + Bool is_dir = FALSE; + + strncpy(pptr, ent->d_name, bytes); + pptr[bytes] = '\0'; + if (stat(path, &st) != 0) + /* Should check errno, may be a broken symbolic link + * a directory with r-- permission, etc */ + continue; + else if (first || show_matches != SM_NEVER) { + is_dir = S_ISDIR(st.st_mode); + } + + if (first) { + strncpy(match, tmp, sizeof(match) - 1); + match[sizeof(match) - 2] = '\0'; + mlen = strlen(match); + first = 0; + isdir = is_dir; + } + else { + while (*tmp && *mat && *tmp++ == *mat) + ++mat; + if (mlen > mat - match) { + mlen = mat - match; + match[mlen] = '\0'; + } + } + if (show_matches != SM_NEVER) { + matches = (char **)XtRealloc((char*)matches, sizeof(char**) + * (n_matches + 1)); + buflen += d_namlen + 1; + if (is_dir) { + matches[n_matches] = XtMalloc(d_namlen + 2); + strcpy(matches[n_matches], ent->d_name); + strcat(matches[n_matches], "/"); + ++buflen; + } + else + matches[n_matches] = XtNewString(ent->d_name); + } + else if (mlen == 0 && n_matches >= 1) { + ++n_matches; + break; + } + ++n_matches; + } + } + + closedir(dir); + changed = mlen != 0; + + if (n_matches) { + Bool free_matches = True, add_slash = n_matches == 1 && isdir && !slash; + + if (mlen && has_dot && match[mlen - 1] == '.') + --mlen; + + if (mlen || add_slash) { + XawTextPosition pos; + + block.firstPos = 0; + block.format = FMT8BIT; + if (mlen) { + pos = length; + block.length = mlen; + block.ptr = match; + XawTextReplace(filenamewindow, pos, pos, &block); + XawTextSetInsertionPoint(filenamewindow, pos + block.length); + } + if (add_slash) { + XawTextPosition actual = XawTextGetInsertionPoint(w); + + pos = XawTextSourceScan(XawTextGetSource(w), 0, XawstAll, + XawsdRight, 1, True); + block.length = 1; + block.ptr = "/"; + XawTextReplace(filenamewindow, pos, pos, &block); + if (actual == pos) + XawTextSetInsertionPoint(filenamewindow, pos + 1); + } + } + else if (n_matches != 1 || isdir) { + if (show_matches == SM_NEVER) + Feep(); + } + + if (show_matches != SM_NEVER) { + if (show_matches == SM_ALWAYS || (!changed && n_matches != 1)) { + char **list = NULL, *label; + int n_list; + Arg args[2]; + + XtSetArg(args[0], XtNlist, &list); + XtSetArg(args[1], XtNnumberStrings, &n_list); + XtGetValues(dirwindow, args, 2); + + matches = (char **)XtRealloc((char*)matches, sizeof(char**) + * (n_matches + 2)); + matches[n_matches++] = XtNewString("./"); + matches[n_matches++] = XtNewString("../"); + qsort(matches, n_matches, sizeof(char*), compar); + XtSetArg(args[0], XtNlist, matches); + XtSetArg(args[1], XtNnumberStrings, n_matches); + XtSetValues(dirwindow, args, 2); + if (n_list > 0 + && (n_list != 1 || list[0] != XtName(dirwindow))) { + while (--n_list > -1) + XtFree(list[n_list]); + XtFree((char*)list); + } + + label = ResolveName(dir_name); + XtSetArg(args[0], XtNlabel, label); + XtSetValues(dirlabel, args, 1); + SwitchDirWindow(True); + free_matches = False; + } + } + if (free_matches && matches) { + while (--n_matches > -1) + XtFree(matches[n_matches]); + XtFree((char*)matches); + } + } + else + Feep(); + } + else + Feep(); + + XtFree(save); +} + +/*ARGSUSED*/ +void +DirWindowCB(Widget w, XtPointer user_data, XtPointer call_data) +{ + XawListReturnStruct *file_info = (XawListReturnStruct *)call_data; + char *dir_name, *string, path[BUFSIZ]; + Arg args[2]; + + if (file_info == NULL) + string = (char *)user_data; + else + string = file_info->string; + + XtSetArg(args[0], XtNlabel, &dir_name); + XtGetValues(dirlabel, args, 1); + if (*dir_name == '\0') { + strncpy(path, string, sizeof(path) - 1); + path[sizeof(path) - 1] = '\0'; + } + else if (strcmp(dir_name, "/") == 0) + XmuSnprintf(path, sizeof(path), "/%s", string); + else + XmuSnprintf(path, sizeof(path), "%s/%s", dir_name, string); + + if (*string && string[strlen(string) - 1] == '/') { + DIR *dir; + + if ((dir = opendir(path)) != NULL) { + struct dirent *ent; + struct stat st; + unsigned d_namlen; + Bool isdir; + char **entries = NULL, **list = NULL; + int n_entries = 0, n_list = 0; + char *label, *pptr = path + strlen(path); + int bytes = sizeof(path) - (pptr - path) - 1; + + while ((ent = readdir(dir)) != NULL) { + d_namlen = strlen(ent->d_name); + strncpy(pptr, ent->d_name, bytes); + pptr[bytes] = '\0'; + if (stat(path, &st) != 0) + /* Should check errno, may be a broken symbolic link + * a directory with r-- permission, etc */ + continue; + else + isdir = S_ISDIR(st.st_mode); + + entries = (char **)XtRealloc((char*)entries, sizeof(char*) + * (n_entries + 1)); + if (isdir) { + entries[n_entries] = XtMalloc(d_namlen + 2); + strcpy(entries[n_entries], ent->d_name); + strcat(entries[n_entries], "/"); + } + else + entries[n_entries] = XtNewString(ent->d_name); + ++n_entries; + } + closedir(dir); + + XtSetArg(args[0], XtNlist, &list); + XtSetArg(args[1], XtNnumberStrings, &n_list); + XtGetValues(dirwindow, args, 2); + + if (n_entries == 0) { + entries = (char**)XtMalloc(sizeof(char*) * 2); + /* Directory has read but not execute permission? */ + entries[n_entries++] = XtNewString("./"); + entries[n_entries++] = XtNewString("../"); + } + qsort(entries, n_entries, sizeof(char*), compar); + XtSetArg(args[0], XtNlist, entries); + XtSetArg(args[1], XtNnumberStrings, n_entries); + XtSetValues(dirwindow, args, 2); + if (n_list > 0 + && (n_list != 1 || list[0] != XtName(dirwindow))) { + while (--n_list > -1) + XtFree(list[n_list]); + XtFree((char*)list); + } + + *pptr = '\0'; + if ((label = ResolveName(path)) == NULL) { + Feep(); + label = path; + } + XtSetArg(args[0], XtNlabel, label); + XtSetValues(dirlabel, args, 1); + + strncpy(path, label, sizeof(path) - 2); + if (*path && path[strlen(path) - 1] != '/') + strcat(path, "/"); + XtSetArg(args[0], XtNstring, path); + XtSetValues(filenamewindow, args, 1); + XtSetKeyboardFocus(topwindow, filenamewindow); + XawTextSetInsertionPoint(filenamewindow, strlen(path)); + } + else + Feep(); + } + else { + (void)ReallyDoLoad(path, path); + SwitchDirWindow(False); + XtSetKeyboardFocus(topwindow, textwindow); + } +} |