- Fix for possible unset uid/gid in toproto - Fix for default mtree style - Update libelf - Importing libexecinfo - Resynchronize GCC, mpc, gmp, mpfr - build.sh: Replace params with show-params. This has been done as the make target has been renamed in the same way, while a new target named params has been added. This new target generates a file containing all the parameters, instead of printing it on the console. - Update test48 with new etc/services (Fix by Ben Gras <ben@minix3.org) get getservbyport() out of the inner loop Change-Id: Ie6ad5226fa2621ff9f0dee8782ea48f9443d2091
3651 lines
87 KiB
C
3651 lines
87 KiB
C
/* $NetBSD: internals.c,v 1.37 2013/11/26 01:17:00 christos Exp $ */
|
|
|
|
/*-
|
|
* Copyright (c) 1998-1999 Brett Lymn
|
|
* (blymn@baea.com.au, brett_lymn@yahoo.com.au)
|
|
* All rights reserved.
|
|
*
|
|
* This code has been donated to The NetBSD Foundation by the Author.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. The name of the author may not be used to endorse or promote products
|
|
* derived from this software without specific prior written permission
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
*
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__RCSID("$NetBSD: internals.c,v 1.37 2013/11/26 01:17:00 christos Exp $");
|
|
|
|
#include <limits.h>
|
|
#include <ctype.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <strings.h>
|
|
#include <assert.h>
|
|
#include "internals.h"
|
|
#include "form.h"
|
|
|
|
#ifdef DEBUG
|
|
/*
|
|
* file handle to write debug info to, this will be initialised when
|
|
* the form is first posted.
|
|
*/
|
|
FILE *dbg = NULL;
|
|
|
|
/*
|
|
* map the request numbers to strings for debug
|
|
*/
|
|
char *reqs[] = {
|
|
"NEXT_PAGE", "PREV_PAGE", "FIRST_PAGE", "LAST_PAGE", "NEXT_FIELD",
|
|
"PREV_FIELD", "FIRST_FIELD", "LAST_FIELD", "SNEXT_FIELD",
|
|
"SPREV_FIELD", "SFIRST_FIELD", "SLAST_FIELD", "LEFT_FIELD",
|
|
"RIGHT_FIELD", "UP_FIELD", "DOWN_FIELD", "NEXT_CHAR", "PREV_CHAR",
|
|
"NEXT_LINE", "PREV_LINE", "NEXT_WORD", "PREV_WORD", "BEG_FIELD",
|
|
"END_FIELD", "BEG_LINE", "END_LINE", "LEFT_CHAR", "RIGHT_CHAR",
|
|
"UP_CHAR", "DOWN_CHAR", "NEW_LINE", "INS_CHAR", "INS_LINE",
|
|
"DEL_CHAR", "DEL_PREV", "DEL_LINE", "DEL_WORD", "CLR_EOL",
|
|
"CLR_EOF", "CLR_FIELD", "OVL_MODE", "INS_MODE", "SCR_FLINE",
|
|
"SCR_BLINE", "SCR_FPAGE", "SCR_BPAGE", "SCR_FHPAGE", "SCR_BHPAGE",
|
|
"SCR_FCHAR", "SCR_BCHAR", "SCR_HFLINE", "SCR_HBLINE", "SCR_HFHALF",
|
|
"SCR_HBHALF", "VALIDATION", "PREV_CHOICE", "NEXT_CHOICE" };
|
|
#endif
|
|
|
|
/* define our own min function - this is not generic but will do here
|
|
* (don't believe me? think about what value you would get
|
|
* from min(x++, y++)
|
|
*/
|
|
#define min(a,b) (((a) > (b))? (b) : (a))
|
|
|
|
/* for the line joining function... */
|
|
#define JOIN_NEXT 1
|
|
#define JOIN_NEXT_NW 2 /* next join, don't wrap the joined line */
|
|
#define JOIN_PREV 3
|
|
#define JOIN_PREV_NW 4 /* previous join, don't wrap the joined line */
|
|
|
|
/* for the bump_lines function... */
|
|
#define _FORMI_USE_CURRENT -1 /* indicates current cursor pos to be used */
|
|
|
|
/* used in add_char for initial memory allocation for string in row */
|
|
#define INITIAL_LINE_ALLOC 16
|
|
|
|
unsigned
|
|
field_skip_blanks(unsigned int start, _FORMI_FIELD_LINES **rowp);
|
|
static void
|
|
_formi_do_char_validation(FIELD *field, FIELDTYPE *type, char c, int *ret_val);
|
|
static void
|
|
_formi_do_validation(FIELD *field, FIELDTYPE *type, int *ret_val);
|
|
static int
|
|
_formi_join_line(FIELD *field, _FORMI_FIELD_LINES **rowp, int direction);
|
|
void
|
|
_formi_hscroll_back(FIELD *field, _FORMI_FIELD_LINES *row, unsigned int amt);
|
|
void
|
|
_formi_hscroll_fwd(FIELD *field, _FORMI_FIELD_LINES *row, unsigned int amt);
|
|
static void
|
|
_formi_scroll_back(FIELD *field, unsigned int amt);
|
|
static void
|
|
_formi_scroll_fwd(FIELD *field, unsigned int amt);
|
|
static int
|
|
_formi_set_cursor_xpos(FIELD *field, int no_scroll);
|
|
static int
|
|
find_sow(unsigned int offset, _FORMI_FIELD_LINES **rowp);
|
|
static int
|
|
split_line(FIELD *field, bool hard_split, unsigned pos,
|
|
_FORMI_FIELD_LINES **rowp);
|
|
static bool
|
|
check_field_size(FIELD *field);
|
|
static int
|
|
add_tab(FORM *form, _FORMI_FIELD_LINES *row, unsigned int i, char c);
|
|
static int
|
|
tab_size(_FORMI_FIELD_LINES *row, unsigned int i);
|
|
static unsigned int
|
|
tab_fit_len(_FORMI_FIELD_LINES *row, unsigned int len);
|
|
static int
|
|
tab_fit_window(FIELD *field, unsigned int pos, unsigned int window);
|
|
static void
|
|
add_to_free(FIELD *field, _FORMI_FIELD_LINES *line);
|
|
static void
|
|
adjust_ypos(FIELD *field, _FORMI_FIELD_LINES *line);
|
|
static _FORMI_FIELD_LINES *
|
|
copy_row(_FORMI_FIELD_LINES *row);
|
|
static void
|
|
destroy_row_list(_FORMI_FIELD_LINES *start);
|
|
|
|
/*
|
|
* Calculate the cursor y position to make the given row appear on the
|
|
* field. This may be as simple as just changing the ypos (if at all) but
|
|
* may encompass resetting the start_line of the field to place the line
|
|
* at the bottom of the field. The field is assumed to be a multi-line one.
|
|
*/
|
|
static void
|
|
adjust_ypos(FIELD *field, _FORMI_FIELD_LINES *line)
|
|
{
|
|
unsigned ypos;
|
|
_FORMI_FIELD_LINES *rs;
|
|
|
|
ypos = 0;
|
|
rs = field->alines;
|
|
while (rs != line) {
|
|
rs = rs->next;
|
|
ypos++;
|
|
}
|
|
|
|
field->cursor_ypos = ypos;
|
|
field->start_line = field->alines;
|
|
if (ypos > (field->rows - 1)) {
|
|
/*
|
|
* cur_line off the end of the field,
|
|
* adjust start_line so fix this.
|
|
*/
|
|
field->cursor_ypos = field->rows - 1;
|
|
ypos = ypos - (field->rows - 1);
|
|
while (ypos > 0) {
|
|
ypos--;
|
|
field->start_line = field->start_line->next;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Delete the given row and add it to the free list of the given field.
|
|
*/
|
|
static void
|
|
add_to_free(FIELD *field, _FORMI_FIELD_LINES *line)
|
|
{
|
|
_FORMI_FIELD_LINES *saved;
|
|
|
|
saved = line;
|
|
|
|
/* don't remove if only one line... */
|
|
if ((line->prev == NULL) && (line->next == NULL))
|
|
return;
|
|
|
|
if (line->prev == NULL) {
|
|
/* handle top of list */
|
|
field->alines = line->next;
|
|
field->alines->prev = NULL;
|
|
|
|
if (field->cur_line == saved)
|
|
field->cur_line = field->alines;
|
|
if (field->start_line == saved)
|
|
field->start_line = saved;
|
|
} else if (line->next == NULL) {
|
|
/* handle bottom of list */
|
|
line->prev->next = NULL;
|
|
if (field->cur_line == saved)
|
|
field->cur_line = saved->prev;
|
|
if (field->start_line == saved)
|
|
field->cur_line = saved->prev;
|
|
} else {
|
|
saved->next->prev = saved->prev;
|
|
saved->prev->next = saved->next;
|
|
if (field->cur_line == saved)
|
|
field->cur_line = saved->prev;
|
|
if (field->start_line == saved)
|
|
field->start_line = saved;
|
|
}
|
|
|
|
saved->next = field->free;
|
|
field->free = saved;
|
|
saved->prev = NULL;
|
|
if (saved->next != NULL)
|
|
saved->next->prev = line;
|
|
}
|
|
|
|
/*
|
|
* Duplicate the given row, return the pointer to the new copy or
|
|
* NULL if the copy fails.
|
|
*/
|
|
static _FORMI_FIELD_LINES *
|
|
copy_row(_FORMI_FIELD_LINES *row)
|
|
{
|
|
_FORMI_FIELD_LINES *new;
|
|
_formi_tab_t *tp, *newt;
|
|
|
|
if ((new = (_FORMI_FIELD_LINES *) malloc(sizeof(_FORMI_FIELD_LINES)))
|
|
== NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
memcpy(new, row, sizeof(_FORMI_FIELD_LINES));
|
|
|
|
/* nuke the pointers from the source row so we don't get confused */
|
|
new->next = NULL;
|
|
new->prev = NULL;
|
|
new->tabs = NULL;
|
|
|
|
if ((new->string = (char *) malloc((size_t)new->allocated)) == NULL) {
|
|
free(new);
|
|
return NULL;
|
|
}
|
|
|
|
memcpy(new->string, row->string, (size_t) row->length + 1);
|
|
|
|
if (row->tabs != NULL) {
|
|
tp = row->tabs;
|
|
if ((new->tabs = (_formi_tab_t *) malloc(sizeof(_formi_tab_t)))
|
|
== NULL) {
|
|
free(new->string);
|
|
free(new);
|
|
return NULL;
|
|
}
|
|
|
|
memcpy(new->tabs, row->tabs, sizeof(_formi_tab_t));
|
|
new->tabs->back = NULL;
|
|
new->tabs->fwd = NULL;
|
|
|
|
tp = tp->fwd;
|
|
newt = new->tabs;
|
|
|
|
while (tp != NULL) {
|
|
if ((newt->fwd =
|
|
(_formi_tab_t *) malloc(sizeof(_formi_tab_t)))
|
|
== NULL) {
|
|
/* error... unwind allocations */
|
|
tp = new->tabs;
|
|
while (tp != NULL) {
|
|
newt = tp->fwd;
|
|
free(tp);
|
|
tp = newt;
|
|
}
|
|
|
|
free(new->string);
|
|
free(new);
|
|
return NULL;
|
|
}
|
|
|
|
memcpy(newt->fwd, tp, sizeof(_formi_tab_t));
|
|
newt->fwd->back = newt;
|
|
newt = newt->fwd;
|
|
newt->fwd = NULL;
|
|
tp = tp->fwd;
|
|
}
|
|
}
|
|
|
|
return new;
|
|
}
|
|
|
|
/*
|
|
* Initialise the row offset for a field, depending on the type of
|
|
* field it is and the type of justification used. The justification
|
|
* is only used on static single line fields, everything else will
|
|
* have the cursor_xpos set to 0.
|
|
*/
|
|
void
|
|
_formi_init_field_xpos(FIELD *field)
|
|
{
|
|
/* not static or is multi-line which are not justified, so 0 it is */
|
|
if (((field->opts & O_STATIC) != O_STATIC) ||
|
|
((field->rows + field->nrows) != 1)) {
|
|
field->cursor_xpos = 0;
|
|
return;
|
|
}
|
|
|
|
switch (field->justification) {
|
|
case JUSTIFY_RIGHT:
|
|
field->cursor_xpos = field->cols - 1;
|
|
break;
|
|
|
|
case JUSTIFY_CENTER:
|
|
field->cursor_xpos = (field->cols - 1) / 2;
|
|
break;
|
|
|
|
default: /* assume left justify */
|
|
field->cursor_xpos = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Open the debug file if it is not already open....
|
|
*/
|
|
#ifdef DEBUG
|
|
int
|
|
_formi_create_dbg_file(void)
|
|
{
|
|
if (dbg == NULL) {
|
|
dbg = fopen("___form_dbg.out", "w");
|
|
if (dbg == NULL) {
|
|
fprintf(stderr, "Cannot open debug file!\n");
|
|
return E_SYSTEM_ERROR;
|
|
}
|
|
}
|
|
|
|
return E_OK;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Check the sizing of the field, if the maximum size is set for a
|
|
* dynamic field then check that the number of rows or columns does
|
|
* not exceed the set maximum. The decision to check the rows or
|
|
* columns is made on the basis of how many rows are in the field -
|
|
* one row means the max applies to the number of columns otherwise it
|
|
* applies to the number of rows. If the row/column count is less
|
|
* than the maximum then return TRUE.
|
|
*
|
|
*/
|
|
static bool
|
|
check_field_size(FIELD *field)
|
|
{
|
|
if ((field->opts & O_STATIC) != O_STATIC) {
|
|
/* dynamic field */
|
|
if (field->max == 0) /* unlimited */
|
|
return TRUE;
|
|
|
|
if (field->rows == 1) {
|
|
return (field->alines->length < field->max);
|
|
} else {
|
|
return (field->row_count <= field->max);
|
|
}
|
|
} else {
|
|
if ((field->rows + field->nrows) == 1) {
|
|
return (field->alines->length <= field->cols);
|
|
} else {
|
|
return (field->row_count <= (field->rows
|
|
+ field->nrows));
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Set the form's current field to the first valid field on the page.
|
|
* Assume the fields have been sorted and stitched.
|
|
*/
|
|
int
|
|
_formi_pos_first_field(FORM *form)
|
|
{
|
|
FIELD *cur;
|
|
int old_page;
|
|
|
|
old_page = form->page;
|
|
|
|
/* scan forward for an active page....*/
|
|
while (form->page_starts[form->page].in_use == 0) {
|
|
form->page++;
|
|
if (form->page > form->max_page) {
|
|
form->page = old_page;
|
|
return E_REQUEST_DENIED;
|
|
}
|
|
}
|
|
|
|
/* then scan for a field we can use */
|
|
cur = form->fields[form->page_starts[form->page].first];
|
|
while ((cur->opts & (O_VISIBLE | O_ACTIVE))
|
|
!= (O_VISIBLE | O_ACTIVE)) {
|
|
cur = TAILQ_NEXT(cur, glue);
|
|
if (cur == NULL) {
|
|
form->page = old_page;
|
|
return E_REQUEST_DENIED;
|
|
}
|
|
}
|
|
|
|
form->cur_field = cur->index;
|
|
return E_OK;
|
|
}
|
|
|
|
/*
|
|
* Set the field to the next active and visible field, the fields are
|
|
* traversed in index order in the direction given. If the parameter
|
|
* use_sorted is TRUE then the sorted field list will be traversed instead
|
|
* of using the field index.
|
|
*/
|
|
int
|
|
_formi_pos_new_field(FORM *form, unsigned direction, unsigned use_sorted)
|
|
{
|
|
FIELD *cur;
|
|
int i;
|
|
|
|
i = form->cur_field;
|
|
cur = form->fields[i];
|
|
|
|
do {
|
|
if (direction == _FORMI_FORWARD) {
|
|
if (use_sorted == TRUE) {
|
|
if ((form->wrap == FALSE) &&
|
|
(cur == TAILQ_LAST(&form->sorted_fields,
|
|
_formi_sort_head)))
|
|
return E_REQUEST_DENIED;
|
|
cur = TAILQ_NEXT(cur, glue);
|
|
i = cur->index;
|
|
} else {
|
|
if ((form->wrap == FALSE) &&
|
|
((i + 1) >= form->field_count))
|
|
return E_REQUEST_DENIED;
|
|
i++;
|
|
if (i >= form->field_count)
|
|
i = 0;
|
|
}
|
|
} else {
|
|
if (use_sorted == TRUE) {
|
|
if ((form->wrap == FALSE) &&
|
|
(cur == TAILQ_FIRST(&form->sorted_fields)))
|
|
return E_REQUEST_DENIED;
|
|
cur = TAILQ_PREV(cur, _formi_sort_head, glue);
|
|
i = cur->index;
|
|
} else {
|
|
if ((form->wrap == FALSE) && (i <= 0))
|
|
return E_REQUEST_DENIED;
|
|
i--;
|
|
if (i < 0)
|
|
i = form->field_count - 1;
|
|
}
|
|
}
|
|
|
|
if ((form->fields[i]->opts & (O_VISIBLE | O_ACTIVE))
|
|
== (O_VISIBLE | O_ACTIVE)) {
|
|
form->cur_field = i;
|
|
return E_OK;
|
|
}
|
|
}
|
|
while (i != form->cur_field);
|
|
|
|
return E_REQUEST_DENIED;
|
|
}
|
|
|
|
/*
|
|
* Destroy the list of line structs passed by freeing all allocated
|
|
* memory.
|
|
*/
|
|
static void
|
|
destroy_row_list(_FORMI_FIELD_LINES *start)
|
|
{
|
|
_FORMI_FIELD_LINES *temp, *row;
|
|
_formi_tab_t *tt, *tp;
|
|
|
|
row = start;
|
|
while (row != NULL) {
|
|
if (row->tabs != NULL) {
|
|
/* free up the tab linked list... */
|
|
tp = row->tabs;
|
|
while (tp != NULL) {
|
|
tt = tp->fwd;
|
|
free(tp);
|
|
tp = tt;
|
|
}
|
|
}
|
|
|
|
if (row->string != NULL)
|
|
free(row->string);
|
|
|
|
temp = row->next;
|
|
free(row);
|
|
row = temp;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Word wrap the contents of the field's buffer 0 if this is allowed.
|
|
* If the wrap is successful, that is, the row count nor the buffer
|
|
* size is exceeded then the function will return E_OK, otherwise it
|
|
* will return E_REQUEST_DENIED.
|
|
*/
|
|
int
|
|
_formi_wrap_field(FIELD *field, _FORMI_FIELD_LINES *loc)
|
|
{
|
|
int width, wrap_err;
|
|
unsigned int pos, saved_xpos, saved_ypos, saved_cur_xpos;
|
|
unsigned int saved_row_count;
|
|
_FORMI_FIELD_LINES *saved_row, *row, *row_backup, *saved_cur_line;
|
|
_FORMI_FIELD_LINES *saved_start_line, *temp;
|
|
|
|
if ((field->opts & O_STATIC) == O_STATIC) {
|
|
if ((field->rows + field->nrows) == 1) {
|
|
return E_OK; /* cannot wrap a single line */
|
|
}
|
|
width = field->cols;
|
|
} else {
|
|
/* if we are limited to one line then don't try to wrap */
|
|
if ((field->drows + field->nrows) == 1) {
|
|
return E_OK;
|
|
}
|
|
|
|
/*
|
|
* hueristic - if a dynamic field has more than one line
|
|
* on the screen then the field grows rows, otherwise
|
|
* it grows columns, effectively a single line field.
|
|
* This is documented AT&T behaviour.
|
|
*/
|
|
if (field->rows > 1) {
|
|
width = field->cols;
|
|
} else {
|
|
return E_OK;
|
|
}
|
|
}
|
|
|
|
row = loc;
|
|
|
|
/* if we are not at the top of the field then back up one
|
|
* row because we may be able to merge the current row into
|
|
* the one above.
|
|
*/
|
|
if (row->prev != NULL)
|
|
row = row->prev;
|
|
|
|
saved_row = row;
|
|
saved_xpos = field->row_xpos;
|
|
saved_cur_xpos = field->cursor_xpos;
|
|
saved_ypos = field->cursor_ypos;
|
|
saved_row_count = field->row_count;
|
|
|
|
/*
|
|
* Save a copy of the lines affected, just in case things
|
|
* don't work out.
|
|
*/
|
|
if ((row_backup = copy_row(row)) == NULL)
|
|
return E_SYSTEM_ERROR;
|
|
|
|
temp = row_backup;
|
|
row = row->next;
|
|
|
|
saved_cur_line = temp;
|
|
saved_start_line = temp;
|
|
|
|
while (row != NULL) {
|
|
if ((temp->next = copy_row(row)) == NULL) {
|
|
/* a row copy failed... free up allocations */
|
|
destroy_row_list(row_backup);
|
|
return E_SYSTEM_ERROR;
|
|
}
|
|
|
|
temp->next->prev = temp;
|
|
temp = temp->next;
|
|
|
|
if (row == field->start_line)
|
|
saved_start_line = temp;
|
|
if (row == field->cur_line)
|
|
saved_cur_line = temp;
|
|
|
|
row = row->next;
|
|
}
|
|
|
|
row = saved_row;
|
|
while (row != NULL) {
|
|
pos = row->length - 1;
|
|
if (row->expanded < width) {
|
|
/* line may be too short, try joining some lines */
|
|
if ((row->hard_ret == TRUE) && (row->next != NULL)) {
|
|
/*
|
|
* Skip the line if it has a hard return
|
|
* and it is not the last, we cannot join
|
|
* anything to it.
|
|
*/
|
|
row = row->next;
|
|
continue;
|
|
}
|
|
|
|
if (row->next == NULL) {
|
|
/*
|
|
* If there are no more lines and this line
|
|
* is too short then our job is over.
|
|
*/
|
|
break;
|
|
}
|
|
|
|
if (_formi_join_line(field, &row,
|
|
JOIN_NEXT_NW) == E_OK) {
|
|
continue;
|
|
} else
|
|
break;
|
|
} else if (row->expanded > width) {
|
|
/* line is too long, split it */
|
|
|
|
/*
|
|
* split on first whitespace before current word
|
|
* if the line has tabs we need to work out where
|
|
* the field border lies when the tabs are expanded.
|
|
*/
|
|
if (row->tabs == NULL) {
|
|
pos = width - 1;
|
|
if (pos >= row->expanded)
|
|
pos = row->expanded - 1;
|
|
} else {
|
|
pos = tab_fit_len(row, field->cols);
|
|
}
|
|
|
|
if ((!isblank((unsigned char)row->string[pos])) &&
|
|
((field->opts & O_WRAP) == O_WRAP)) {
|
|
if (!isblank((unsigned char)row->string[pos - 1]))
|
|
pos = find_sow((unsigned int) pos,
|
|
&row);
|
|
/*
|
|
* If we cannot split the line then return
|
|
* NO_ROOM so the driver can tell that it
|
|
* should not autoskip (if that is enabled)
|
|
*/
|
|
if ((pos == 0)
|
|
|| (!isblank((unsigned char)row->string[pos - 1]))) {
|
|
wrap_err = E_NO_ROOM;
|
|
goto restore_and_exit;
|
|
}
|
|
}
|
|
|
|
/* if we are at the end of the string and it has
|
|
* a trailing blank, don't wrap the blank.
|
|
*/
|
|
if ((row->next == NULL) && (pos == row->length - 1) &&
|
|
(isblank((unsigned char)row->string[pos])) &&
|
|
row->expanded <= field->cols)
|
|
continue;
|
|
|
|
/*
|
|
* otherwise, if we are still sitting on a
|
|
* blank but not at the end of the line
|
|
* move forward one char so the blank
|
|
* is on the line boundary.
|
|
*/
|
|
if ((isblank((unsigned char)row->string[pos])) &&
|
|
(pos != row->length - 1))
|
|
pos++;
|
|
|
|
if (split_line(field, FALSE, pos, &row) != E_OK) {
|
|
wrap_err = E_REQUEST_DENIED;
|
|
goto restore_and_exit;
|
|
}
|
|
} else
|
|
/* line is exactly the right length, do next one */
|
|
row = row->next;
|
|
}
|
|
|
|
/* Check if we have not run out of room */
|
|
if ((((field->opts & O_STATIC) == O_STATIC) &&
|
|
field->row_count > (field->rows + field->nrows)) ||
|
|
((field->max != 0) && (field->row_count > field->max))) {
|
|
|
|
wrap_err = E_REQUEST_DENIED;
|
|
|
|
restore_and_exit:
|
|
if (saved_row->prev == NULL) {
|
|
field->alines = row_backup;
|
|
} else {
|
|
saved_row->prev->next = row_backup;
|
|
row_backup->prev = saved_row->prev;
|
|
}
|
|
|
|
field->row_xpos = saved_xpos;
|
|
field->cursor_xpos = saved_cur_xpos;
|
|
field->cursor_ypos = saved_ypos;
|
|
field->row_count = saved_row_count;
|
|
field->start_line = saved_start_line;
|
|
field->cur_line = saved_cur_line;
|
|
|
|
destroy_row_list(saved_row);
|
|
return wrap_err;
|
|
}
|
|
|
|
destroy_row_list(row_backup);
|
|
return E_OK;
|
|
}
|
|
|
|
/*
|
|
* Join the two lines that surround the location pos, the type
|
|
* variable indicates the direction of the join, JOIN_NEXT will join
|
|
* the next line to the current line, JOIN_PREV will join the current
|
|
* line to the previous line, the new lines will be wrapped unless the
|
|
* _NW versions of the directions are used. Returns E_OK if the join
|
|
* was successful or E_REQUEST_DENIED if the join cannot happen.
|
|
*/
|
|
static int
|
|
_formi_join_line(FIELD *field, _FORMI_FIELD_LINES **rowp, int direction)
|
|
{
|
|
int old_len, count;
|
|
struct _formi_field_lines *saved;
|
|
char *newp;
|
|
_FORMI_FIELD_LINES *row = *rowp;
|
|
#ifdef DEBUG
|
|
int dbg_ok = FALSE;
|
|
|
|
if (_formi_create_dbg_file() == E_OK) {
|
|
dbg_ok = TRUE;
|
|
}
|
|
|
|
if (dbg_ok == TRUE) {
|
|
fprintf(dbg, "join_line: working on row %p, row_count = %d\n",
|
|
row, field->row_count);
|
|
}
|
|
#endif
|
|
|
|
if ((direction == JOIN_NEXT) || (direction == JOIN_NEXT_NW)) {
|
|
/*
|
|
* See if there is another line following, or if the
|
|
* line contains a hard return then we don't join
|
|
* any lines to it.
|
|
*/
|
|
if ((row->next == NULL) || (row->hard_ret == TRUE)) {
|
|
return E_REQUEST_DENIED;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
if (dbg_ok == TRUE) {
|
|
fprintf(dbg,
|
|
"join_line: join_next before length = %d, expanded = %d",
|
|
row->length, row->expanded);
|
|
fprintf(dbg,
|
|
" :: next row length = %d, expanded = %d\n",
|
|
row->length, row->expanded);
|
|
}
|
|
#endif
|
|
|
|
if (row->allocated < (row->length + row->next->length + 1)) {
|
|
if ((newp = realloc(row->string, (size_t)(row->length +
|
|
row->next->length
|
|
+ 1))) == NULL)
|
|
return E_REQUEST_DENIED;
|
|
row->string = newp;
|
|
row->allocated = row->length + row->next->length + 1;
|
|
}
|
|
|
|
strcat(row->string, row->next->string);
|
|
old_len = row->length;
|
|
row->length += row->next->length;
|
|
if (row->length > 0)
|
|
row->expanded =
|
|
_formi_tab_expanded_length(row->string, 0,
|
|
row->length - 1);
|
|
else
|
|
row->expanded = 0;
|
|
|
|
_formi_calculate_tabs(row);
|
|
row->hard_ret = row->next->hard_ret;
|
|
|
|
/* adjust current line if it is on the row being eaten */
|
|
if (field->cur_line == row->next) {
|
|
field->cur_line = row;
|
|
field->row_xpos += old_len;
|
|
field->cursor_xpos =
|
|
_formi_tab_expanded_length(row->string, 0,
|
|
field->row_xpos);
|
|
if (field->cursor_xpos > 0)
|
|
field->cursor_xpos--;
|
|
|
|
if (field->cursor_ypos > 0)
|
|
field->cursor_ypos--;
|
|
else {
|
|
if (field->start_line->prev != NULL)
|
|
field->start_line =
|
|
field->start_line->prev;
|
|
}
|
|
}
|
|
|
|
/* remove joined line record from the row list */
|
|
add_to_free(field, row->next);
|
|
|
|
#ifdef DEBUG
|
|
if (dbg_ok == TRUE) {
|
|
fprintf(dbg,
|
|
"join_line: exit length = %d, expanded = %d\n",
|
|
row->length, row->expanded);
|
|
}
|
|
#endif
|
|
} else {
|
|
if (row->prev == NULL) {
|
|
return E_REQUEST_DENIED;
|
|
}
|
|
|
|
saved = row->prev;
|
|
|
|
/*
|
|
* Don't try to join if the line above has a hard
|
|
* return on it.
|
|
*/
|
|
if (saved->hard_ret == TRUE) {
|
|
return E_REQUEST_DENIED;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
if (dbg_ok == TRUE) {
|
|
fprintf(dbg,
|
|
"join_line: join_prev before length = %d, expanded = %d",
|
|
row->length, row->expanded);
|
|
fprintf(dbg,
|
|
" :: prev row length = %d, expanded = %d\n",
|
|
saved->length, saved->expanded);
|
|
}
|
|
#endif
|
|
|
|
if (saved->allocated < (row->length + saved->length + 1)) {
|
|
if ((newp = realloc(saved->string,
|
|
(size_t) (row->length +
|
|
saved->length
|
|
+ 1))) == NULL)
|
|
return E_REQUEST_DENIED;
|
|
saved->string = newp;
|
|
saved->allocated = row->length + saved->length + 1;
|
|
}
|
|
|
|
strcat(saved->string, row->string);
|
|
old_len = saved->length;
|
|
saved->length += row->length;
|
|
if (saved->length > 0)
|
|
saved->expanded =
|
|
_formi_tab_expanded_length(saved->string, 0,
|
|
saved->length - 1);
|
|
else
|
|
saved->length = 0;
|
|
|
|
saved->hard_ret = row->hard_ret;
|
|
|
|
/* adjust current line if it was on the row being eaten */
|
|
if (field->cur_line == row) {
|
|
field->cur_line = saved;
|
|
field->row_xpos += old_len;
|
|
field->cursor_xpos =
|
|
_formi_tab_expanded_length(saved->string, 0,
|
|
field->row_xpos);
|
|
if (field->cursor_xpos > 0)
|
|
field->cursor_xpos--;
|
|
}
|
|
|
|
add_to_free(field, row);
|
|
|
|
#ifdef DEBUG
|
|
if (dbg_ok == TRUE) {
|
|
fprintf(dbg,
|
|
"join_line: exit length = %d, expanded = %d\n",
|
|
saved->length, saved->expanded);
|
|
}
|
|
#endif
|
|
row = saved;
|
|
}
|
|
|
|
|
|
/*
|
|
* Work out where the line lies in the field in relation to
|
|
* the cursor_ypos. First count the rows from the start of
|
|
* the field until we hit the row we just worked on.
|
|
*/
|
|
saved = field->start_line;
|
|
count = 0;
|
|
while (saved->next != NULL) {
|
|
if (saved == row)
|
|
break;
|
|
count++;
|
|
saved = saved->next;
|
|
}
|
|
|
|
/* now check if we need to adjust cursor_ypos */
|
|
if (field->cursor_ypos > count) {
|
|
field->cursor_ypos--;
|
|
}
|
|
|
|
field->row_count--;
|
|
*rowp = row;
|
|
|
|
/* wrap the field if required, if this fails undo the change */
|
|
if ((direction == JOIN_NEXT) || (direction == JOIN_PREV)) {
|
|
if (_formi_wrap_field(field, row) != E_OK) {
|
|
return E_REQUEST_DENIED;
|
|
}
|
|
}
|
|
|
|
return E_OK;
|
|
}
|
|
|
|
/*
|
|
* Split the line at the given position, if possible. If hard_split is
|
|
* TRUE then split the line regardless of the position, otherwise don't
|
|
* split at the beginning of a line.
|
|
*/
|
|
static int
|
|
split_line(FIELD *field, bool hard_split, unsigned pos,
|
|
_FORMI_FIELD_LINES **rowp)
|
|
{
|
|
struct _formi_field_lines *new_line;
|
|
char *newp;
|
|
_FORMI_FIELD_LINES *row = *rowp;
|
|
#ifdef DEBUG
|
|
short dbg_ok = FALSE;
|
|
#endif
|
|
|
|
/* if asked to split right where the line already starts then
|
|
* just return - nothing to do unless we are appending a line
|
|
* to the buffer.
|
|
*/
|
|
if ((pos == 0) && (hard_split == FALSE))
|
|
return E_OK;
|
|
|
|
#ifdef DEBUG
|
|
if (_formi_create_dbg_file() == E_OK) {
|
|
fprintf(dbg, "split_line: splitting line at %d\n", pos);
|
|
dbg_ok = TRUE;
|
|
}
|
|
#endif
|
|
|
|
/* Need an extra line struct, check free list first */
|
|
if (field->free != NULL) {
|
|
new_line = field->free;
|
|
field->free = new_line->next;
|
|
if (field->free != NULL)
|
|
field->free->prev = NULL;
|
|
} else {
|
|
if ((new_line = (struct _formi_field_lines *)
|
|
malloc(sizeof(struct _formi_field_lines))) == NULL)
|
|
return E_SYSTEM_ERROR;
|
|
new_line->prev = NULL;
|
|
new_line->next = NULL;
|
|
new_line->allocated = 0;
|
|
new_line->length = 0;
|
|
new_line->expanded = 0;
|
|
new_line->string = NULL;
|
|
new_line->hard_ret = FALSE;
|
|
new_line->tabs = NULL;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
if (dbg_ok == TRUE) {
|
|
fprintf(dbg,
|
|
"split_line: enter: length = %d, expanded = %d\n",
|
|
row->length, row->expanded);
|
|
}
|
|
#endif
|
|
|
|
assert((row->length < INT_MAX) && (row->expanded < INT_MAX));
|
|
|
|
|
|
/* add new line to the row list */
|
|
new_line->next = row->next;
|
|
new_line->prev = row;
|
|
row->next = new_line;
|
|
if (new_line->next != NULL)
|
|
new_line->next->prev = new_line;
|
|
|
|
new_line->length = row->length - pos;
|
|
if (new_line->length >= new_line->allocated) {
|
|
if ((newp = realloc(new_line->string,
|
|
(size_t) new_line->length + 1)) == NULL)
|
|
return E_SYSTEM_ERROR;
|
|
new_line->string = newp;
|
|
new_line->allocated = new_line->length + 1;
|
|
}
|
|
|
|
strcpy(new_line->string, &row->string[pos]);
|
|
|
|
row->length = pos;
|
|
row->string[pos] = '\0';
|
|
|
|
if (row->length != 0)
|
|
row->expanded = _formi_tab_expanded_length(row->string, 0,
|
|
row->length - 1);
|
|
else
|
|
row->expanded = 0;
|
|
_formi_calculate_tabs(row);
|
|
|
|
if (new_line->length != 0)
|
|
new_line->expanded =
|
|
_formi_tab_expanded_length(new_line->string, 0,
|
|
new_line->length - 1);
|
|
else
|
|
new_line->expanded = 0;
|
|
|
|
_formi_calculate_tabs(new_line);
|
|
|
|
/*
|
|
* If the given row was the current line then adjust the
|
|
* current line pointer if necessary
|
|
*/
|
|
if ((field->cur_line == row) && (field->row_xpos >= pos)) {
|
|
field->cur_line = new_line;
|
|
field->row_xpos -= pos;
|
|
field->cursor_xpos =
|
|
_formi_tab_expanded_length(new_line->string, 0,
|
|
field->row_xpos);
|
|
if (field->cursor_xpos > 0)
|
|
field->cursor_xpos--;
|
|
|
|
field->cursor_ypos++;
|
|
if (field->cursor_ypos >= field->rows) {
|
|
if (field->start_line->next != NULL) {
|
|
field->start_line = field->start_line->next;
|
|
field->cursor_ypos = field->rows - 1;
|
|
}
|
|
else
|
|
assert(field->start_line->next == NULL);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If the line split had a hard return then replace the
|
|
* current line's hard return with a soft return and carry
|
|
* the hard return onto the line after.
|
|
*/
|
|
if (row->hard_ret == TRUE) {
|
|
new_line->hard_ret = TRUE;
|
|
row->hard_ret = FALSE;
|
|
}
|
|
|
|
/*
|
|
* except where we are doing a hard split then the current
|
|
* row must have a hard return on it too...
|
|
*/
|
|
if (hard_split == TRUE) {
|
|
row->hard_ret = TRUE;
|
|
}
|
|
|
|
assert(((row->expanded < INT_MAX) &&
|
|
(new_line->expanded < INT_MAX) &&
|
|
(row->length < INT_MAX) &&
|
|
(new_line->length < INT_MAX)));
|
|
|
|
#ifdef DEBUG
|
|
if (dbg_ok == TRUE) {
|
|
fprintf(dbg, "split_line: exit: ");
|
|
fprintf(dbg, "row.length = %d, row.expanded = %d, ",
|
|
row->length, row->expanded);
|
|
fprintf(dbg,
|
|
"next_line.length = %d, next_line.expanded = %d, ",
|
|
new_line->length, new_line->expanded);
|
|
fprintf(dbg, "row_count = %d\n", field->row_count + 1);
|
|
}
|
|
#endif
|
|
|
|
field->row_count++;
|
|
*rowp = new_line;
|
|
|
|
return E_OK;
|
|
}
|
|
|
|
/*
|
|
* skip the blanks in the given string, start at the index start and
|
|
* continue forward until either the end of the string or a non-blank
|
|
* character is found. Return the index of either the end of the string or
|
|
* the first non-blank character.
|
|
*/
|
|
unsigned
|
|
_formi_skip_blanks(char *string, unsigned int start)
|
|
{
|
|
unsigned int i;
|
|
|
|
i = start;
|
|
|
|
while ((string[i] != '\0') && isblank((unsigned char)string[i]))
|
|
i++;
|
|
|
|
return i;
|
|
}
|
|
|
|
/*
|
|
* Skip the blanks in the string associated with the given row, pass back
|
|
* the row and the offset at which the first non-blank is found. If no
|
|
* non-blank character is found then return the index to the last
|
|
* character on the last line.
|
|
*/
|
|
|
|
unsigned
|
|
field_skip_blanks(unsigned int start, _FORMI_FIELD_LINES **rowp)
|
|
{
|
|
unsigned int i;
|
|
_FORMI_FIELD_LINES *row, *last = NULL;
|
|
|
|
row = *rowp;
|
|
i = start;
|
|
|
|
do {
|
|
i = _formi_skip_blanks(&row->string[i], i);
|
|
if (!isblank((unsigned char)row->string[i])) {
|
|
last = row;
|
|
row = row->next;
|
|
/*
|
|
* don't reset if last line otherwise we will
|
|
* not be at the end of the string.
|
|
*/
|
|
if (row != NULL)
|
|
i = 0;
|
|
} else
|
|
break;
|
|
}
|
|
while (row != NULL);
|
|
|
|
/*
|
|
* If we hit the end of the row list then point at the last row
|
|
* otherwise we return the row we found the blank on.
|
|
*/
|
|
if (row == NULL)
|
|
*rowp = last;
|
|
else
|
|
*rowp = row;
|
|
|
|
return i;
|
|
}
|
|
|
|
/*
|
|
* Return the index of the top left most field of the two given fields.
|
|
*/
|
|
static int
|
|
_formi_top_left(FORM *form, int a, int b)
|
|
{
|
|
/* lower row numbers always win here.... */
|
|
if (form->fields[a]->form_row < form->fields[b]->form_row)
|
|
return a;
|
|
|
|
if (form->fields[a]->form_row > form->fields[b]->form_row)
|
|
return b;
|
|
|
|
/* rows must be equal, check columns */
|
|
if (form->fields[a]->form_col < form->fields[b]->form_col)
|
|
return a;
|
|
|
|
if (form->fields[a]->form_col > form->fields[b]->form_col)
|
|
return b;
|
|
|
|
/* if we get here fields must be in exactly the same place, punt */
|
|
return a;
|
|
}
|
|
|
|
/*
|
|
* Return the index to the field that is the bottom-right-most of the
|
|
* two given fields.
|
|
*/
|
|
static int
|
|
_formi_bottom_right(FORM *form, int a, int b)
|
|
{
|
|
/* check the rows first, biggest row wins */
|
|
if (form->fields[a]->form_row > form->fields[b]->form_row)
|
|
return a;
|
|
if (form->fields[a]->form_row < form->fields[b]->form_row)
|
|
return b;
|
|
|
|
/* rows must be equal, check cols, biggest wins */
|
|
if (form->fields[a]->form_col > form->fields[b]->form_col)
|
|
return a;
|
|
if (form->fields[a]->form_col < form->fields[b]->form_col)
|
|
return b;
|
|
|
|
/* fields in the same place, punt */
|
|
return a;
|
|
}
|
|
|
|
/*
|
|
* Find the end of the current word in the string str, starting at
|
|
* offset - the end includes any trailing whitespace. If the end of
|
|
* the string is found before a new word then just return the offset
|
|
* to the end of the string. If do_join is TRUE then lines will be
|
|
* joined (without wrapping) until either the end of the field or the
|
|
* end of a word is found (whichever comes first).
|
|
*/
|
|
static int
|
|
find_eow(FIELD *cur, unsigned int offset, bool do_join,
|
|
_FORMI_FIELD_LINES **rowp)
|
|
{
|
|
int start;
|
|
_FORMI_FIELD_LINES *row;
|
|
|
|
row = *rowp;
|
|
start = offset;
|
|
|
|
do {
|
|
/* first skip any non-whitespace */
|
|
while ((row->string[start] != '\0')
|
|
&& !isblank((unsigned char)row->string[start]))
|
|
start++;
|
|
|
|
/* see if we hit the end of the string */
|
|
if (row->string[start] == '\0') {
|
|
if (do_join == TRUE) {
|
|
if (row->next == NULL)
|
|
return start;
|
|
|
|
if (_formi_join_line(cur, &row, JOIN_NEXT_NW)
|
|
!= E_OK)
|
|
return E_REQUEST_DENIED;
|
|
} else {
|
|
do {
|
|
if (row->next == NULL) {
|
|
*rowp = row;
|
|
return start;
|
|
} else {
|
|
row = row->next;
|
|
start = 0;
|
|
}
|
|
} while (row->length == 0);
|
|
}
|
|
}
|
|
} while (!isblank((unsigned char)row->string[start]));
|
|
|
|
do {
|
|
/* otherwise skip the whitespace.... */
|
|
while ((row->string[start] != '\0')
|
|
&& isblank((unsigned char)row->string[start]))
|
|
start++;
|
|
|
|
if (row->string[start] == '\0') {
|
|
if (do_join == TRUE) {
|
|
if (row->next == NULL)
|
|
return start;
|
|
|
|
if (_formi_join_line(cur, &row, JOIN_NEXT_NW)
|
|
!= E_OK)
|
|
return E_REQUEST_DENIED;
|
|
} else {
|
|
do {
|
|
if (row->next == NULL) {
|
|
*rowp = row;
|
|
return start;
|
|
} else {
|
|
row = row->next;
|
|
start = 0;
|
|
}
|
|
} while (row->length == 0);
|
|
}
|
|
}
|
|
} while (isblank((unsigned char)row->string[start]));
|
|
|
|
*rowp = row;
|
|
return start;
|
|
}
|
|
|
|
/*
|
|
* Find the beginning of the current word in the string str, starting
|
|
* at offset.
|
|
*/
|
|
static int
|
|
find_sow(unsigned int offset, _FORMI_FIELD_LINES **rowp)
|
|
{
|
|
int start;
|
|
char *str;
|
|
_FORMI_FIELD_LINES *row;
|
|
|
|
row = *rowp;
|
|
str = row->string;
|
|
start = offset;
|
|
|
|
do {
|
|
if (start > 0) {
|
|
if (isblank((unsigned char)str[start]) ||
|
|
isblank((unsigned char)str[start - 1])) {
|
|
if (isblank((unsigned char)str[start - 1]))
|
|
start--;
|
|
/* skip the whitespace.... */
|
|
while ((start >= 0) &&
|
|
isblank((unsigned char)str[start]))
|
|
start--;
|
|
}
|
|
}
|
|
|
|
/* see if we hit the start of the string */
|
|
if (start < 0) {
|
|
do {
|
|
if (row->prev == NULL) {
|
|
*rowp = row;
|
|
start = 0;
|
|
return start;
|
|
} else {
|
|
row = row->prev;
|
|
str = row->string;
|
|
if (row->length > 0)
|
|
start = row->length - 1;
|
|
else
|
|
start = 0;
|
|
}
|
|
} while (row->length == 0);
|
|
}
|
|
} while (isblank((unsigned char)row->string[start]));
|
|
|
|
/* see if we hit the start of the string */
|
|
if (start < 0) {
|
|
*rowp = row;
|
|
return 0;
|
|
}
|
|
|
|
/* now skip any non-whitespace */
|
|
do {
|
|
while ((start >= 0) && !isblank((unsigned char)str[start]))
|
|
start--;
|
|
|
|
|
|
if (start < 0) {
|
|
do {
|
|
if (row->prev == NULL) {
|
|
*rowp = row;
|
|
start = 0;
|
|
return start;
|
|
} else {
|
|
row = row->prev;
|
|
str = row->string;
|
|
if (row->length > 0)
|
|
start = row->length - 1;
|
|
else
|
|
start = 0;
|
|
}
|
|
} while (row->length == 0);
|
|
}
|
|
} while (!isblank((unsigned char)str[start]));
|
|
|
|
if (start > 0) {
|
|
start++; /* last loop has us pointing at a space, adjust */
|
|
if (start >= row->length) {
|
|
if (row->next != NULL) {
|
|
start = 0;
|
|
row = row->next;
|
|
} else {
|
|
start = row->length - 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (start < 0)
|
|
start = 0;
|
|
|
|
*rowp = row;
|
|
return start;
|
|
}
|
|
|
|
/*
|
|
* Scroll the field forward the given number of lines.
|
|
*/
|
|
static void
|
|
_formi_scroll_fwd(FIELD *field, unsigned int amt)
|
|
{
|
|
unsigned int count;
|
|
_FORMI_FIELD_LINES *end_row;
|
|
|
|
end_row = field->start_line;
|
|
/* walk the line structs forward to find the bottom of the field */
|
|
count = field->rows - 1;
|
|
while ((count > 0) && (end_row->next != NULL))
|
|
{
|
|
count--;
|
|
end_row = end_row->next;
|
|
}
|
|
|
|
/* check if there are lines to scroll */
|
|
if ((count > 0) && (end_row->next == NULL))
|
|
return;
|
|
|
|
/*
|
|
* ok, lines to scroll - do this by walking both the start_line
|
|
* and the end_row at the same time for amt lines, we stop when
|
|
* either we have done the number of lines or end_row hits the
|
|
* last line in the field.
|
|
*/
|
|
count = amt;
|
|
while ((count > 0) && (end_row->next != NULL)) {
|
|
count--;
|
|
field->start_line = field->start_line->next;
|
|
end_row = end_row->next;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Scroll the field backward the given number of lines.
|
|
*/
|
|
static void
|
|
_formi_scroll_back(FIELD *field, unsigned int amt)
|
|
{
|
|
unsigned int count;
|
|
|
|
/* check for lines above */
|
|
if (field->start_line->prev == NULL)
|
|
return;
|
|
|
|
/*
|
|
* Backward scroll is easy, follow row struct chain backward until
|
|
* the number of lines done or we reach the top of the field.
|
|
*/
|
|
count = amt;
|
|
while ((count > 0) && (field->start_line->prev != NULL)) {
|
|
count--;
|
|
field->start_line = field->start_line->prev;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Scroll the field forward the given number of characters.
|
|
*/
|
|
void
|
|
_formi_hscroll_fwd(FIELD *field, _FORMI_FIELD_LINES *row, int unsigned amt)
|
|
{
|
|
unsigned int end, scroll_amt, expanded;
|
|
_formi_tab_t *ts;
|
|
|
|
|
|
if ((row->tabs == NULL) || (row->tabs->in_use == FALSE)) {
|
|
/* if the line has no tabs things are easy... */
|
|
end = field->start_char + field->cols + amt - 1;
|
|
scroll_amt = amt;
|
|
if (end > row->length) {
|
|
end = row->length;
|
|
scroll_amt = end - field->start_char - field->cols + 1;
|
|
}
|
|
} else {
|
|
/*
|
|
* If there are tabs we need to add on the scroll amount,
|
|
* find the last char position that will fit into
|
|
* the field and finally fix up the start_char. This
|
|
* is a lot of work but handling the case where there
|
|
* are not enough chars to scroll by amt is difficult.
|
|
*/
|
|
end = field->start_char + field->row_xpos + amt;
|
|
if (end >= row->length)
|
|
end = row->length - 1;
|
|
else {
|
|
expanded = _formi_tab_expanded_length(
|
|
row->string,
|
|
field->start_char + amt,
|
|
field->start_char + field->row_xpos + amt);
|
|
ts = row->tabs;
|
|
/* skip tabs to the lhs of our starting point */
|
|
while ((ts != NULL) && (ts->in_use == TRUE)
|
|
&& (ts->pos < end))
|
|
ts = ts->fwd;
|
|
|
|
while ((expanded <= field->cols)
|
|
&& (end < row->length)) {
|
|
if (row->string[end] == '\t') {
|
|
assert((ts != NULL)
|
|
&& (ts->in_use == TRUE));
|
|
if (ts->pos == end) {
|
|
if ((expanded + ts->size)
|
|
> field->cols)
|
|
break;
|
|
expanded += ts->size;
|
|
ts = ts->fwd;
|
|
}
|
|
else
|
|
assert(ts->pos == end);
|
|
} else
|
|
expanded++;
|
|
end++;
|
|
}
|
|
}
|
|
|
|
scroll_amt = tab_fit_window(field, end, field->cols);
|
|
if (scroll_amt < field->start_char)
|
|
scroll_amt = 1;
|
|
else
|
|
scroll_amt -= field->start_char;
|
|
|
|
scroll_amt = min(scroll_amt, amt);
|
|
}
|
|
|
|
field->start_char += scroll_amt;
|
|
field->cursor_xpos =
|
|
_formi_tab_expanded_length(row->string,
|
|
field->start_char,
|
|
field->row_xpos
|
|
+ field->start_char) - 1;
|
|
|
|
}
|
|
|
|
/*
|
|
* Scroll the field backward the given number of characters.
|
|
*/
|
|
void
|
|
_formi_hscroll_back(FIELD *field, _FORMI_FIELD_LINES *row, unsigned int amt)
|
|
{
|
|
field->start_char -= min(field->start_char, amt);
|
|
field->cursor_xpos =
|
|
_formi_tab_expanded_length(row->string, field->start_char,
|
|
field->row_xpos
|
|
+ field->start_char) - 1;
|
|
if (field->cursor_xpos >= field->cols) {
|
|
field->row_xpos = 0;
|
|
field->cursor_xpos = 0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Find the different pages in the form fields and assign the form
|
|
* page_starts array with the information to find them.
|
|
*/
|
|
int
|
|
_formi_find_pages(FORM *form)
|
|
{
|
|
int i, cur_page = 0;
|
|
|
|
if ((form->page_starts = (_FORMI_PAGE_START *)
|
|
malloc((form->max_page + 1) * sizeof(_FORMI_PAGE_START))) == NULL)
|
|
return E_SYSTEM_ERROR;
|
|
|
|
/* initialise the page starts array */
|
|
memset(form->page_starts, 0,
|
|
(form->max_page + 1) * sizeof(_FORMI_PAGE_START));
|
|
|
|
for (i =0; i < form->field_count; i++) {
|
|
if (form->fields[i]->page_break == 1)
|
|
cur_page++;
|
|
if (form->page_starts[cur_page].in_use == 0) {
|
|
form->page_starts[cur_page].in_use = 1;
|
|
form->page_starts[cur_page].first = i;
|
|
form->page_starts[cur_page].last = i;
|
|
form->page_starts[cur_page].top_left = i;
|
|
form->page_starts[cur_page].bottom_right = i;
|
|
} else {
|
|
form->page_starts[cur_page].last = i;
|
|
form->page_starts[cur_page].top_left =
|
|
_formi_top_left(form,
|
|
form->page_starts[cur_page].top_left,
|
|
i);
|
|
form->page_starts[cur_page].bottom_right =
|
|
_formi_bottom_right(form,
|
|
form->page_starts[cur_page].bottom_right,
|
|
i);
|
|
}
|
|
}
|
|
|
|
return E_OK;
|
|
}
|
|
|
|
/*
|
|
* Completely redraw the field of the given form.
|
|
*/
|
|
void
|
|
_formi_redraw_field(FORM *form, int field)
|
|
{
|
|
unsigned int pre, post, flen, slen, i, j, start, line;
|
|
unsigned int tab, cpos, len;
|
|
char *str, c;
|
|
FIELD *cur;
|
|
_FORMI_FIELD_LINES *row;
|
|
#ifdef DEBUG
|
|
char buffer[100];
|
|
#endif
|
|
|
|
cur = form->fields[field];
|
|
flen = cur->cols;
|
|
slen = 0;
|
|
start = 0;
|
|
line = 0;
|
|
|
|
for (row = cur->start_line; ((row != NULL) && (line < cur->rows));
|
|
row = row->next, line++) {
|
|
wmove(form->scrwin, (int) (cur->form_row + line),
|
|
(int) cur->form_col);
|
|
if ((cur->rows + cur->nrows) == 1) {
|
|
if ((cur->cols + cur->start_char) >= row->length)
|
|
len = row->length;
|
|
else
|
|
len = cur->cols + cur->start_char;
|
|
if (row->string != NULL)
|
|
slen = _formi_tab_expanded_length(
|
|
row->string, cur->start_char, len);
|
|
else
|
|
slen = 0;
|
|
|
|
if (slen > cur->cols)
|
|
slen = cur->cols;
|
|
slen += cur->start_char;
|
|
} else
|
|
slen = row->expanded;
|
|
|
|
if ((cur->opts & O_STATIC) == O_STATIC) {
|
|
switch (cur->justification) {
|
|
case JUSTIFY_RIGHT:
|
|
post = 0;
|
|
if (flen < slen)
|
|
pre = 0;
|
|
else
|
|
pre = flen - slen;
|
|
break;
|
|
|
|
case JUSTIFY_CENTER:
|
|
if (flen < slen) {
|
|
pre = 0;
|
|
post = 0;
|
|
} else {
|
|
pre = flen - slen;
|
|
post = pre = pre / 2;
|
|
/* get padding right if
|
|
centring is not even */
|
|
if ((post + pre + slen) < flen)
|
|
post++;
|
|
}
|
|
break;
|
|
|
|
case NO_JUSTIFICATION:
|
|
case JUSTIFY_LEFT:
|
|
default:
|
|
pre = 0;
|
|
if (flen <= slen)
|
|
post = 0;
|
|
else {
|
|
post = flen - slen;
|
|
if (post > flen)
|
|
post = flen;
|
|
}
|
|
break;
|
|
}
|
|
} else {
|
|
/* dynamic fields are not justified */
|
|
pre = 0;
|
|
if (flen <= slen)
|
|
post = 0;
|
|
else {
|
|
post = flen - slen;
|
|
if (post > flen)
|
|
post = flen;
|
|
}
|
|
|
|
/* but they do scroll.... */
|
|
|
|
if (pre > cur->start_char - start)
|
|
pre = pre - cur->start_char + start;
|
|
else
|
|
pre = 0;
|
|
|
|
if (slen > cur->start_char) {
|
|
slen -= cur->start_char;
|
|
if (slen > flen)
|
|
post = 0;
|
|
else
|
|
post = flen - slen;
|
|
|
|
if (post > flen)
|
|
post = flen;
|
|
} else {
|
|
slen = 0;
|
|
post = flen - pre;
|
|
}
|
|
}
|
|
|
|
if (form->cur_field == field)
|
|
wattrset(form->scrwin, cur->fore);
|
|
else
|
|
wattrset(form->scrwin, cur->back);
|
|
|
|
str = &row->string[cur->start_char];
|
|
|
|
#ifdef DEBUG
|
|
if (_formi_create_dbg_file() == E_OK) {
|
|
fprintf(dbg,
|
|
"redraw_field: start=%d, pre=%d, slen=%d, flen=%d, post=%d, start_char=%d\n",
|
|
start, pre, slen, flen, post, cur->start_char);
|
|
if (str != NULL) {
|
|
if (row->expanded != 0) {
|
|
strncpy(buffer, str, flen);
|
|
} else {
|
|
strcpy(buffer, "(empty)");
|
|
}
|
|
} else {
|
|
strcpy(buffer, "(null)");
|
|
}
|
|
buffer[flen] = '\0';
|
|
fprintf(dbg, "redraw_field: %s\n", buffer);
|
|
}
|
|
#endif
|
|
|
|
for (i = start + cur->start_char; i < pre; i++)
|
|
waddch(form->scrwin, cur->pad);
|
|
|
|
#ifdef DEBUG
|
|
fprintf(dbg, "redraw_field: will add %d chars\n",
|
|
min(slen, flen));
|
|
#endif
|
|
for (i = 0, cpos = cur->start_char; i < min(slen, flen);
|
|
i++, str++, cpos++)
|
|
{
|
|
c = *str;
|
|
tab = 0; /* just to shut gcc up */
|
|
#ifdef DEBUG
|
|
fprintf(dbg, "adding char str[%d]=%c\n",
|
|
cpos + cur->start_char, c);
|
|
#endif
|
|
if (((cur->opts & O_PUBLIC) != O_PUBLIC)) {
|
|
if (c == '\t')
|
|
tab = add_tab(form, row, cpos,
|
|
cur->pad);
|
|
else
|
|
waddch(form->scrwin, cur->pad);
|
|
} else if ((cur->opts & O_VISIBLE) == O_VISIBLE) {
|
|
if (c == '\t')
|
|
tab = add_tab(form, row, cpos, ' ');
|
|
else
|
|
waddch(form->scrwin, c);
|
|
} else {
|
|
if (c == '\t')
|
|
tab = add_tab(form, row, cpos, ' ');
|
|
else
|
|
waddch(form->scrwin, ' ');
|
|
}
|
|
|
|
/*
|
|
* If we have had a tab then skip forward
|
|
* the requisite number of chars to keep
|
|
* things in sync.
|
|
*/
|
|
if (c == '\t')
|
|
i += tab - 1;
|
|
}
|
|
|
|
for (i = 0; i < post; i++)
|
|
waddch(form->scrwin, cur->pad);
|
|
}
|
|
|
|
for (i = line; i < cur->rows; i++) {
|
|
wmove(form->scrwin, (int) (cur->form_row + i),
|
|
(int) cur->form_col);
|
|
|
|
if (form->cur_field == field)
|
|
wattrset(form->scrwin, cur->fore);
|
|
else
|
|
wattrset(form->scrwin, cur->back);
|
|
|
|
for (j = 0; j < cur->cols; j++) {
|
|
waddch(form->scrwin, cur->pad);
|
|
}
|
|
}
|
|
|
|
wattrset(form->scrwin, cur->back);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Add the correct number of the given character to simulate a tab
|
|
* in the field.
|
|
*/
|
|
static int
|
|
add_tab(FORM *form, _FORMI_FIELD_LINES *row, unsigned int i, char c)
|
|
{
|
|
int j;
|
|
_formi_tab_t *ts = row->tabs;
|
|
|
|
while ((ts != NULL) && (ts->pos != i))
|
|
ts = ts->fwd;
|
|
|
|
assert(ts != NULL);
|
|
|
|
for (j = 0; j < ts->size; j++)
|
|
waddch(form->scrwin, c);
|
|
|
|
return ts->size;
|
|
}
|
|
|
|
|
|
/*
|
|
* Display the fields attached to the form that are on the current page
|
|
* on the screen.
|
|
*
|
|
*/
|
|
int
|
|
_formi_draw_page(FORM *form)
|
|
{
|
|
int i;
|
|
|
|
if (form->page_starts[form->page].in_use == 0)
|
|
return E_BAD_ARGUMENT;
|
|
|
|
wclear(form->scrwin);
|
|
|
|
for (i = form->page_starts[form->page].first;
|
|
i <= form->page_starts[form->page].last; i++)
|
|
_formi_redraw_field(form, i);
|
|
|
|
return E_OK;
|
|
}
|
|
|
|
/*
|
|
* Add the character c at the position pos in buffer 0 of the given field
|
|
*/
|
|
int
|
|
_formi_add_char(FIELD *field, unsigned int pos, char c)
|
|
{
|
|
char *new, old_c;
|
|
unsigned int new_size;
|
|
int status;
|
|
_FORMI_FIELD_LINES *row, *temp, *next_temp;
|
|
|
|
row = field->cur_line;
|
|
|
|
/*
|
|
* If buffer has not had a string before, set it to a blank
|
|
* string. Everything should flow from there....
|
|
*/
|
|
if (row->string == NULL) {
|
|
if ((row->string = (char *) malloc((size_t)INITIAL_LINE_ALLOC))
|
|
== NULL)
|
|
return E_SYSTEM_ERROR;
|
|
row->string[0] = '\0';
|
|
row->allocated = INITIAL_LINE_ALLOC;
|
|
row->length = 0;
|
|
row->expanded = 0;
|
|
}
|
|
|
|
if (_formi_validate_char(field, c) != E_OK) {
|
|
#ifdef DEBUG
|
|
fprintf(dbg, "add_char: char %c failed char validation\n", c);
|
|
#endif
|
|
return E_INVALID_FIELD;
|
|
}
|
|
|
|
if ((c == '\t') && (field->cols <= 8)) {
|
|
#ifdef DEBUG
|
|
fprintf(dbg, "add_char: field too small for a tab\n");
|
|
#endif
|
|
return E_NO_ROOM;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
fprintf(dbg, "add_char: pos=%d, char=%c\n", pos, c);
|
|
fprintf(dbg, "add_char enter: xpos=%d, row_pos=%d, start=%d\n",
|
|
field->cursor_xpos, field->row_xpos, field->start_char);
|
|
fprintf(dbg, "add_char enter: length=%d(%d), allocated=%d\n",
|
|
row->expanded, row->length, row->allocated);
|
|
fprintf(dbg, "add_char enter: %s\n", row->string);
|
|
fprintf(dbg, "add_char enter: buf0_status=%d\n", field->buf0_status);
|
|
#endif
|
|
if (((field->opts & O_BLANK) == O_BLANK) &&
|
|
(field->buf0_status == FALSE) &&
|
|
((field->row_xpos + field->start_char) == 0)) {
|
|
row = field->alines;
|
|
if (row->next != NULL) {
|
|
/* shift all but one line structs to free list */
|
|
temp = row->next;
|
|
do {
|
|
next_temp = temp->next;
|
|
add_to_free(field, temp);
|
|
temp = next_temp;
|
|
} while (temp != NULL);
|
|
}
|
|
|
|
row->length = 0;
|
|
row->string[0] = '\0';
|
|
pos = 0;
|
|
field->start_char = 0;
|
|
field->start_line = row;
|
|
field->cur_line = row;
|
|
field->row_count = 1;
|
|
field->row_xpos = 0;
|
|
field->cursor_ypos = 0;
|
|
row->expanded = 0;
|
|
row->length = 0;
|
|
_formi_init_field_xpos(field);
|
|
}
|
|
|
|
|
|
if ((field->overlay == 0)
|
|
|| ((field->overlay == 1) && (pos >= row->length))) {
|
|
/* first check if the field can have more chars...*/
|
|
if (check_field_size(field) == FALSE)
|
|
return E_REQUEST_DENIED;
|
|
|
|
if (row->length + 2
|
|
>= row->allocated) {
|
|
new_size = row->allocated + 16 - (row->allocated % 16);
|
|
if ((new = (char *) realloc(row->string,
|
|
(size_t) new_size )) == NULL)
|
|
return E_SYSTEM_ERROR;
|
|
row->allocated = new_size;
|
|
row->string = new;
|
|
}
|
|
}
|
|
|
|
if ((field->overlay == 0) && (row->length > pos)) {
|
|
bcopy(&row->string[pos], &row->string[pos + 1],
|
|
(size_t) (row->length - pos + 1));
|
|
}
|
|
|
|
old_c = row->string[pos];
|
|
row->string[pos] = c;
|
|
if (pos >= row->length) {
|
|
/* make sure the string is terminated if we are at the
|
|
* end of the string, the terminator would be missing
|
|
* if we are are at the end of the field.
|
|
*/
|
|
row->string[pos + 1] = '\0';
|
|
}
|
|
|
|
/* only increment the length if we are inserting characters
|
|
* OR if we are at the end of the field in overlay mode.
|
|
*/
|
|
if ((field->overlay == 0)
|
|
|| ((field->overlay == 1) && (pos >= row->length))) {
|
|
row->length++;
|
|
}
|
|
|
|
_formi_calculate_tabs(row);
|
|
row->expanded = _formi_tab_expanded_length(row->string, 0,
|
|
row->length - 1);
|
|
|
|
/* wrap the field, if needed */
|
|
status = _formi_wrap_field(field, row);
|
|
|
|
row = field->cur_line;
|
|
pos = field->row_xpos;
|
|
|
|
/*
|
|
* check the wrap worked or that we have not exceeded the
|
|
* max field size - this can happen if the field is re-wrapped
|
|
* and the row count is increased past the set limit.
|
|
*/
|
|
if ((status != E_OK) || (check_field_size(field) == FALSE)) {
|
|
if ((field->overlay == 0)
|
|
|| ((field->overlay == 1)
|
|
&& (pos >= (row->length - 1) /*XXXX- append check???*/))) {
|
|
/*
|
|
* wrap failed for some reason, back out the
|
|
* char insert
|
|
*/
|
|
bcopy(&row->string[pos + 1], &row->string[pos],
|
|
(size_t) (row->length - pos));
|
|
row->length--;
|
|
if (pos > 0)
|
|
pos--;
|
|
} else if (field->overlay == 1) {
|
|
/* back out character overlay */
|
|
row->string[pos] = old_c;
|
|
}
|
|
|
|
_formi_calculate_tabs(row);
|
|
|
|
_formi_wrap_field(field, row);
|
|
/*
|
|
* If we are here then either the status is bad or we
|
|
* simply ran out of room. If the status is E_OK then
|
|
* we ran out of room, let the form driver know this.
|
|
*/
|
|
if (status == E_OK)
|
|
status = E_REQUEST_DENIED;
|
|
|
|
} else {
|
|
field->buf0_status = TRUE;
|
|
field->row_xpos++;
|
|
if ((field->rows + field->nrows) == 1) {
|
|
status = _formi_set_cursor_xpos(field, FALSE);
|
|
} else {
|
|
field->cursor_xpos =
|
|
_formi_tab_expanded_length(
|
|
row->string, 0, field->row_xpos - 1);
|
|
|
|
/*
|
|
* Annoying corner case - if we are right in
|
|
* the bottom right corner of the field we
|
|
* need to scroll the field one line so the
|
|
* cursor is positioned correctly in the
|
|
* field.
|
|
*/
|
|
if ((field->cursor_xpos >= field->cols) &&
|
|
(field->cursor_ypos == (field->rows - 1))) {
|
|
field->cursor_ypos--;
|
|
field->start_line = field->start_line->next;
|
|
}
|
|
}
|
|
}
|
|
|
|
assert((field->cursor_xpos <= field->cols)
|
|
&& (field->cursor_ypos < 400000));
|
|
|
|
#ifdef DEBUG
|
|
fprintf(dbg, "add_char exit: xpos=%d, row_pos=%d, start=%d\n",
|
|
field->cursor_xpos, field->row_xpos, field->start_char);
|
|
fprintf(dbg, "add_char_exit: length=%d(%d), allocated=%d\n",
|
|
row->expanded, row->length, row->allocated);
|
|
fprintf(dbg, "add_char exit: ypos=%d, start_line=%p\n",
|
|
field->cursor_ypos, field->start_line);
|
|
fprintf(dbg,"add_char exit: %s\n", row->string);
|
|
fprintf(dbg, "add_char exit: buf0_status=%d\n", field->buf0_status);
|
|
fprintf(dbg, "add_char exit: status = %s\n",
|
|
(status == E_OK)? "OK" : "FAILED");
|
|
#endif
|
|
return status;
|
|
}
|
|
|
|
/*
|
|
* Set the position of the cursor on the screen in the row depending on
|
|
* where the current position in the string is and the justification
|
|
* that is to be applied to the field. Justification is only applied
|
|
* to single row, static fields.
|
|
*/
|
|
static int
|
|
_formi_set_cursor_xpos(FIELD *field, int noscroll)
|
|
{
|
|
int just, pos;
|
|
|
|
just = field->justification;
|
|
pos = field->start_char + field->row_xpos;
|
|
|
|
#ifdef DEBUG
|
|
fprintf(dbg,
|
|
"cursor_xpos enter: pos %d, start_char %d, row_xpos %d, xpos %d\n",
|
|
pos, field->start_char, field->row_xpos, field->cursor_xpos);
|
|
#endif
|
|
|
|
/*
|
|
* make sure we apply the correct justification to non-static
|
|
* fields.
|
|
*/
|
|
if (((field->rows + field->nrows) != 1) ||
|
|
((field->opts & O_STATIC) != O_STATIC))
|
|
just = JUSTIFY_LEFT;
|
|
|
|
switch (just) {
|
|
case JUSTIFY_RIGHT:
|
|
field->cursor_xpos = field->cols - 1
|
|
- _formi_tab_expanded_length(
|
|
field->cur_line->string, 0,
|
|
field->cur_line->length - 1)
|
|
+ _formi_tab_expanded_length(
|
|
field->cur_line->string, 0,
|
|
field->row_xpos);
|
|
break;
|
|
|
|
case JUSTIFY_CENTER:
|
|
field->cursor_xpos = ((field->cols - 1)
|
|
- _formi_tab_expanded_length(
|
|
field->cur_line->string, 0,
|
|
field->cur_line->length - 1) + 1) / 2
|
|
+ _formi_tab_expanded_length(field->cur_line->string,
|
|
0, field->row_xpos);
|
|
|
|
if (field->cursor_xpos > (field->cols - 1))
|
|
field->cursor_xpos = (field->cols - 1);
|
|
break;
|
|
|
|
default:
|
|
field->cursor_xpos = _formi_tab_expanded_length(
|
|
field->cur_line->string,
|
|
field->start_char,
|
|
field->row_xpos + field->start_char);
|
|
if ((field->cursor_xpos <= (field->cols - 1)) &&
|
|
((field->start_char + field->row_xpos)
|
|
< field->cur_line->length))
|
|
field->cursor_xpos--;
|
|
|
|
if (field->cursor_xpos > (field->cols - 1)) {
|
|
if ((field->opts & O_STATIC) == O_STATIC) {
|
|
field->start_char = 0;
|
|
|
|
if (field->row_xpos
|
|
== (field->cur_line->length - 1)) {
|
|
field->cursor_xpos = field->cols - 1;
|
|
} else {
|
|
field->cursor_xpos =
|
|
_formi_tab_expanded_length(
|
|
field->cur_line->string,
|
|
field->start_char,
|
|
field->row_xpos
|
|
+ field->start_char
|
|
- 1) - 1;
|
|
}
|
|
} else {
|
|
if (noscroll == FALSE) {
|
|
field->start_char =
|
|
tab_fit_window(
|
|
field,
|
|
field->start_char
|
|
+ field->row_xpos,
|
|
field->cols);
|
|
field->row_xpos = pos
|
|
- field->start_char;
|
|
field->cursor_xpos =
|
|
_formi_tab_expanded_length(
|
|
field->cur_line->string,
|
|
field->start_char,
|
|
field->row_xpos
|
|
+ field->start_char - 1);
|
|
} else {
|
|
field->cursor_xpos = (field->cols - 1);
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
fprintf(dbg,
|
|
"cursor_xpos exit: pos %d, start_char %d, row_xpos %d, xpos %d\n",
|
|
pos, field->start_char, field->row_xpos, field->cursor_xpos);
|
|
#endif
|
|
return E_OK;
|
|
}
|
|
|
|
/*
|
|
* Manipulate the text in a field, this takes the given form and performs
|
|
* the passed driver command on the current text field. Returns 1 if the
|
|
* text field was modified.
|
|
*/
|
|
int
|
|
_formi_manipulate_field(FORM *form, int c)
|
|
{
|
|
FIELD *cur;
|
|
char *str, saved;
|
|
unsigned int start, end, pos, status, old_count, size;
|
|
unsigned int old_xpos, old_row_pos;
|
|
int len, wb;
|
|
bool eat_char;
|
|
_FORMI_FIELD_LINES *row, *rs;
|
|
|
|
cur = form->fields[form->cur_field];
|
|
if (cur->cur_line->string == NULL)
|
|
return E_REQUEST_DENIED;
|
|
|
|
#ifdef DEBUG
|
|
fprintf(dbg, "entry: request is REQ_%s\n", reqs[c - REQ_MIN_REQUEST]);
|
|
fprintf(dbg,
|
|
"entry: xpos=%d, row_pos=%d, start_char=%d, length=%d, allocated=%d\n",
|
|
cur->cursor_xpos, cur->row_xpos, cur->start_char,
|
|
cur->cur_line->length, cur->cur_line->allocated);
|
|
fprintf(dbg, "entry: start_line=%p, ypos=%d\n", cur->start_line,
|
|
cur->cursor_ypos);
|
|
fprintf(dbg, "entry: string=");
|
|
if (cur->cur_line->string == NULL)
|
|
fprintf(dbg, "(null)\n");
|
|
else
|
|
fprintf(dbg, "\"%s\"\n", cur->cur_line->string);
|
|
#endif
|
|
|
|
/* Cannot manipulate a null string! */
|
|
if (cur->cur_line->string == NULL)
|
|
return E_REQUEST_DENIED;
|
|
|
|
saved = '\0';
|
|
row = cur->cur_line;
|
|
|
|
switch (c) {
|
|
case REQ_RIGHT_CHAR:
|
|
/*
|
|
* The right_char request performs the same function
|
|
* as the next_char request except that the cursor is
|
|
* not wrapped if it is at the end of the line, so
|
|
* check if the cursor is at the end of the line and
|
|
* deny the request otherwise just fall through to
|
|
* the next_char request handler.
|
|
*/
|
|
if (cur->cursor_xpos >= cur->cols - 1)
|
|
return E_REQUEST_DENIED;
|
|
|
|
/* FALLTHRU */
|
|
|
|
case REQ_NEXT_CHAR:
|
|
/* for a dynamic field allow an offset of one more
|
|
* char so we can insert chars after end of string.
|
|
* Static fields cannot do this so deny request if
|
|
* cursor is at the end of the field.
|
|
*/
|
|
if (((cur->opts & O_STATIC) == O_STATIC) &&
|
|
(cur->row_xpos == cur->cols - 1) &&
|
|
((cur->rows + cur->nrows) == 1))
|
|
return E_REQUEST_DENIED;
|
|
|
|
if (((cur->rows + cur->nrows) == 1) &&
|
|
(cur->row_xpos + cur->start_char + 1) > row->length)
|
|
return E_REQUEST_DENIED;
|
|
|
|
if ((cur->rows + cur->nrows) == 1) {
|
|
cur->row_xpos++;
|
|
_formi_set_cursor_xpos(cur, (c == REQ_RIGHT_CHAR));
|
|
} else {
|
|
if (cur->cursor_xpos >= (row->expanded - 1)) {
|
|
if ((row->next == NULL) ||
|
|
(c == REQ_RIGHT_CHAR))
|
|
return E_REQUEST_DENIED;
|
|
|
|
cur->cursor_xpos = 0;
|
|
cur->row_xpos = 0;
|
|
cur->cur_line = cur->cur_line->next;
|
|
if (cur->cursor_ypos == (cur->rows - 1))
|
|
cur->start_line =
|
|
cur->start_line->next;
|
|
else
|
|
cur->cursor_ypos++;
|
|
} else {
|
|
old_xpos = cur->cursor_xpos;
|
|
old_row_pos = cur->row_xpos;
|
|
if (row->string[cur->row_xpos] == '\t')
|
|
cur->cursor_xpos += tab_size(row,
|
|
cur->row_xpos);
|
|
else
|
|
cur->cursor_xpos++;
|
|
cur->row_xpos++;
|
|
if (cur->cursor_xpos
|
|
>= row->expanded) {
|
|
if ((row->next == NULL) ||
|
|
(c == REQ_RIGHT_CHAR)) {
|
|
cur->cursor_xpos = old_xpos;
|
|
cur->row_xpos = old_row_pos;
|
|
return E_REQUEST_DENIED;
|
|
}
|
|
|
|
cur->cursor_xpos = 0;
|
|
cur->row_xpos = 0;
|
|
cur->cur_line = cur->cur_line->next;
|
|
if (cur->cursor_ypos
|
|
== (cur->rows - 1))
|
|
cur->start_line =
|
|
cur->start_line->next;
|
|
else
|
|
cur->cursor_ypos++;
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case REQ_LEFT_CHAR:
|
|
/*
|
|
* The behaviour of left_char is the same as prev_char
|
|
* except that the cursor will not wrap if it has
|
|
* reached the LHS of the field, so just check this
|
|
* and fall through if we are not at the LHS.
|
|
*/
|
|
if (cur->cursor_xpos == 0)
|
|
return E_REQUEST_DENIED;
|
|
|
|
/* FALLTHRU */
|
|
case REQ_PREV_CHAR:
|
|
if ((cur->rows + cur->nrows) == 1) {
|
|
if (cur->row_xpos == 0) {
|
|
if (cur->start_char > 0)
|
|
cur->start_char--;
|
|
else
|
|
return E_REQUEST_DENIED;
|
|
} else {
|
|
cur->row_xpos--;
|
|
_formi_set_cursor_xpos(cur, FALSE);
|
|
}
|
|
} else {
|
|
if ((cur->cursor_xpos == 0) &&
|
|
(cur->cursor_ypos == 0) &&
|
|
(cur->start_line->prev == NULL))
|
|
return E_REQUEST_DENIED;
|
|
|
|
pos = cur->row_xpos;
|
|
if (cur->cursor_xpos > 0) {
|
|
if (row->string[pos] == '\t') {
|
|
size = tab_size(row, pos);
|
|
if (size > cur->cursor_xpos) {
|
|
cur->cursor_xpos = 0;
|
|
cur->row_xpos = 0;
|
|
} else {
|
|
cur->row_xpos--;
|
|
cur->cursor_xpos -= size;
|
|
}
|
|
} else {
|
|
cur->cursor_xpos--;
|
|
cur->row_xpos--;
|
|
}
|
|
} else {
|
|
cur->cur_line = cur->cur_line->prev;
|
|
if (cur->cursor_ypos > 0)
|
|
cur->cursor_ypos--;
|
|
else
|
|
cur->start_line =
|
|
cur->start_line->prev;
|
|
row = cur->cur_line;
|
|
if (row->expanded > 0) {
|
|
cur->cursor_xpos = row->expanded - 1;
|
|
} else {
|
|
cur->cursor_xpos = 0;
|
|
}
|
|
|
|
if (row->length > 0)
|
|
cur->row_xpos = row->length - 1;
|
|
else
|
|
cur->row_xpos = 0;
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case REQ_DOWN_CHAR:
|
|
/*
|
|
* The down_char request has the same functionality as
|
|
* the next_line request excepting that the field is not
|
|
* scrolled if the cursor is at the bottom of the field.
|
|
* Check to see if the cursor is at the bottom of the field
|
|
* and if it is then deny the request otherwise fall
|
|
* through to the next_line handler.
|
|
*/
|
|
if (cur->cursor_ypos >= cur->rows - 1)
|
|
return E_REQUEST_DENIED;
|
|
|
|
/* FALLTHRU */
|
|
|
|
case REQ_NEXT_LINE:
|
|
if ((row->next == NULL) || (cur->cur_line->next == NULL))
|
|
return E_REQUEST_DENIED;
|
|
|
|
cur->cur_line = cur->cur_line->next;
|
|
if ((cur->cursor_ypos + 1) >= cur->rows) {
|
|
cur->start_line = cur->start_line->next;
|
|
} else
|
|
cur->cursor_ypos++;
|
|
row = cur->cur_line;
|
|
|
|
if (row->length == 0) {
|
|
cur->row_xpos = 0;
|
|
cur->cursor_xpos = 0;
|
|
} else {
|
|
if (cur->cursor_xpos > (row->expanded - 1))
|
|
cur->cursor_xpos = row->expanded - 1;
|
|
|
|
cur->row_xpos = tab_fit_len(row, cur->cursor_xpos + 1);
|
|
if (cur->row_xpos == 0)
|
|
cur->cursor_xpos = 0;
|
|
else
|
|
cur->cursor_xpos =
|
|
_formi_tab_expanded_length(
|
|
row->string, 0, cur->row_xpos);
|
|
if (cur->cursor_xpos > 0)
|
|
cur->cursor_xpos--;
|
|
}
|
|
break;
|
|
|
|
case REQ_UP_CHAR:
|
|
/*
|
|
* The up_char request has the same functionality as
|
|
* the prev_line request excepting the field is not
|
|
* scrolled, check if the cursor is at the top of the
|
|
* field, if it is deny the request otherwise fall
|
|
* through to the prev_line handler.
|
|
*/
|
|
if (cur->cursor_ypos == 0)
|
|
return E_REQUEST_DENIED;
|
|
|
|
/* FALLTHRU */
|
|
|
|
case REQ_PREV_LINE:
|
|
if (cur->cur_line->prev == NULL)
|
|
return E_REQUEST_DENIED;
|
|
|
|
if (cur->cursor_ypos == 0) {
|
|
if (cur->start_line->prev == NULL)
|
|
return E_REQUEST_DENIED;
|
|
cur->start_line = cur->start_line->prev;
|
|
} else
|
|
cur->cursor_ypos--;
|
|
|
|
cur->cur_line = cur->cur_line->prev;
|
|
row = cur->cur_line;
|
|
|
|
if (row->length == 0) {
|
|
cur->row_xpos = 0;
|
|
cur->cursor_xpos = 0;
|
|
} else {
|
|
if (cur->cursor_xpos > (row->expanded - 1))
|
|
cur->cursor_xpos = row->expanded - 1;
|
|
|
|
cur->row_xpos = tab_fit_len(row, cur->cursor_xpos + 1);
|
|
cur->cursor_xpos =
|
|
_formi_tab_expanded_length(row->string,
|
|
0, cur->row_xpos);
|
|
if (cur->cursor_xpos > 0)
|
|
cur->cursor_xpos--;
|
|
}
|
|
break;
|
|
|
|
case REQ_NEXT_WORD:
|
|
start = cur->row_xpos + cur->start_char;
|
|
str = row->string;
|
|
|
|
wb = find_eow(cur, start, FALSE, &row);
|
|
if (wb < 0)
|
|
return wb;
|
|
|
|
start = wb;
|
|
/* check if we hit the end */
|
|
if (str[start] == '\0')
|
|
return E_REQUEST_DENIED;
|
|
|
|
/* otherwise we must have found the start of a word...*/
|
|
if ((cur->rows + cur->nrows) == 1) {
|
|
/* single line field */
|
|
size = _formi_tab_expanded_length(str,
|
|
cur->start_char, start);
|
|
if (size < cur->cols) {
|
|
cur->row_xpos = start - cur->start_char;
|
|
} else {
|
|
cur->start_char = start;
|
|
cur->row_xpos = 0;
|
|
}
|
|
_formi_set_cursor_xpos(cur, FALSE);
|
|
} else {
|
|
/* multiline field */
|
|
cur->cur_line = row;
|
|
adjust_ypos(cur, row);
|
|
|
|
cur->row_xpos = start;
|
|
cur->cursor_xpos =
|
|
_formi_tab_expanded_length(
|
|
row->string, 0, cur->row_xpos) - 1;
|
|
}
|
|
break;
|
|
|
|
case REQ_PREV_WORD:
|
|
start = cur->start_char + cur->row_xpos;
|
|
if (cur->start_char > 0)
|
|
start--;
|
|
|
|
if ((start == 0) && (row->prev == NULL))
|
|
return E_REQUEST_DENIED;
|
|
|
|
if (start == 0) {
|
|
row = row->prev;
|
|
if (row->length > 0)
|
|
start = row->length - 1;
|
|
else
|
|
start = 0;
|
|
}
|
|
|
|
str = row->string;
|
|
|
|
start = find_sow(start, &row);
|
|
|
|
if ((cur->rows + cur->nrows) == 1) {
|
|
/* single line field */
|
|
size = _formi_tab_expanded_length(str,
|
|
cur->start_char, start);
|
|
|
|
if (start > cur->start_char) {
|
|
cur->row_xpos = start - cur->start_char;
|
|
} else {
|
|
cur->start_char = start;
|
|
cur->row_xpos = 0;
|
|
}
|
|
_formi_set_cursor_xpos(cur, FALSE);
|
|
} else {
|
|
/* multiline field */
|
|
cur->cur_line = row;
|
|
adjust_ypos(cur, row);
|
|
cur->row_xpos = start;
|
|
cur->cursor_xpos =
|
|
_formi_tab_expanded_length(
|
|
row->string, 0,
|
|
cur->row_xpos) - 1;
|
|
}
|
|
|
|
break;
|
|
|
|
case REQ_BEG_FIELD:
|
|
cur->start_char = 0;
|
|
while (cur->start_line->prev != NULL)
|
|
cur->start_line = cur->start_line->prev;
|
|
cur->cur_line = cur->start_line;
|
|
cur->row_xpos = 0;
|
|
_formi_init_field_xpos(cur);
|
|
cur->cursor_ypos = 0;
|
|
break;
|
|
|
|
case REQ_BEG_LINE:
|
|
cur->row_xpos = 0;
|
|
_formi_init_field_xpos(cur);
|
|
cur->start_char = 0;
|
|
break;
|
|
|
|
case REQ_END_FIELD:
|
|
while (cur->cur_line->next != NULL)
|
|
cur->cur_line = cur->cur_line->next;
|
|
|
|
if (cur->row_count > cur->rows) {
|
|
cur->start_line = cur->cur_line;
|
|
pos = cur->rows - 1;
|
|
while (pos > 0) {
|
|
cur->start_line = cur->start_line->prev;
|
|
pos--;
|
|
}
|
|
cur->cursor_ypos = cur->rows - 1;
|
|
} else {
|
|
cur->cursor_ypos = cur->row_count - 1;
|
|
}
|
|
|
|
/* we fall through here deliberately, we are on the
|
|
* correct row, now we need to get to the end of the
|
|
* line.
|
|
*/
|
|
/* FALLTHRU */
|
|
|
|
case REQ_END_LINE:
|
|
row = cur->cur_line;
|
|
|
|
if ((cur->rows + cur->nrows) == 1) {
|
|
if (row->expanded > cur->cols - 1) {
|
|
if ((cur->opts & O_STATIC) != O_STATIC) {
|
|
cur->start_char = tab_fit_window(
|
|
cur, row->length,
|
|
cur->cols) + 1;
|
|
cur->row_xpos = row->length
|
|
- cur->start_char;
|
|
} else {
|
|
cur->start_char = 0;
|
|
cur->row_xpos = cur->cols - 1;
|
|
}
|
|
} else {
|
|
cur->row_xpos = row->length + 1;
|
|
cur->start_char = 0;
|
|
}
|
|
_formi_set_cursor_xpos(cur, FALSE);
|
|
} else {
|
|
cur->row_xpos = row->length - 1;
|
|
cur->cursor_xpos = row->expanded - 1;
|
|
if (row->next == NULL) {
|
|
cur->row_xpos++;
|
|
cur->cursor_xpos++;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case REQ_NEW_LINE:
|
|
start = cur->start_char + cur->row_xpos;
|
|
if ((status = split_line(cur, TRUE, start, &row)) != E_OK)
|
|
return status;
|
|
cur->cur_line->hard_ret = TRUE;
|
|
cur->cursor_xpos = 0;
|
|
cur->row_xpos = 0;
|
|
break;
|
|
|
|
case REQ_INS_CHAR:
|
|
if ((status = _formi_add_char(cur, cur->start_char
|
|
+ cur->row_xpos,
|
|
cur->pad)) != E_OK)
|
|
return status;
|
|
break;
|
|
|
|
case REQ_INS_LINE:
|
|
if ((status = split_line(cur, TRUE, 0, &row)) != E_OK)
|
|
return status;
|
|
cur->cur_line->hard_ret = TRUE;
|
|
break;
|
|
|
|
case REQ_DEL_CHAR:
|
|
row = cur->cur_line;
|
|
start = cur->start_char + cur->row_xpos;
|
|
end = row->length - 1;
|
|
if ((start >= row->length) && (row->next == NULL))
|
|
return E_REQUEST_DENIED;
|
|
|
|
if ((start == row->length - 1) || (row->length == 0)) {
|
|
if ((cur->rows + cur->nrows) > 1) {
|
|
/*
|
|
* Firstly, check if the current line has
|
|
* a hard return. In this case we just
|
|
* want to "delete" the hard return and
|
|
* re-wrap the field. The hard return
|
|
* does not occupy a character space in
|
|
* the buffer but we must make it appear
|
|
* like it does for a deletion.
|
|
*/
|
|
if (row->hard_ret == TRUE) {
|
|
row->hard_ret = FALSE;
|
|
if (_formi_join_line(cur, &row,
|
|
JOIN_NEXT)
|
|
!= E_OK) {
|
|
row->hard_ret = TRUE;
|
|
return 0;
|
|
} else {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If we have more than one row, join the
|
|
* next row to make things easier unless
|
|
* we are at the end of the string, in
|
|
* that case the join would fail but we
|
|
* really want to delete the last char
|
|
* in the field.
|
|
*/
|
|
if (row->next != NULL) {
|
|
if (_formi_join_line(cur, &row,
|
|
JOIN_NEXT_NW)
|
|
!= E_OK) {
|
|
return E_REQUEST_DENIED;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
saved = row->string[start];
|
|
bcopy(&row->string[start + 1], &row->string[start],
|
|
(size_t) (end - start + 1));
|
|
row->string[end] = '\0';
|
|
row->length--;
|
|
if (row->length > 0)
|
|
row->expanded = _formi_tab_expanded_length(
|
|
row->string, 0, row->length - 1);
|
|
else
|
|
row->expanded = 0;
|
|
|
|
/*
|
|
* recalculate tabs for a single line field, multiline
|
|
* fields will do this when the field is wrapped.
|
|
*/
|
|
if ((cur->rows + cur->nrows) == 1)
|
|
_formi_calculate_tabs(row);
|
|
/*
|
|
* if we are at the end of the string then back the
|
|
* cursor pos up one to stick on the end of the line
|
|
*/
|
|
if (start == row->length) {
|
|
if (row->length > 1) {
|
|
if ((cur->rows + cur->nrows) == 1) {
|
|
pos = cur->row_xpos + cur->start_char;
|
|
cur->start_char =
|
|
tab_fit_window(
|
|
cur,
|
|
cur->start_char + cur->row_xpos,
|
|
cur->cols);
|
|
cur->row_xpos = pos - cur->start_char
|
|
- 1;
|
|
_formi_set_cursor_xpos(cur, FALSE);
|
|
} else {
|
|
if (cur->row_xpos == 0) {
|
|
if (row->next != NULL) {
|
|
if (_formi_join_line(
|
|
cur, &row,
|
|
JOIN_PREV_NW)
|
|
!= E_OK) {
|
|
return E_REQUEST_DENIED;
|
|
}
|
|
} else {
|
|
if (cur->row_count > 1)
|
|
cur->row_count--;
|
|
}
|
|
|
|
}
|
|
|
|
cur->row_xpos = start - 1;
|
|
cur->cursor_xpos =
|
|
_formi_tab_expanded_length(
|
|
row->string,
|
|
0, cur->row_xpos - 1);
|
|
if ((cur->cursor_xpos > 0)
|
|
&& (start != (row->expanded - 1)))
|
|
cur->cursor_xpos--;
|
|
}
|
|
|
|
start--;
|
|
} else {
|
|
start = 0;
|
|
cur->row_xpos = 0;
|
|
_formi_init_field_xpos(cur);
|
|
}
|
|
}
|
|
|
|
if ((cur->rows + cur->nrows) > 1) {
|
|
if (_formi_wrap_field(cur, row) != E_OK) {
|
|
bcopy(&row->string[start],
|
|
&row->string[start + 1],
|
|
(size_t) (end - start));
|
|
row->length++;
|
|
row->string[start] = saved;
|
|
_formi_wrap_field(cur, row);
|
|
return E_REQUEST_DENIED;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case REQ_DEL_PREV:
|
|
if ((cur->cursor_xpos == 0) && (cur->start_char == 0)
|
|
&& (cur->start_line->prev == NULL)
|
|
&& (cur->cursor_ypos == 0))
|
|
return E_REQUEST_DENIED;
|
|
|
|
row = cur->cur_line;
|
|
start = cur->row_xpos + cur->start_char;
|
|
end = row->length - 1;
|
|
eat_char = TRUE;
|
|
|
|
if ((cur->start_char + cur->row_xpos) == 0) {
|
|
if (row->prev == NULL)
|
|
return E_REQUEST_DENIED;
|
|
|
|
/*
|
|
* If we are a multiline field then check if
|
|
* the line above has a hard return. If it does
|
|
* then just "eat" the hard return and re-wrap
|
|
* the field.
|
|
*/
|
|
if (row->prev->hard_ret == TRUE) {
|
|
row->prev->hard_ret = FALSE;
|
|
if (_formi_join_line(cur, &row,
|
|
JOIN_PREV) != E_OK) {
|
|
row->prev->hard_ret = TRUE;
|
|
return 0;
|
|
}
|
|
|
|
eat_char = FALSE;
|
|
} else {
|
|
start = row->prev->length;
|
|
/*
|
|
* Join this line to the previous
|
|
* one.
|
|
*/
|
|
if (_formi_join_line(cur, &row,
|
|
JOIN_PREV_NW) != E_OK) {
|
|
return 0;
|
|
}
|
|
end = row->length - 1;
|
|
}
|
|
}
|
|
|
|
if (eat_char == TRUE) {
|
|
/*
|
|
* eat a char from the buffer. Normally we do
|
|
* this unless we have deleted a "hard return"
|
|
* in which case we just want to join the lines
|
|
* without losing a char.
|
|
*/
|
|
saved = row->string[start - 1];
|
|
bcopy(&row->string[start], &row->string[start - 1],
|
|
(size_t) (end - start + 1));
|
|
row->length--;
|
|
row->string[row->length] = '\0';
|
|
row->expanded = _formi_tab_expanded_length(
|
|
row->string, 0, row->length - 1);
|
|
}
|
|
|
|
if ((cur->rows + cur->nrows) == 1) {
|
|
_formi_calculate_tabs(row);
|
|
pos = cur->row_xpos + cur->start_char;
|
|
if (pos > 0)
|
|
pos--;
|
|
cur->start_char =
|
|
tab_fit_window(cur,
|
|
cur->start_char + cur->row_xpos,
|
|
cur->cols);
|
|
cur->row_xpos = pos - cur->start_char;
|
|
_formi_set_cursor_xpos(cur, FALSE);
|
|
} else {
|
|
if (eat_char == TRUE) {
|
|
cur->row_xpos--;
|
|
if (cur->row_xpos > 0)
|
|
cur->cursor_xpos =
|
|
_formi_tab_expanded_length(
|
|
row->string, 0,
|
|
cur->row_xpos - 1);
|
|
else
|
|
cur->cursor_xpos = 0;
|
|
}
|
|
|
|
if ((_formi_wrap_field(cur, row) != E_OK)) {
|
|
bcopy(&row->string[start - 1],
|
|
&row->string[start],
|
|
(size_t) (end - start));
|
|
row->length++;
|
|
row->string[start - 1] = saved;
|
|
row->string[row->length] = '\0';
|
|
_formi_wrap_field(cur, row);
|
|
return E_REQUEST_DENIED;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case REQ_DEL_LINE:
|
|
if (((cur->rows + cur->nrows) == 1) ||
|
|
(cur->row_count == 1)) {
|
|
/* single line case */
|
|
row->length = 0;
|
|
row->expanded = row->length = 0;
|
|
cur->row_xpos = 0;
|
|
_formi_init_field_xpos(cur);
|
|
cur->cursor_ypos = 0;
|
|
} else {
|
|
/* multiline field */
|
|
old_count = cur->row_count;
|
|
cur->row_count--;
|
|
if (cur->row_count == 0)
|
|
cur->row_count = 1;
|
|
|
|
if (old_count == 1) {
|
|
row->expanded = row->length = 0;
|
|
cur->cursor_xpos = 0;
|
|
cur->row_xpos = 0;
|
|
cur->cursor_ypos = 0;
|
|
} else
|
|
add_to_free(cur, row);
|
|
|
|
if (row->next == NULL) {
|
|
if (cur->cursor_ypos == 0) {
|
|
if (cur->start_line->prev != NULL) {
|
|
cur->start_line =
|
|
cur->start_line->prev;
|
|
}
|
|
} else {
|
|
cur->cursor_ypos--;
|
|
}
|
|
}
|
|
|
|
if (old_count > 1) {
|
|
if (cur->cursor_xpos > row->expanded) {
|
|
cur->cursor_xpos = row->expanded - 1;
|
|
cur->row_xpos = row->length - 1;
|
|
}
|
|
|
|
cur->start_line = cur->alines;
|
|
rs = cur->start_line;
|
|
cur->cursor_ypos = 0;
|
|
while (rs != row) {
|
|
if (cur->cursor_ypos < cur->rows)
|
|
cur->cursor_ypos++;
|
|
else
|
|
cur->start_line =
|
|
cur->start_line->next;
|
|
rs = rs->next;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case REQ_DEL_WORD:
|
|
start = cur->start_char + cur->row_xpos;
|
|
str = row->string;
|
|
|
|
wb = find_eow(cur, start, TRUE, &row);
|
|
if (wb < 0)
|
|
return wb;
|
|
|
|
end = wb;
|
|
|
|
/*
|
|
* If not at the start of a word then find the start,
|
|
* we cannot blindly call find_sow because this will
|
|
* skip back a word if we are already at the start of
|
|
* a word.
|
|
*/
|
|
if ((start > 0)
|
|
&& !(isblank((unsigned char)str[start - 1]) &&
|
|
!isblank((unsigned char)str[start])))
|
|
start = find_sow(start, &row);
|
|
str = row->string;
|
|
/* XXXX hmmmm what if start and end on diff rows? XXXX */
|
|
bcopy(&str[end], &str[start],
|
|
(size_t) (row->length - end + 1));
|
|
len = end - start;
|
|
row->length -= len;
|
|
|
|
if ((cur->rows + cur->nrows) > 1) {
|
|
row = cur->start_line + cur->cursor_ypos;
|
|
if (row->next != NULL) {
|
|
/*
|
|
* if not on the last row we need to
|
|
* join on the next row so the line
|
|
* will be re-wrapped.
|
|
*/
|
|
_formi_join_line(cur, &row, JOIN_NEXT_NW);
|
|
}
|
|
_formi_wrap_field(cur, row);
|
|
cur->row_xpos = start;
|
|
cur->cursor_xpos = _formi_tab_expanded_length(
|
|
row->string, 0, cur->row_xpos);
|
|
if (cur->cursor_xpos > 0)
|
|
cur->cursor_xpos--;
|
|
} else {
|
|
_formi_calculate_tabs(row);
|
|
cur->row_xpos = start - cur->start_char;
|
|
if (cur->row_xpos > 0)
|
|
cur->row_xpos--;
|
|
_formi_set_cursor_xpos(cur, FALSE);
|
|
}
|
|
break;
|
|
|
|
case REQ_CLR_EOL:
|
|
row->string[cur->row_xpos + 1] = '\0';
|
|
row->length = cur->row_xpos + 1;
|
|
row->expanded = cur->cursor_xpos + 1;
|
|
break;
|
|
|
|
case REQ_CLR_EOF:
|
|
row = cur->cur_line->next;
|
|
while (row != NULL) {
|
|
rs = row->next;
|
|
add_to_free(cur, row);
|
|
row = rs;
|
|
cur->row_count--;
|
|
}
|
|
break;
|
|
|
|
case REQ_CLR_FIELD:
|
|
row = cur->alines->next;
|
|
cur->cur_line = cur->alines;
|
|
cur->start_line = cur->alines;
|
|
|
|
while (row != NULL) {
|
|
rs = row->next;
|
|
add_to_free(cur, row);
|
|
row = rs;
|
|
}
|
|
|
|
cur->alines->string[0] = '\0';
|
|
cur->alines->length = 0;
|
|
cur->alines->expanded = 0;
|
|
cur->row_count = 1;
|
|
cur->cursor_ypos = 0;
|
|
cur->row_xpos = 0;
|
|
_formi_init_field_xpos(cur);
|
|
cur->start_char = 0;
|
|
break;
|
|
|
|
case REQ_OVL_MODE:
|
|
cur->overlay = 1;
|
|
break;
|
|
|
|
case REQ_INS_MODE:
|
|
cur->overlay = 0;
|
|
break;
|
|
|
|
case REQ_SCR_FLINE:
|
|
_formi_scroll_fwd(cur, 1);
|
|
break;
|
|
|
|
case REQ_SCR_BLINE:
|
|
_formi_scroll_back(cur, 1);
|
|
break;
|
|
|
|
case REQ_SCR_FPAGE:
|
|
_formi_scroll_fwd(cur, cur->rows);
|
|
break;
|
|
|
|
case REQ_SCR_BPAGE:
|
|
_formi_scroll_back(cur, cur->rows);
|
|
break;
|
|
|
|
case REQ_SCR_FHPAGE:
|
|
_formi_scroll_fwd(cur, cur->rows / 2);
|
|
break;
|
|
|
|
case REQ_SCR_BHPAGE:
|
|
_formi_scroll_back(cur, cur->rows / 2);
|
|
break;
|
|
|
|
case REQ_SCR_FCHAR:
|
|
_formi_hscroll_fwd(cur, row, 1);
|
|
break;
|
|
|
|
case REQ_SCR_BCHAR:
|
|
_formi_hscroll_back(cur, row, 1);
|
|
break;
|
|
|
|
case REQ_SCR_HFLINE:
|
|
_formi_hscroll_fwd(cur, row, cur->cols);
|
|
break;
|
|
|
|
case REQ_SCR_HBLINE:
|
|
_formi_hscroll_back(cur, row, cur->cols);
|
|
break;
|
|
|
|
case REQ_SCR_HFHALF:
|
|
_formi_hscroll_fwd(cur, row, cur->cols / 2);
|
|
break;
|
|
|
|
case REQ_SCR_HBHALF:
|
|
_formi_hscroll_back(cur, row, cur->cols / 2);
|
|
break;
|
|
|
|
default:
|
|
return 0;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
fprintf(dbg,
|
|
"exit: cursor_xpos=%d, row_xpos=%d, start_char=%d, length=%d, allocated=%d\n",
|
|
cur->cursor_xpos, cur->row_xpos, cur->start_char,
|
|
cur->cur_line->length, cur->cur_line->allocated);
|
|
fprintf(dbg, "exit: start_line=%p, ypos=%d\n", cur->start_line,
|
|
cur->cursor_ypos);
|
|
fprintf(dbg, "exit: string=\"%s\"\n", cur->cur_line->string);
|
|
assert ((cur->cursor_xpos < INT_MAX) && (cur->row_xpos < INT_MAX)
|
|
&& (cur->cursor_xpos >= cur->row_xpos));
|
|
#endif
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* Validate the given character by passing it to any type character
|
|
* checking routines, if they exist.
|
|
*/
|
|
int
|
|
_formi_validate_char(FIELD *field, char c)
|
|
{
|
|
int ret_val;
|
|
|
|
if (field->type == NULL)
|
|
return E_OK;
|
|
|
|
ret_val = E_INVALID_FIELD;
|
|
_formi_do_char_validation(field, field->type, c, &ret_val);
|
|
|
|
return ret_val;
|
|
}
|
|
|
|
|
|
/*
|
|
* Perform the validation of the character, invoke all field_type validation
|
|
* routines. If the field is ok then update ret_val to E_OK otherwise
|
|
* ret_val is not changed.
|
|
*/
|
|
static void
|
|
_formi_do_char_validation(FIELD *field, FIELDTYPE *type, char c, int *ret_val)
|
|
{
|
|
if ((type->flags & _TYPE_IS_LINKED) == _TYPE_IS_LINKED) {
|
|
_formi_do_char_validation(field, type->link->next, c, ret_val);
|
|
_formi_do_char_validation(field, type->link->prev, c, ret_val);
|
|
} else {
|
|
if (type->char_check == NULL)
|
|
*ret_val = E_OK;
|
|
else {
|
|
if (type->char_check((int)(unsigned char) c,
|
|
field->args) == TRUE)
|
|
*ret_val = E_OK;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Validate the current field. If the field validation returns success then
|
|
* return E_OK otherwise return E_INVALID_FIELD.
|
|
*
|
|
*/
|
|
int
|
|
_formi_validate_field(FORM *form)
|
|
{
|
|
FIELD *cur;
|
|
int ret_val, count;
|
|
|
|
|
|
if ((form == NULL) || (form->fields == NULL) ||
|
|
(form->fields[0] == NULL))
|
|
return E_INVALID_FIELD;
|
|
|
|
cur = form->fields[form->cur_field];
|
|
|
|
/*
|
|
* Sync the buffer if it has been modified so the field
|
|
* validation routines can use it and because this is
|
|
* the correct behaviour according to AT&T implementation.
|
|
*/
|
|
if ((cur->buf0_status == TRUE)
|
|
&& ((ret_val = _formi_sync_buffer(cur)) != E_OK))
|
|
return ret_val;
|
|
|
|
/*
|
|
* If buffer is untouched then the string pointer may be
|
|
* NULL, see if this is ok or not.
|
|
*/
|
|
if (cur->buffers[0].string == NULL) {
|
|
if ((cur->opts & O_NULLOK) == O_NULLOK)
|
|
return E_OK;
|
|
else
|
|
return E_INVALID_FIELD;
|
|
}
|
|
|
|
count = _formi_skip_blanks(cur->buffers[0].string, 0);
|
|
|
|
/* check if we have a null field, depending on the nullok flag
|
|
* this may be acceptable or not....
|
|
*/
|
|
if (cur->buffers[0].string[count] == '\0') {
|
|
if ((cur->opts & O_NULLOK) == O_NULLOK)
|
|
return E_OK;
|
|
else
|
|
return E_INVALID_FIELD;
|
|
}
|
|
|
|
/* check if an unmodified field is ok */
|
|
if (cur->buf0_status == 0) {
|
|
if ((cur->opts & O_PASSOK) == O_PASSOK)
|
|
return E_OK;
|
|
else
|
|
return E_INVALID_FIELD;
|
|
}
|
|
|
|
/* if there is no type then just accept the field */
|
|
if (cur->type == NULL)
|
|
return E_OK;
|
|
|
|
ret_val = E_INVALID_FIELD;
|
|
_formi_do_validation(cur, cur->type, &ret_val);
|
|
|
|
return ret_val;
|
|
}
|
|
|
|
/*
|
|
* Perform the validation of the field, invoke all field_type validation
|
|
* routines. If the field is ok then update ret_val to E_OK otherwise
|
|
* ret_val is not changed.
|
|
*/
|
|
static void
|
|
_formi_do_validation(FIELD *field, FIELDTYPE *type, int *ret_val)
|
|
{
|
|
if ((type->flags & _TYPE_IS_LINKED) == _TYPE_IS_LINKED) {
|
|
_formi_do_validation(field, type->link->next, ret_val);
|
|
_formi_do_validation(field, type->link->prev, ret_val);
|
|
} else {
|
|
if (type->field_check == NULL)
|
|
*ret_val = E_OK;
|
|
else {
|
|
if (type->field_check(field, field_buffer(field, 0))
|
|
== TRUE)
|
|
*ret_val = E_OK;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Select the next/previous choice for the field, the driver command
|
|
* selecting the direction will be passed in c. Return 1 if a choice
|
|
* selection succeeded, 0 otherwise.
|
|
*/
|
|
int
|
|
_formi_field_choice(FORM *form, int c)
|
|
{
|
|
FIELDTYPE *type;
|
|
FIELD *field;
|
|
|
|
if ((form == NULL) || (form->fields == NULL) ||
|
|
(form->fields[0] == NULL) ||
|
|
(form->fields[form->cur_field]->type == NULL))
|
|
return 0;
|
|
|
|
field = form->fields[form->cur_field];
|
|
type = field->type;
|
|
|
|
switch (c) {
|
|
case REQ_NEXT_CHOICE:
|
|
if (type->next_choice == NULL)
|
|
return 0;
|
|
else
|
|
return type->next_choice(field,
|
|
field_buffer(field, 0));
|
|
|
|
case REQ_PREV_CHOICE:
|
|
if (type->prev_choice == NULL)
|
|
return 0;
|
|
else
|
|
return type->prev_choice(field,
|
|
field_buffer(field, 0));
|
|
|
|
default: /* should never happen! */
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Update the fields if they have changed. The parameter old has the
|
|
* previous current field as the current field may have been updated by
|
|
* the driver. Return 1 if the form page needs updating.
|
|
*
|
|
*/
|
|
int
|
|
_formi_update_field(FORM *form, int old_field)
|
|
{
|
|
int cur, i;
|
|
|
|
cur = form->cur_field;
|
|
|
|
if (old_field != cur) {
|
|
if (!((cur >= form->page_starts[form->page].first) &&
|
|
(cur <= form->page_starts[form->page].last))) {
|
|
/* not on same page any more */
|
|
for (i = 0; i < form->max_page; i++) {
|
|
if ((form->page_starts[i].in_use == 1) &&
|
|
(form->page_starts[i].first <= cur) &&
|
|
(form->page_starts[i].last >= cur)) {
|
|
form->page = i;
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
_formi_redraw_field(form, old_field);
|
|
_formi_redraw_field(form, form->cur_field);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Compare function for the field sorting
|
|
*
|
|
*/
|
|
static int
|
|
field_sort_compare(const void *one, const void *two)
|
|
{
|
|
const FIELD *a, *b;
|
|
int tl;
|
|
|
|
/* LINTED const castaway; we don't modify these! */
|
|
a = (const FIELD *) *((const FIELD **) one);
|
|
b = (const FIELD *) *((const FIELD **) two);
|
|
|
|
if (a == NULL)
|
|
return 1;
|
|
|
|
if (b == NULL)
|
|
return -1;
|
|
|
|
/*
|
|
* First check the page, we want the fields sorted by page.
|
|
*
|
|
*/
|
|
if (a->page != b->page)
|
|
return ((a->page > b->page)? 1 : -1);
|
|
|
|
tl = _formi_top_left(a->parent, a->index, b->index);
|
|
|
|
/*
|
|
* sort fields left to right, top to bottom so the top left is
|
|
* the lesser value....
|
|
*/
|
|
return ((tl == a->index)? -1 : 1);
|
|
}
|
|
|
|
/*
|
|
* Sort the fields in a form ready for driver traversal.
|
|
*/
|
|
void
|
|
_formi_sort_fields(FORM *form)
|
|
{
|
|
FIELD **sort_area;
|
|
int i;
|
|
|
|
TAILQ_INIT(&form->sorted_fields);
|
|
|
|
if ((sort_area = malloc(sizeof(*sort_area) * form->field_count))
|
|
== NULL)
|
|
return;
|
|
|
|
bcopy(form->fields, sort_area,
|
|
(size_t) (sizeof(FIELD *) * form->field_count));
|
|
qsort(sort_area, (size_t) form->field_count, sizeof(FIELD *),
|
|
field_sort_compare);
|
|
|
|
for (i = 0; i < form->field_count; i++)
|
|
TAILQ_INSERT_TAIL(&form->sorted_fields, sort_area[i], glue);
|
|
|
|
free(sort_area);
|
|
}
|
|
|
|
/*
|
|
* Set the neighbours for all the fields in the given form.
|
|
*/
|
|
void
|
|
_formi_stitch_fields(FORM *form)
|
|
{
|
|
int above_row, below_row, end_above, end_below, cur_row, real_end;
|
|
FIELD *cur, *above, *below;
|
|
|
|
/*
|
|
* check if the sorted fields circle queue is empty, just
|
|
* return if it is.
|
|
*/
|
|
if (TAILQ_EMPTY(&form->sorted_fields))
|
|
return;
|
|
|
|
/* initially nothing is above..... */
|
|
above_row = -1;
|
|
end_above = TRUE;
|
|
above = NULL;
|
|
|
|
/* set up the first field as the current... */
|
|
cur = TAILQ_FIRST(&form->sorted_fields);
|
|
cur_row = cur->form_row;
|
|
|
|
/* find the first field on the next row if any */
|
|
below = TAILQ_NEXT(cur, glue);
|
|
below_row = -1;
|
|
end_below = TRUE;
|
|
real_end = TRUE;
|
|
while (below != NULL) {
|
|
if (below->form_row != cur_row) {
|
|
below_row = below->form_row;
|
|
end_below = FALSE;
|
|
real_end = FALSE;
|
|
break;
|
|
}
|
|
below = TAILQ_NEXT(below, glue);
|
|
}
|
|
|
|
/* walk the sorted fields, setting the neighbour pointers */
|
|
while (cur != NULL) {
|
|
if (cur == TAILQ_FIRST(&form->sorted_fields))
|
|
cur->left = NULL;
|
|
else
|
|
cur->left = TAILQ_PREV(cur, _formi_sort_head, glue);
|
|
|
|
if (cur == TAILQ_LAST(&form->sorted_fields, _formi_sort_head))
|
|
cur->right = NULL;
|
|
else
|
|
cur->right = TAILQ_NEXT(cur, glue);
|
|
|
|
if (end_above == TRUE)
|
|
cur->up = NULL;
|
|
else {
|
|
cur->up = above;
|
|
above = TAILQ_NEXT(above, glue);
|
|
if (above_row != above->form_row) {
|
|
end_above = TRUE;
|
|
above_row = above->form_row;
|
|
}
|
|
}
|
|
|
|
if (end_below == TRUE)
|
|
cur->down = NULL;
|
|
else {
|
|
cur->down = below;
|
|
below = TAILQ_NEXT(below, glue);
|
|
if (below == NULL) {
|
|
end_below = TRUE;
|
|
real_end = TRUE;
|
|
} else if (below_row != below->form_row) {
|
|
end_below = TRUE;
|
|
below_row = below->form_row;
|
|
}
|
|
}
|
|
|
|
cur = TAILQ_NEXT(cur, glue);
|
|
if ((cur != NULL)
|
|
&& (cur_row != cur->form_row)) {
|
|
cur_row = cur->form_row;
|
|
if (end_above == FALSE) {
|
|
for (; above !=
|
|
TAILQ_FIRST(&form->sorted_fields);
|
|
above = TAILQ_NEXT(above, glue)) {
|
|
if (above->form_row != above_row) {
|
|
above_row = above->form_row;
|
|
break;
|
|
}
|
|
}
|
|
} else if (above == NULL) {
|
|
above = TAILQ_FIRST(&form->sorted_fields);
|
|
end_above = FALSE;
|
|
above_row = above->form_row;
|
|
} else
|
|
end_above = FALSE;
|
|
|
|
if (end_below == FALSE) {
|
|
while (below_row == below->form_row) {
|
|
below = TAILQ_NEXT(below, glue);
|
|
if (below == NULL) {
|
|
real_end = TRUE;
|
|
end_below = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (below != NULL)
|
|
below_row = below->form_row;
|
|
} else if (real_end == FALSE)
|
|
end_below = FALSE;
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Calculate the length of the displayed line allowing for any tab
|
|
* characters that need to be expanded. We assume that the tab stops
|
|
* are 8 characters apart. The parameters start and end are the
|
|
* character positions in the string str we want to get the length of,
|
|
* the function returns the number of characters from the start
|
|
* position to the end position that should be displayed after any
|
|
* intervening tabs have been expanded.
|
|
*/
|
|
int
|
|
_formi_tab_expanded_length(char *str, unsigned int start, unsigned int end)
|
|
{
|
|
int len, start_len, i;
|
|
|
|
/* if we have a null string then there is no length */
|
|
if (str[0] == '\0')
|
|
return 0;
|
|
|
|
len = 0;
|
|
start_len = 0;
|
|
|
|
/*
|
|
* preceding tabs affect the length tabs in the span, so
|
|
* we need to calculate the length including the stuff before
|
|
* start and then subtract off the unwanted bit.
|
|
*/
|
|
for (i = 0; i <= end; i++) {
|
|
if (i == start) /* stash preamble length for later */
|
|
start_len = len;
|
|
|
|
if (str[i] == '\0')
|
|
break;
|
|
|
|
if (str[i] == '\t')
|
|
len = len - (len % 8) + 8;
|
|
else
|
|
len++;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
if (dbg != NULL) {
|
|
fprintf(dbg,
|
|
"tab_expanded: start=%d, end=%d, expanded=%d (diff=%d)\n",
|
|
start, end, (len - start_len), (end - start));
|
|
}
|
|
#endif
|
|
|
|
return (len - start_len);
|
|
}
|
|
|
|
/*
|
|
* Calculate the tab stops on a given line in the field and set up
|
|
* the tabs list with the results. We do this by scanning the line for tab
|
|
* characters and if one is found, noting the position and the number of
|
|
* characters to get to the next tab stop. This information is kept to
|
|
* make manipulating the field (scrolling and so on) easier to handle.
|
|
*/
|
|
void
|
|
_formi_calculate_tabs(_FORMI_FIELD_LINES *row)
|
|
{
|
|
_formi_tab_t *ts = row->tabs, *old_ts = NULL, **tsp;
|
|
int i, j;
|
|
|
|
/*
|
|
* If the line already has tabs then invalidate them by
|
|
* walking the list and killing the in_use flag.
|
|
*/
|
|
for (; ts != NULL; ts = ts->fwd)
|
|
ts->in_use = FALSE;
|
|
|
|
|
|
/*
|
|
* Now look for tabs in the row and record the info...
|
|
*/
|
|
tsp = &row->tabs;
|
|
for (i = 0, j = 0; i < row->length; i++, j++) {
|
|
if (row->string[i] == '\t') {
|
|
if (*tsp == NULL) {
|
|
if ((*tsp = (_formi_tab_t *)
|
|
malloc(sizeof(_formi_tab_t))) == NULL)
|
|
return;
|
|
(*tsp)->back = old_ts;
|
|
(*tsp)->fwd = NULL;
|
|
}
|
|
|
|
(*tsp)->in_use = TRUE;
|
|
(*tsp)->pos = i;
|
|
(*tsp)->size = 8 - (j % 8);
|
|
j += (*tsp)->size - 1;
|
|
old_ts = *tsp;
|
|
tsp = &(*tsp)->fwd;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Return the size of the tab padding for a tab character at the given
|
|
* position. Return 1 if there is not a tab char entry matching the
|
|
* given location.
|
|
*/
|
|
static int
|
|
tab_size(_FORMI_FIELD_LINES *row, unsigned int i)
|
|
{
|
|
_formi_tab_t *ts;
|
|
|
|
ts = row->tabs;
|
|
while ((ts != NULL) && (ts->pos != i))
|
|
ts = ts->fwd;
|
|
|
|
if (ts == NULL)
|
|
return 1;
|
|
else
|
|
return ts->size;
|
|
}
|
|
|
|
/*
|
|
* Find the character offset that corresponds to longest tab expanded
|
|
* string that will fit into the given window. Walk the string backwards
|
|
* evaluating the sizes of any tabs that are in the string. Note that
|
|
* using this function on a multi-line window will produce undefined
|
|
* results - it is really only required for a single row field.
|
|
*/
|
|
static int
|
|
tab_fit_window(FIELD *field, unsigned int pos, unsigned int window)
|
|
{
|
|
int scroll_amt, i;
|
|
_formi_tab_t *ts;
|
|
|
|
/* first find the last tab */
|
|
ts = field->alines->tabs;
|
|
|
|
/*
|
|
* unless there are no tabs - just return the window size,
|
|
* if there is enough room, otherwise 0.
|
|
*/
|
|
if (ts == NULL) {
|
|
if (field->alines->length < window)
|
|
return 0;
|
|
else
|
|
return field->alines->length - window + 1;
|
|
}
|
|
|
|
while ((ts->fwd != NULL) && (ts->fwd->in_use == TRUE))
|
|
ts = ts->fwd;
|
|
|
|
/*
|
|
* now walk backwards finding the first tab that is to the
|
|
* left of our starting pos.
|
|
*/
|
|
while ((ts != NULL) && (ts->in_use == TRUE) && (ts->pos > pos))
|
|
ts = ts->back;
|
|
|
|
scroll_amt = 0;
|
|
for (i = pos; i >= 0; i--) {
|
|
if (field->alines->string[i] == '\t') {
|
|
assert((ts != NULL) && (ts->in_use == TRUE));
|
|
if (ts->pos == i) {
|
|
if ((scroll_amt + ts->size) > window) {
|
|
break;
|
|
}
|
|
scroll_amt += ts->size;
|
|
ts = ts->back;
|
|
}
|
|
else
|
|
assert(ts->pos == i);
|
|
} else {
|
|
scroll_amt++;
|
|
if (scroll_amt > window)
|
|
break;
|
|
}
|
|
}
|
|
|
|
return ++i;
|
|
}
|
|
|
|
/*
|
|
* Return the position of the last character that will fit into the
|
|
* given width after tabs have been expanded for a given row of a given
|
|
* field.
|
|
*/
|
|
static unsigned int
|
|
tab_fit_len(_FORMI_FIELD_LINES *row, unsigned int width)
|
|
{
|
|
unsigned int pos, len, row_pos;
|
|
_formi_tab_t *ts;
|
|
|
|
ts = row->tabs;
|
|
pos = 0;
|
|
len = 0;
|
|
row_pos = 0;
|
|
|
|
if (width == 0)
|
|
return 0;
|
|
|
|
while ((len < width) && (pos < row->length)) {
|
|
if (row->string[pos] == '\t') {
|
|
assert((ts != NULL) && (ts->in_use == TRUE));
|
|
if (ts->pos == row_pos) {
|
|
if ((len + ts->size) > width)
|
|
break;
|
|
len += ts->size;
|
|
ts = ts->fwd;
|
|
}
|
|
else
|
|
assert(ts->pos == row_pos);
|
|
} else
|
|
len++;
|
|
pos++;
|
|
row_pos++;
|
|
}
|
|
|
|
if (pos > 0)
|
|
pos--;
|
|
return pos;
|
|
}
|
|
|
|
/*
|
|
* Sync the field line structures with the contents of buffer 0 for that
|
|
* field. We do this by walking all the line structures and concatenating
|
|
* all the strings into one single string in buffer 0.
|
|
*/
|
|
int
|
|
_formi_sync_buffer(FIELD *field)
|
|
{
|
|
_FORMI_FIELD_LINES *line;
|
|
char *nstr, *tmp;
|
|
unsigned length;
|
|
|
|
if (field->alines == NULL)
|
|
return E_BAD_ARGUMENT;
|
|
|
|
if (field->alines->string == NULL)
|
|
return E_BAD_ARGUMENT;
|
|
|
|
/*
|
|
* init nstr up front, just in case there are no line contents,
|
|
* this could happen if the field just contains hard returns.
|
|
*/
|
|
if ((nstr = malloc(sizeof(char))) == NULL)
|
|
return E_SYSTEM_ERROR;
|
|
nstr[0] = '\0';
|
|
|
|
line = field->alines;
|
|
length = 1; /* allow for terminating null */
|
|
|
|
while (line != NULL) {
|
|
if (line->length != 0) {
|
|
if ((tmp = realloc(nstr,
|
|
(size_t) (length + line->length)))
|
|
== NULL) {
|
|
if (nstr != NULL)
|
|
free(nstr);
|
|
return (E_SYSTEM_ERROR);
|
|
}
|
|
|
|
nstr = tmp;
|
|
strcat(nstr, line->string);
|
|
length += line->length;
|
|
}
|
|
|
|
line = line->next;
|
|
}
|
|
|
|
if (field->buffers[0].string != NULL)
|
|
free(field->buffers[0].string);
|
|
field->buffers[0].allocated = length;
|
|
field->buffers[0].length = length - 1;
|
|
field->buffers[0].string = nstr;
|
|
return E_OK;
|
|
}
|
|
|
|
|
|
|