mirrors/nano
1
0
Fork 0
mirror of git://git.sv.gnu.org/nano.git synced 2024-12-25 11:57:05 +03:00
Code Issues Packages Projects Releases Wiki Activity
834a69d5a4
nano/winio.c
Chris Allegretta e7034c6087 onekey() - Off by one error fix fix ;-) (Rocco Corsi) 
git-svn-id: svn://svn.savannah.gnu.org/nano/trunk/nano@221 35c25a1d-7b9e-4130-9fde-d3aeb78583b8
2000-09-15 03:31:09 +00:00

1304 lines
30 KiB
C
Raw Blame History

/* $Id$ */
/**************************************************************************
* winio.c *
* *
* Copyright (C) 1999 Chris Allegretta *
* 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 1, 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 program; if not, write to the Free Software *
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. *
* *
**************************************************************************/
#include <stdarg.h>
#include <string.h>
#include <stdlib.h>
#include "config.h"
#include "proto.h"
#include "nano.h"
#ifndef NANO_SMALL
#include <libintl.h>
#define _(string) gettext(string)
#else
#define _(string) (string)
#endif
static int statblank = 0; /* Number of keystrokes left after
we call statubar() before we
actually blank the statusbar */
/* Local Function Prototypes for only winio.c */
inline int get_page_from_virtual(int virtual);
inline int get_page_start_virtual(int page);
inline int get_page_end_virtual(int page);
/* Window I/O */
int do_first_line(void)
{
current = fileage;
placewewant = 0;
current_x = 0;
edit_update(current, CENTER);
return 1;
}
int do_last_line(void)
{
current = filebot;
placewewant = 0;
current_x = 0;
edit_update(current, CENTER);
return 1;
}
/* Like xplustabs, but for a specifc index of a speficific filestruct */
int xpt(filestruct * fileptr, int index)
{
int i, tabs = 0;
if (fileptr == NULL || fileptr->data == NULL)
return 0;
for (i = 0; i < index && fileptr->data[i] != 0; i++) {
tabs++;
if (fileptr->data[i] == NANO_CONTROL_I) {
if (tabs % tabsize == 0);
else
tabs += tabsize - (tabs % tabsize);
} else if (fileptr->data[i] & 0x80)
/* Make 8 bit chars only 1 collumn! */
;
else if (fileptr->data[i] < 32)
tabs++;
}
return tabs;
}
/* Return the actual place on the screen of current->data[current_x], which
should always be > current_x */
int xplustabs(void)
{
return xpt(current, current_x);
}
/* Return what current_x should be, given xplustabs() for the line,
* given a start position in the filestruct's data */
int actual_x_from_start(filestruct * fileptr, int xplus, int start)
{
int i, tot = 1;
if (fileptr == NULL || fileptr->data == NULL)
return 0;
for (i = start; tot <= xplus && fileptr->data[i] != 0; i++, tot++)
if (fileptr->data[i] == NANO_CONTROL_I) {
if (tot % tabsize == 0)
tot++;
else
tot += tabsize - (tot % tabsize);
} else if (fileptr->data[i] & 0x80)
tot++; /* Make 8 bit chars only 1 column (again) */
else if (fileptr->data[i] < 32)
tot += 2;
#ifdef DEBUG
fprintf(stderr, _("actual_x_from_start for xplus=%d returned %d\n"),
xplus, i);
#endif
return i - start;
}
/* Opposite of xplustabs */
inline int actual_x(filestruct * fileptr, int xplus)
{
return actual_x_from_start(fileptr, xplus, 0);
}
/* a strlen with tabs factored in, similar to xplustabs() */
int strlenpt(char *buf)
{
int i, tabs = 0;
if (buf == NULL)
return 0;
for (i = 0; buf[i] != 0; i++) {
tabs++;
if (buf[i] == NANO_CONTROL_I) {
if (tabs % tabsize == 0);
else
tabs += tabsize - (tabs % tabsize);
} else if (buf[i] & 0x80)
/* Make 8 bit chars only 1 collumn! */
;
else if (buf[i] < 32)
tabs++;
}
return tabs;
}
/* resets current_y based on the position of current and puts the cursor at
(current_y, current_x) */
void reset_cursor(void)
{
filestruct *ptr = edittop;
int x;
current_y = 0;
while (ptr != current && ptr != editbot && ptr->next != NULL) {
ptr = ptr->next;
current_y++;
}
x = xplustabs();
if (x <= COLS - 2)
wmove(edit, current_y, x);
else
wmove(edit, current_y, x -
get_page_start_virtual(get_page_from_virtual(x)));
}
void blank_bottombars(void)
{
int i = no_help()? 3 : 1;
for (; i <= 2; i++)
mvwaddstr(bottomwin, i, 0, hblank);
}
void blank_edit(void)
{
int i;
for (i = 0; i <= editwinrows - 1; i++)
mvwaddstr(edit, i, 0, hblank);
wrefresh(edit);
}
void blank_statusbar(void)
{
mvwaddstr(bottomwin, 0, 0, hblank);
}
void blank_statusbar_refresh(void)
{
blank_statusbar();
wrefresh(bottomwin);
}
void check_statblank(void)
{
if (statblank > 1)
statblank--;
else if (statblank == 1 && !ISSET(CONSTUPDATE)) {
statblank--;
blank_statusbar_refresh();
}
}
/* Get the input from the kb, this should only be called from statusq */
int nanogetstr(char *buf, char *def, shortcut s[], int slen, int start_x)
{
int kbinput = 0, j = 0, x = 0, xend;
int x_left = 0;
char inputstr[132], inputbuf[132] = "";
blank_statusbar();
mvwaddstr(bottomwin, 0, 0, buf);
if (strlen(def) > 0)
waddstr(bottomwin, def);
wrefresh(bottomwin);
x_left = strlen(buf);
x = strlen(def) + x_left;
/* Get the input! */
if (strlen(def) > 0) {
strcpy(answer, def);
strcpy(inputbuf, def);
}
while ((kbinput = wgetch(bottomwin)) != 13) {
for (j = 0; j <= slen - 1; j++) {
if (kbinput == s[j].val) {
strcpy(answer, "");
return s[j].val;
}
}
xend = strlen(buf) + strlen(inputbuf);
switch (kbinput) {
case KEY_HOME:
x = x_left;
blank_statusbar();
mvwaddstr(bottomwin, 0, 0, buf);
waddstr(bottomwin, inputbuf);
wmove(bottomwin, 0, x);
break;
case KEY_END:
x = x_left + strlen(inputbuf);
blank_statusbar();
mvwaddstr(bottomwin, 0, 0, buf);
waddstr(bottomwin, inputbuf);
wmove(bottomwin, 0, x);
break;
case KEY_RIGHT:
if (x < xend)
x++;
wmove(bottomwin, 0, x);
break;
case NANO_CONTROL_D:
if (strlen(inputbuf) > 0 && (x - x_left) != strlen(inputbuf)) {
memmove(inputbuf + (x - x_left),
inputbuf + (x - x_left) + 1,
strlen(inputbuf) - (x - x_left) - 1);
inputbuf[strlen(inputbuf) - 1] = 0;
}
blank_statusbar();
mvwaddstr(bottomwin, 0, 0, buf);
waddstr(bottomwin, inputbuf);
wmove(bottomwin, 0, x);
break;
case NANO_CONTROL_K:
case NANO_CONTROL_U:
*inputbuf = 0;
x = x_left;
blank_statusbar();
mvwaddstr(bottomwin, 0, 0, buf);
waddstr(bottomwin, inputbuf);
wmove(bottomwin, 0, x);
break;
case KEY_BACKSPACE:
case KEY_DC:
case 127:
case NANO_CONTROL_H:
if (strlen(inputbuf) > 0) {
if (x == (x_left + strlen(inputbuf)))
inputbuf[strlen(inputbuf) - 1] = 0;
else if (x - x_left) {
memmove(inputbuf + (x - x_left) - 1,
inputbuf + (x - x_left),
strlen(inputbuf) - (x - x_left));
inputbuf[strlen(inputbuf) - 1] = 0;
}
}
blank_statusbar();
mvwaddstr(bottomwin, 0, 0, buf);
waddstr(bottomwin, inputbuf);
case KEY_LEFT:
if (x > strlen(buf))
x--;
wmove(bottomwin, 0, x);
break;
case KEY_UP:
case KEY_DOWN:
break;
case 27:
switch (kbinput = wgetch(edit)) {
case 79:
switch (kbinput = wgetch(edit)) {
case 70:
x = x_left + strlen(inputbuf);
blank_statusbar();
mvwaddstr(bottomwin, 0, 0, buf);
waddstr(bottomwin, inputbuf);
wmove(bottomwin, 0, x);
break;
case 72:
x = x_left;
blank_statusbar();
mvwaddstr(bottomwin, 0, 0, buf);
waddstr(bottomwin, inputbuf);
wmove(bottomwin, 0, x);
break;
}
break;
case 91:
switch (kbinput = wgetch(edit)) {
case 'C':
if (x < xend)
x++;
wmove(bottomwin, 0, x);
break;
case 'D':
if (x > strlen(buf))
x--;
wmove(bottomwin, 0, x);
break;
case 49:
x = x_left;
blank_statusbar();
mvwaddstr(bottomwin, 0, 0, buf);
waddstr(bottomwin, inputbuf);
wmove(bottomwin, 0, x);
goto skip_126;
case 51:
if (strlen(inputbuf) > 0
&& (x - x_left) != strlen(inputbuf)) {
memmove(inputbuf + (x - x_left),
inputbuf + (x - x_left) + 1,
strlen(inputbuf) - (x - x_left) - 1);
inputbuf[strlen(inputbuf) - 1] = 0;
}
blank_statusbar();
mvwaddstr(bottomwin, 0, 0, buf);
waddstr(bottomwin, inputbuf);
wmove(bottomwin, 0, x);
goto skip_126;
case 52:
x = x_left + strlen(inputbuf);
blank_statusbar();
mvwaddstr(bottomwin, 0, 0, buf);
waddstr(bottomwin, inputbuf);
wmove(bottomwin, 0, x);
goto skip_126;
skip_126:
nodelay(edit, TRUE);
kbinput = wgetch(edit);
if (kbinput == 126 || kbinput == ERR)
kbinput = -1;
nodelay(edit, FALSE);
break;
}
}
blank_statusbar();
mvwaddstr(bottomwin, 0, 0, buf);
waddstr(bottomwin, inputbuf);
wmove(bottomwin, 0, x);
break;
default:
if (kbinput < 32)
break;
strcpy(inputstr, inputbuf);
inputstr[x - strlen(buf)] = kbinput;
strcpy(&inputstr[x - strlen(buf) + 1],
&inputbuf[x - strlen(buf)]);
strcpy(inputbuf, inputstr);
x++;
mvwaddstr(bottomwin, 0, 0, buf);
waddstr(bottomwin, inputbuf);
wmove(bottomwin, 0, x);
#ifdef DEBUG
fprintf(stderr, _("input \'%c\' (%d)\n"), kbinput, kbinput);
#endif
}
wrefresh(bottomwin);
}
strncpy(answer, inputbuf, 132);
if (!strcmp(answer, ""))
return -2;
else
return 0;
}
void horizbar(WINDOW * win, int y)
{
wattron(win, A_REVERSE);
mvwaddstr(win, 0, 0, hblank);
wattroff(win, A_REVERSE);
}
void titlebar(void)
{
int namelen, space;
horizbar(topwin, 0);
wattron(topwin, A_REVERSE);
mvwaddstr(topwin, 0, 3, VERMSG);
space = COLS - strlen(VERMSG) - strlen(VERSION) - 21;
namelen = strlen(filename);
if (!strcmp(filename, ""))
mvwaddstr(topwin, 0, center_x - 6, _("New Buffer"));
else {
if (namelen > space) {
waddstr(topwin, _(" File: ..."));
waddstr(topwin, &filename[namelen - space]);
} else {
mvwaddstr(topwin, 0, center_x - (namelen / 2 + 1), "File: ");
waddstr(topwin, filename);
}
}
if (ISSET(MODIFIED))
mvwaddstr(topwin, 0, COLS - 10, _("Modified"));
wattroff(topwin, A_REVERSE);
wrefresh(topwin);
reset_cursor();
}
void onekey(char *keystroke, char *desc)
{
char description[80];
snprintf(description, 12, " %-10s", desc);
wattron(bottomwin, A_REVERSE);
waddstr(bottomwin, keystroke);
wattroff(bottomwin, A_REVERSE);
waddstr(bottomwin, description);
}
void clear_bottomwin(void)
{
if (ISSET(NO_HELP))
return;
mvwaddstr(bottomwin, 1, 0, hblank);
mvwaddstr(bottomwin, 2, 0, hblank);
}
void bottombars(shortcut s[], int slen)
{
int i, j, k;
char keystr[10];
if (ISSET(NO_HELP))
return;
/* Determine how many extra spaces are needed to fill the bottom of the screen */
k = COLS / 6 - 13;
clear_bottomwin();
wmove(bottomwin, 1, 0);
for (i = 0; i <= slen - 1; i += 2) {
snprintf(keystr, 10, "^%c", s[i].val + 64);
onekey(keystr, s[i].desc);
for (j = 0; j < k; j++)
waddch(bottomwin, ' ');
}
wmove(bottomwin, 2, 0);
for (i = 1; i <= slen - 1; i += 2) {
snprintf(keystr, 10, "^%c", s[i].val + 64);
onekey(keystr, s[i].desc);
for (j = 0; j < k; j++)
waddch(bottomwin, ' ');
}
wrefresh(bottomwin);
}
/* If modified is not already set, set it and update titlebar */
void set_modified(void)
{
if (!ISSET(MODIFIED)) {
SET(MODIFIED);
titlebar();
wrefresh(topwin);
}
}
/* And so start the display update routines */
/* Given a column, this returns the "page" it is on */
/* "page" in the case of the display columns, means which set of 80 */
/* characters is viewable (ie: page 1 shows from 1 to COLS) */
inline int get_page_from_virtual(int virtual)
{
int page = 2;
if (virtual <= COLS - 2)
return 1;
virtual -= (COLS - 2);
while (virtual > COLS - 2 - 7) {
virtual -= (COLS - 2 - 7);
page++;
}
return page;
}
/* The inverse of the above function */
inline int get_page_start_virtual(int page)
{
int virtual;
virtual = --page * (COLS - 7);
if (page)
virtual -= 2 * page - 1;
return virtual;
}
inline int get_page_end_virtual(int page)
{
return get_page_start_virtual(page) + COLS - 1;
}
#ifndef NANO_SMALL
/* This takes care of the case where there is a mark that covers only */
/* the current line. */
/* It expects a line with no tab characers (ie: the type that edit_add */
/* deals with */
void add_marked_sameline(int begin, int end, filestruct * fileptr, int y,
int virt_cur_x, int this_page)
{
/*
* The general idea is to break the line up into 3 sections: before
* the mark, the mark, and after the mark. We then paint each in
* turn (for those that are currently visible, of course
*
* 3 start points: 0 -> begin, begin->end, end->strlen(data)
* in data : pre sel post
*/
int this_page_start = get_page_start_virtual(this_page),
this_page_end = get_page_end_virtual(this_page);
/* likewise, 3 data lengths */
int pre_data_len = begin, sel_data_len = end - begin, post_data_len = 0; /* Determined from the other two */
/* now fix the start locations & lengths according to the cursor's
* position (ie: our page) */
if (pre_data_len < this_page_start)
pre_data_len = 0;
else
pre_data_len -= this_page_start;
if (begin < this_page_start)
begin = this_page_start;
if (end < this_page_start)
end = this_page_start;
if (begin > this_page_end)
begin = this_page_end;
if (end > this_page_end)
end = this_page_end;
/* Now calculate the lengths */
sel_data_len = end - begin;
post_data_len = this_page_end - end;
/* Paint this line! */
mvwaddnstr(edit, y, 0, &fileptr->data[this_page_start], pre_data_len);
wattron(edit, A_REVERSE);
mvwaddnstr(edit, y, begin - this_page_start,
&fileptr->data[begin], sel_data_len);
wattroff(edit, A_REVERSE);
mvwaddnstr(edit, y, end - this_page_start,
&fileptr->data[end], post_data_len);
}
#endif
/* edit_add takes care of the job of actually painting a line into the
* edit window.
*
* Called only from update_line. Expects a converted-to-not-have-tabs
* line */
void edit_add(filestruct * fileptr, int yval, int start, int virt_cur_x,
int virt_mark_beginx, int this_page)
{
#ifndef NANO_SMALL
/* There are quite a few cases that could take place, we'll deal
* with them each in turn */
if (ISSET(MARK_ISSET)
&& !((fileptr->lineno > mark_beginbuf->lineno
&& fileptr->lineno > current->lineno)
|| (fileptr->lineno < mark_beginbuf->lineno
&& fileptr->lineno < current->lineno)))
{
/* If we get here we are on a line that is atleast
* partially selected. The lineno checks above determined
* that */
if (fileptr != mark_beginbuf && fileptr != current) {
/* We are on a completely marked line, paint it all
* inverse */
wattron(edit, A_REVERSE);
mvwaddnstr(edit, yval, 0, fileptr->data, COLS);
wattroff(edit, A_REVERSE);
} else if (fileptr == mark_beginbuf && fileptr == current) {
/* Special case, we're still on the same line we started
* marking -- so we call our helper function */
if (virt_cur_x < virt_mark_beginx) {
/* To the right of us is marked */
add_marked_sameline(virt_cur_x, virt_mark_beginx,
fileptr, yval, virt_cur_x,
this_page);
} else {
/* To the left of us is marked */
add_marked_sameline(virt_mark_beginx, virt_cur_x,
fileptr, yval, virt_cur_x,
this_page);
}
} else if (fileptr == mark_beginbuf) {
/*
* we're updating the line that was first marked
* but we're not currently on it. So we want to
* figur out which half to invert based on our
* relative line numbers.
*
* i.e. If we're above the "beginbuf" line, we want to
* mark the left side. Otherwise we're below, so we
* mark the right
*/
int target;
if (mark_beginbuf->lineno > current->lineno)
wattron(edit, A_REVERSE);
target =
(virt_mark_beginx <
COLS - 1) ? virt_mark_beginx : COLS - 1;
mvwaddnstr(edit, yval, 0, fileptr->data, target);
if (mark_beginbuf->lineno < current->lineno)
wattron(edit, A_REVERSE);
else
wattroff(edit, A_REVERSE);
target = (COLS - 1) - virt_mark_beginx;
if (target < 0)
target = 0;
mvwaddnstr(edit, yval, virt_mark_beginx,
&fileptr->data[virt_mark_beginx], target);
if (mark_beginbuf->lineno < current->lineno)
wattroff(edit, A_REVERSE);
} else if (fileptr == current) {
/* we're on the cursors line, but it's not the first
* one we marked. Similar to the previous logic. */
int this_page_start = get_page_start_virtual(this_page),
this_page_end = get_page_end_virtual(this_page);
if (mark_beginbuf->lineno < current->lineno)
wattron(edit, A_REVERSE);
if (virt_cur_x > COLS - 2) {
mvwaddnstr(edit, yval, 0,
&fileptr->data[this_page_start],
virt_cur_x - this_page_start);
} else {
mvwaddnstr(edit, yval, 0, fileptr->data, virt_cur_x);
}
if (mark_beginbuf->lineno > current->lineno)
wattron(edit, A_REVERSE);
else
wattroff(edit, A_REVERSE);
if (virt_cur_x > COLS - 2)
mvwaddnstr(edit, yval, virt_cur_x - this_page_start,
&fileptr->data[virt_cur_x],
this_page_end - virt_cur_x);
else
mvwaddnstr(edit, yval, virt_cur_x,
&fileptr->data[virt_cur_x],
COLS - virt_cur_x);
if (mark_beginbuf->lineno > current->lineno)
wattroff(edit, A_REVERSE);
}
} else
#endif
/* Just paint the string (no mark on this line) */
mvwaddnstr(edit, yval, 0, &fileptr->data[start],
get_page_end_virtual(this_page) - start);
}
/*
* Just update one line in the edit buffer. Basically a wrapper for
* edit_add
*
* index gives is a place in the string to update starting from.
* Likely args are current_x or 0.
*/
void update_line(filestruct * fileptr, int index)
{
filestruct *filetmp;
int line = 0, col = 0;
int virt_cur_x = current_x, virt_mark_beginx = mark_beginx;
char *realdata, *tmp;
int i, pos, len, page;
if (!fileptr)
return;
/* First, blank out the line (at a minimum) */
for (filetmp = edittop; filetmp != fileptr && filetmp != editbot;
filetmp = filetmp->next)
line++;
mvwaddstr(edit, line, 0, hblank);
/* Next, convert all the tabs to spaces so everything else is easy */
index = xpt(fileptr, index);
realdata = fileptr->data;
len = strlen(realdata);
fileptr->data = nmalloc(xpt(fileptr, len) + 1);
pos = 0;
for (i = 0; i < len; i++) {
if (realdata[i] == '\t') {
do {
fileptr->data[pos++] = ' ';
if (i < current_x)
virt_cur_x++;
if (i < mark_beginx)
virt_mark_beginx++;
} while (pos % tabsize);
/* must decrement once to account for tab-is-one-character */
if (i < current_x)
virt_cur_x--;
if (i < mark_beginx)
virt_mark_beginx--;
}
else if (realdata[i] >= 1 && realdata[i] <= 26) {
/* Treat control characters as ^letter */
fileptr->data[pos++] = '^';
fileptr->data[pos++] = realdata[i] + 64;
} else {
fileptr->data[pos++] = realdata[i];
}
}
fileptr->data[pos] = '\0';
/* Now, Paint the line */
if (current == fileptr && index > COLS - 2) {
/* This handles when the current line is beyond COLS */
/* It requires figureing out what page we're at */
page = get_page_from_virtual(index);
col = get_page_start_virtual(page);
edit_add(filetmp, line, col, virt_cur_x, virt_mark_beginx, page);
mvwaddch(edit, line, 0, '$');
if (strlenpt(fileptr->data) > get_page_end_virtual(page))
mvwaddch(edit, line, COLS - 1, '$');
} else {
/* It's not the current line means that it's at x=0 and page=1 */
/* If it is the current line, then we're in the same boat */
edit_add(filetmp, line, 0, virt_cur_x, virt_mark_beginx, 1);
if (strlenpt(&filetmp->data[col]) > COLS)
mvwaddch(edit, line, COLS - 1, '$');
}
/* Clean up our mess */
tmp = fileptr->data;
fileptr->data = realdata;
free(tmp);
}
void center_cursor(void)
{
current_y = editwinrows / 2;
wmove(edit, current_y, current_x);
}
/* Refresh the screen without changing the position of lines */
void edit_refresh(void)
{
static int noloop = 0;
int lines = 0, i = 0, currentcheck = 0;
filestruct *temp, *hold = current;
if (current == NULL)
return;
temp = edittop;
while (lines <= editwinrows - 1 && lines <= totlines && temp != NULL) {
hold = temp;
update_line(temp, current_x);
if (temp == current)
currentcheck = 1;
temp = temp->next;
lines++;
}
/* If noloop == 1, then we already did an edit_update without finishing
this function. So we don't run edit_update again */
if (!currentcheck && !noloop) /* Then current has run off the screen... */
{
edit_update(current, CENTER);
noloop = 1;
}
else if (noloop)
noloop = 0;
if (lines <= editwinrows - 1)
while (lines <= editwinrows - 1) {
mvwaddstr(edit, lines, i, hblank);
lines++;
}
if (temp == NULL)
editbot = hold;
else
editbot = temp;
}
/*
* Same as above, but touch the window first so everything is redrawn.
*/
void edit_refresh_clearok(void)
{
clearok(edit, TRUE);
edit_refresh();
clearok(edit, FALSE);
}
/*
* Nice generic routine to update the edit buffer given a pointer to the
* file struct =)
*/
void edit_update(filestruct * fileptr, int topmidbot)
{
int i = 0;
filestruct *temp;
if (fileptr == NULL)
return;
temp = fileptr;
if (topmidbot == 2)
;
else if (topmidbot == 0)
for (i = 0; i <= editwinrows - 1 && temp->prev != NULL; i++)
temp = temp->prev;
else
for (i = 0; i <= editwinrows / 2 && temp->prev != NULL; i++)
temp = temp->prev;
edittop = temp;
fix_editbot();
edit_refresh();
}
/* This function updates current based on where current_y is, reset_cursor
does the opposite */
void update_cursor(void)
{
int i = 0;
#ifdef DEBUG
fprintf(stderr, _("Moved to (%d, %d) in edit buffer\n"), current_y,
current_x);
#endif
current = edittop;
while (i <= current_y - 1 && current->next != NULL) {
current = current->next;
i++;
}
#ifdef DEBUG
fprintf(stderr, _("current->data = \"%s\"\n"), current->data);
#endif
}
/*
* Ask a question on the statusbar. Answer will be stored in answer
* global. Returns -1 on aborted enter, -2 on a blank string, and 0
* otherwise, the valid shortcut key caught, Def is any editable text we
* want to put up by default.
*/
int statusq(shortcut s[], int slen, char *def, char *msg, ...)
{
va_list ap;
char foo[133];
int ret;
bottombars(s, slen);
va_start(ap, msg);
vsnprintf(foo, 132, msg, ap);
va_end(ap);
strncat(foo, ": ", 132);
wattron(bottomwin, A_REVERSE);
ret = nanogetstr(foo, def, s, slen, (strlen(foo) + 3));
wattroff(bottomwin, A_REVERSE);
switch (ret) {
case NANO_FIRSTLINE_KEY:
do_first_line();
break;
case NANO_LASTLINE_KEY:
do_last_line();
break;
case NANO_CANCEL_KEY:
return -1;
default:
blank_statusbar_refresh();
}
#ifdef DEBUG
fprintf(stderr, _("I got \"%s\"\n"), answer);
#endif
return ret;
}
/*
* Ask a simple yes/no question on the statusbar. Returns 1 for Y, 0 for
* N, 2 for All (if all is non-zero when passed in) and -1 for abort (^C)
*/
int do_yesno(int all, int leavecursor, char *msg, ...)
{
va_list ap;
char foo[133];
int kbinput, ok = -1;
/* Write the bottom of the screen */
clear_bottomwin();
wattron(bottomwin, A_REVERSE);
blank_statusbar_refresh();
wattroff(bottomwin, A_REVERSE);
/* Remove gettext call for keybindings until we clear the thing up */
if (!ISSET(NO_HELP)) {
wmove(bottomwin, 1, 0);
onekey(" Y", _("Yes"));
if (all)
onekey(" A", _("All"));
wmove(bottomwin, 2, 0);
onekey(" N", _("No"));
onekey("^C", _("Cancel"));
}
va_start(ap, msg);
vsnprintf(foo, 132, msg, ap);
va_end(ap);
wattron(bottomwin, A_REVERSE);
mvwaddstr(bottomwin, 0, 0, foo);
wattroff(bottomwin, A_REVERSE);
wrefresh(bottomwin);
if (leavecursor == 1)
reset_cursor();
while (ok == -1) {
kbinput = wgetch(edit);
switch (kbinput) {
case 'Y':
case 'y':
ok = 1;
break;
case 'N':
case 'n':
ok = 0;
break;
case 'A':
case 'a':
if (all)
ok = 2;
break;
case NANO_CONTROL_C:
ok = -2;
break;
}
}
/* Then blank the screen */
blank_statusbar_refresh();
if (ok == -2)
return -1;
else
return ok;
}
void statusbar(char *msg, ...)
{
va_list ap;
char foo[133];
int start_x = 0;
va_start(ap, msg);
vsnprintf(foo, 132, msg, ap);
va_end(ap);
start_x = center_x - strlen(foo) / 2 - 1;
/* Blank out line */
blank_statusbar();
wmove(bottomwin, 0, start_x);
wattron(bottomwin, A_REVERSE);
waddstr(bottomwin, "[ ");
waddstr(bottomwin, foo);
waddstr(bottomwin, " ]");
wattroff(bottomwin, A_REVERSE);
wrefresh(bottomwin);
if (ISSET(CONSTUPDATE))
statblank = 1;
else
statblank = 25;
}
void display_main_list(void)
{
bottombars(main_list, MAIN_VISIBLE);
}
int total_refresh(void)
{
clearok(edit, TRUE);
clearok(topwin, TRUE);
clearok(bottomwin, TRUE);
wnoutrefresh(edit);
wnoutrefresh(topwin);
wnoutrefresh(bottomwin);
doupdate();
clearok(edit, FALSE);
clearok(topwin, FALSE);
clearok(bottomwin, FALSE);
edit_refresh();
titlebar();
return 1;
}
void previous_line(void)
{
if (current_y > 0)
current_y--;
}
int do_cursorpos(void)
{
filestruct *fileptr;
float linepct, bytepct;
int i, tot = 0;
if (current == NULL || fileage == NULL)
return 0;
for (fileptr = fileage; fileptr != current && fileptr != NULL;
fileptr = fileptr->next)
tot += strlen(fileptr->data) + 1;
if (fileptr == NULL)
return -1;
i = tot + current_x;;
for (fileptr = current->next; fileptr != NULL; fileptr = fileptr->next)
tot += strlen(fileptr->data) + 1;
if (totlines > 0)
linepct = 100 * current->lineno / totlines;
else
linepct = 0;
if (totsize > 0)
bytepct = 100 * i / totsize;
else
bytepct = 0;
#ifdef DEBUG
fprintf(stderr, _("do_cursorpos: linepct = %f, bytepct = %f\n"),
linepct, bytepct);
#endif
statusbar(_("line %d of %d (%.0f%%), character %d of %d (%.0f%%)"),
current->lineno, totlines, linepct, i, totsize, bytepct);
reset_cursor();
return 1;
}
/* Our broken, non-shortcut list compliant help function.
But hey, it's better than nothing, and it's dynamic! */
int do_help(void)
{
#ifndef NANO_SMALL
char *ptr = help_text, *end;
int i, j, row = 0, page = 1, kbinput = 0, no_more = 0;
int no_help_flag = 0;
blank_edit();
curs_set(0);
blank_statusbar();
if (ISSET(NO_HELP)) {
no_help_flag = 1;
delwin(bottomwin);
bottomwin = newwin(3, COLS, LINES - 3, 0);
keypad(bottomwin, TRUE);
editwinrows -= no_help();
UNSET(NO_HELP);
bottombars(help_list, HELP_LIST_LEN);
} else
bottombars(help_list, HELP_LIST_LEN);
do {
ptr = help_text;
switch (kbinput) {
case NANO_NEXTPAGE_KEY:
case NANO_NEXTPAGE_FKEY:
case KEY_NPAGE:
if (!no_more) {
blank_edit();
page++;
}
break;
case NANO_PREVPAGE_KEY:
case NANO_PREVPAGE_FKEY:
case KEY_PPAGE:
if (page > 1) {
no_more = 0;
blank_edit();
page--;
}
break;
}
/* Calculate where in the text we should be based on the page */
for (i = 1; i < page; i++) {
row = 0;
j = 0;
while (row < editwinrows - 2 && *ptr != '\0') {
if (*ptr == '\n' || j == COLS - 5) {
j = 0;
row++;
}
ptr++;
j++;
}
}
if (i > 1) {
}
i = 0;
j = 0;
while (i < editwinrows && *ptr != '\0') {
end = ptr;
while (*end != '\n' && *end != '\0' && j != COLS - 5) {
end++;
j++;
}
if (j == COLS - 5) {
/* Don't print half a word if we've run of of space */
while (*end != ' ' && *end != '\0') {
end--;
j--;
}
}
mvwaddnstr(edit, i, 0, ptr, j);
j = 0;
i++;
if (*end == '\n')
end++;
ptr = end;
}
if (*ptr == '\0') {
no_more = 1;
continue;
}
} while ((kbinput = wgetch(edit)) != NANO_EXIT_KEY);
if (no_help_flag) {
werase(bottomwin);
wrefresh(bottomwin);
delwin(bottomwin);
SET(NO_HELP);
bottomwin = newwin(3 - no_help(), COLS, LINES - 3 + no_help(), 0);
keypad(bottomwin, TRUE);
editwinrows += no_help();
} else
display_main_list();
curs_set(1);
edit_refresh();
#else
nano_small_msg();
#endif
return 1;
}
/* Dump the current file structure to stderr */
void dump_buffer(filestruct * inptr)
{
#ifdef DEBUG
filestruct *fileptr;
if (inptr == fileage)
fprintf(stderr, _("Dumping file buffer to stderr...\n"));
else if (inptr == cutbuffer)
fprintf(stderr, _("Dumping cutbuffer to stderr...\n"));
else
fprintf(stderr, _("Dumping a buffer to stderr...\n"));
fileptr = inptr;
while (fileptr != NULL) {
fprintf(stderr, "(%ld) %s\n", fileptr->lineno, fileptr->data);
fflush(stderr);
fileptr = fileptr->next;
}
#endif /* DEBUG */
}
void dump_buffer_reverse(filestruct * inptr)
{
#ifdef DEBUG
filestruct *fileptr;
fileptr = filebot;
while (fileptr != NULL) {
fprintf(stderr, "(%ld) %s\n", fileptr->lineno, fileptr->data);
fflush(stderr);
fileptr = fileptr->prev;
}
#endif /* DEBUG */
}
/* Fix editbot based on the assumption that edittop is correct */
void fix_editbot(void) {
int i;
editbot = edittop;
for(i = 0; (i <= editwinrows - 1) && (editbot->next != NULL)
&& (editbot != filebot); i++, editbot = editbot->next);
}
Reference in New Issue View Git Blame Copy Permalink