![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to svgancui.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [UNIX Amiga Emulator] / uae / src|
Return to svgancui.c CVS log | Up to [UNIX Amiga Emulator] / uae / src |
1.1 root 1: /*
2: * UAE - The Un*x Amiga Emulator
3: *
4: * ncurses frontend for a text-based user interface.
5: *
6: * Copyright 1996 Bernd Schmidt
7: * If you find the routines in this file useful, you may use them in your
8: * programs without restrictions. Essentially, it's in the public domain.
9: *
10: */
11:
12:
13: #include "sysconfig.h"
14: #include "sysdeps.h"
15:
16: #include <ncurses.h>
17:
18: #include "config.h"
19: #include "options.h"
20: #include "tui.h"
21:
22: static WINDOW *currwin;
23:
24: static WINDOW *winstack[10]; /* more than enough */
25: static int winnr = 0;
26:
27: void tui_setup(void)
28: {
29: int i;
30:
31: for (i = 0; i < 10; i++)
32: winstack[i] = NULL;
33: /* From the ncurses manpage... */
34: initscr(); start_color(); cbreak(); noecho(); nonl(); intrflush(stdscr, FALSE); keypad(stdscr, TRUE);
35: currwin = stdscr;
36: if (has_colors()) {
37: init_pair(1, COLOR_WHITE, COLOR_BLUE);
38: init_pair(2, COLOR_BLACK, COLOR_WHITE);
39: wattron(currwin, COLOR_PAIR(1) | A_BOLD);
40: wbkgd(currwin, ' '|COLOR_PAIR(1));
41: }
42:
43: winstack[0] = stdscr;
44: winnr = 1;
45: }
46:
47: int tui_lines(void)
48: {
49: return LINES;
50: }
51:
52: int tui_cols(void)
53: {
54: return COLS;
55: }
56:
57: void tui_shutdown(void)
58: {
59: endwin();
60: }
61:
62: void tui_refresh(void)
63: {
64: wrefresh(currwin);
65: }
66:
67: void tui_puts(const char *s)
68: {
69: waddstr(currwin, s);
70: }
71:
72: void tui_cursoff(void)
73: {
74: }
75:
76: void tui_curson(void)
77: {
78: }
79:
80: void tui_putc(char c)
81: {
82: waddch(currwin, c);
83: }
84:
85: void tui_cr(void)
86: {
87: waddch(currwin, '\r');
88: }
89:
90: char tui_getc(void)
91: {
92: return getch();
93: }
94:
95: void tui_gotoxy(int x, int y)
96: {
97: x--; y--;
98: wmove(currwin, y, x);
99: }
100:
101: void tui_selwin(int w)
102: {
103: currwin = winstack[w];
104: }
105:
106: void tui_clrwin(int w)
107: {
108: wclear(winstack[w]);
109: }
110:
111: void tui_drawbox(int w)
112: {
113: wborder(winstack[w], 0, 0, 0, 0, 0, 0, 0, 0);
114: }
115:
116: void tui_hline(int x1, int y1, int x2)
117: {
118: wmove(currwin, y1-1, x1-1);
119: whline(currwin, 0, x2-x1+1);
120: }
121:
122: int tui_dlog(int x1, int y1, int x2, int y2)
123: {
124: x1--; y1--;
125: winstack[winnr] = newwin(y2 - y1, x2 - x1, y1, x1);
126: return winnr++;
127: }
128:
129: void tui_dlogdie(int w)
130: {
131: if (currwin == winstack[w])
132: currwin = stdscr;
133: delwin(winstack[w]);
134: winstack[w] = NULL;
135: while (winstack[winnr-1] == NULL)
136: winnr--;
137:
138: for (w = 0; w < winnr; w++)
139: redrawwin(winstack[w]), wrefresh(winstack[w]);
140: }
141:
142: int tui_gets(char *buf, int x, int y, int n)
143: {
144: int i = 0;
145: for (;;) {
146: int c = getch();
147: int j;
148: wmove(currwin, y, x);
149: for (j = 0; j < i; j++)
150: waddch(currwin, buf[j]);
151: for (; j < n; j++)
152: waddch(currwin, ' ');
153: wmove(currwin, y, x + i);
154: wrefresh(currwin);
155: buf[i] = 0;
156: if (c == 13)
157: return 1;
158: else if (c == 27)
159: return 0;
160: else if (i + 1 < n)
161: buf[i++] = c;
162: }
163: }
164:
165: int tui_wgets(char *buf, const char *title, int n)
166: {
167: int l = strlen(title);
168: int ww = l > n ? l : n;
169: int w = tui_dlog((tui_cols()-ww-2)/2, tui_lines()/2-1, (tui_cols()+ww+2)/2, tui_lines()/2+1);
170: tui_selwin(w); tui_drawbox(w);
171: wmove(currwin, 0, (ww-l)/2);
172: waddstr(currwin, title);
173: return tui_gets(buf, 1, 1, n);
174: }
175:
176:
177: static char *pattern;
178: static int maxlen;
179:
180: static void put_filename(char *s, int x, int y, attr_t a)
181: {
182: char buf[256];
183: int i;
184:
185: tui_gotoxy(x,y);
186: if (strcmp(s, ".") == 0)
187: strcpy(buf, "(none)");
188: else
189: strcpy(buf, s);
190: buf[maxlen] = 0;
191: for (i = 0; i < strlen(buf); i++)
192: waddch(currwin, buf[i] | a);
193: for (; i < maxlen; i++)
194: waddch(currwin, ' ' | a);
195: }
196:
197: static char fsbuf[256];
198:
199: static int selectfn(const struct dirent *de)
200: {
201: int l1, l2;
202:
203: /* l1 = strlen(pattern + 1);*/
204: l2 = strlen(de->d_name);
205:
206: if (l2 >= tui_cols()-10) /* Restrict length of filenames so we won't mess up the display */
207: return 0;
208:
209: /* No pattern matching for now. But we don't show hidden files. */
210: if (strcmp(de->d_name, ".") != 0 && strcmp(de->d_name, "..") != 0
211: && de->d_name[0] == '.')
212: return 0;
213: if (l2 > maxlen)
214: maxlen = l2;
215: return 1;
216: }
217:
218: char *tui_filereq(char *s, char *oldfile)
219: {
220: char cwd[256];
221: char *retval = fsbuf;
222: char *tmp;
223: int fin = 0;
224:
225: /* Save wd */
226: if (getcwd(cwd, 256) == NULL)
227: return NULL;
228:
229: /* Change into directory of old file */
230: strcpy(fsbuf, oldfile);
231: tmp = strrchr(fsbuf, '/');
232: if (tmp != NULL) {
233: *tmp = 0;
234: if (strlen(fsbuf) > 0)
235: chdir(fsbuf);
236: }
237:
238: pattern = s;
239: if (s[0] != '*')
240: fprintf(stderr, "Can't handle wildcard %s\n", s);
241: if (s[1] != 0 && strchr(s+1, '*') != NULL)
242: fprintf(stderr, "Can't handle wildcard %s\n", s);
243: for (;!fin;) {
244: struct dirent **names;
245: int i, w, n, l, yp, oldyp, s;
246:
247: maxlen = 0;
248: n = scandir(".", &names, selectfn, alphasort);
249:
250: if (n <= 0)
251: return NULL;
252: l = n;
253: if (l > 15)
254: l = 15;
255: yp = s = 0; oldyp = -1;
256: w = tui_dlog(5, 5, 5 + maxlen + 3, 5 + l + 1);
257: tui_selwin(w); tui_drawbox(w);
258: for (;;) {
259: int c;
260: char tmp[256];
261: while (s < yp)
262: yp--;
263: while (s >= yp + l)
264: yp++;
265: if (oldyp != yp) {
266: oldyp = yp;
267: for (i = 0; i < l; i++) {
268: put_filename(names[i + yp]->d_name, 3, 2 + i, 0);
269: }
270: }
271: put_filename(names[s]->d_name, 3, 2 + s - yp, A_STANDOUT);
272: tui_refresh();
273: c = getch();
274: put_filename(names[s]->d_name, 3, 2 + s - yp, 0);
275: if (c == 27) {
276: retval = NULL; fin = 1;
277: break;
278: } else if (c == KEY_ENTER || c == 13 || c == ' ') {
279: int err;
280:
281: if (strcmp(names[s]->d_name, ".") == 0) {
282: fin = 1;
283: strcpy(fsbuf, "");
284: break;
285: }
286: err = chdir(names[s]->d_name);
287:
288: if (err == 0)
289: break;
290: else if (errno == ENOTDIR) {
291: fin = 1;
292: if (getcwd(fsbuf, 256) == NULL)
293: retval = NULL;
294: if (strlen(fsbuf) + strlen(names[s]->d_name) + 2 >= 256)
295: retval = NULL;
296: else {
297: strcat(fsbuf, "/");
298: strcat(fsbuf, names[s]->d_name);
299: }
300: break;
301: } /* else what? */
302: }
303: switch (c) {
304: case KEY_UP:
305: if (s > 0)
306: s--;
307: break;
308: case KEY_DOWN:
309: if (s + 1 < n)
310: s++;
311: break;
312: case KEY_PPAGE:
313: if (s > l)
314: s -= l;
315: else
316: s = 0;
317: break;
318: case KEY_NPAGE:
319: if (s + l < n)
320: s += l;
321: else
322: s = n - 1;
323: break;
324: default:
325: for (i = 0; i < n; i++)
326: if (names[i]->d_name[0] == c) {
327: s = i;
328: break;
329: }
330: }
331: }
332: #if 0
333: /* @@@ is this right? */
334: for (i = 0; i < n; i++)
335: free(names[i]->d_name);
336: free(names);
337: #endif
338: tui_dlogdie(w);
339: }
340: chdir(cwd);
341: return retval;
342: }
343:
344: int tui_backup_optionsfile(void)
345: {
346: char tmp[257];
347: strcpy(tmp, optionsfile);
348: strcat(tmp, "~");
349: return rename(optionsfile, tmp);
350: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.