ledit

view.h (18899B)

---

 /*
  * A view consists of a window and everything necessary for displaying
  * the contents of the associated buffer in that window.
  */
 
 #ifndef _LEDIT_VIEW_H_
 #define _LEDIT_VIEW_H_
 
 #include <stddef.h>
 #include "common.h"
 #include "txtbuf.h"
 #include "window.h"
 #include "cache.h"
 #include "uglycrap.h"
 
 typedef struct ledit_view ledit_view;
 
 #include "buffer.h"
 
 enum action_type {
         ACTION_NONE,   /* pass next key to basic key handler */
         ACTION_GRABKEY /* pass next key to given callback */
 };
 
 /* struct that is returned by key handlers to tell the
    main event manager what key handler to call next */
 struct action {
         enum action_type type;
         struct action (*callback)(ledit_view *view, unsigned int key_state, KeySym sym, char *buf, int n, int lang_index);
 };
 
 typedef struct {
 	ledit_view *view;          /* parent view */
 	int w;                     /* width in pixels */
 	int h;                     /* height in pixels */
 	long y_offset;             /* pixel offset starting at the top of the file */
 	size_t cache_pixmap_index; /* index of pixmap in cache, or -1 if not assigned */
 	size_t cache_layout_index; /* index of pango layout in cache, or -1 if not assigned */
 	int softlines;             /* number of softlines - cached from PangoLayout */
 	size_t cursor_index;       /* cursor index (for highlight in normal mode) */
 	char cursor_index_valid;   /* whether cursor index is valid */
 	char cache_pixmap_valid;   /* whether cache_pixmap_index is valid */
 	char cache_layout_valid;   /* whether cache_layout_index is valid */
 	char dirty;                /* whether line needs to be rendered before being drawn */
 	char text_dirty;           /* whether the text in the PangoLayout needs to be
 	                            * updated before the layout is rendered */
 	char highlight_dirty;      /* whether highlight (cursor or selection) needs to be
 	                            * updated still in the PangoLayout before rendering */
 	char h_dirty;              /* whether height needs to be recalculated */
 } ledit_view_line;
 
 struct ledit_view {
 	ledit_buffer *buffer;     /* parent buffer */
 	ledit_window *window;     /* window showing this view */
 	ledit_cache *cache;       /* cache for pixmaps and pango layouts */
 	ledit_view_line *lines;   /* array of lines, stored as gap buffer */
 	char *lock_text;          /* text to show if view is locked, i.e. no edits allowed */
 	/* current command type - used by key handler in keys_command.c */
 	command_mode cur_command_type;
 	struct action cur_action; /* current action to execute on key press */
 	size_t lines_cap;         /* size of lines array */
 	size_t lines_gap;         /* position of gap for line gap buffer */
 	size_t lines_num;         /* number of lines */
 	size_t cur_line;          /* current line */
 	size_t cur_index;         /* current byte index in line */
 	long total_height;        /* total pixel height of all lines */
 	long display_offset;      /* current pixel offset of viewport */
 	ledit_range sel;          /* current selection */
 	ledit_mode mode;          /* current mode of this view */
 	char destroy;             /* whether the view should be destroyed at the next possible time */
 	char selecting;           /* whether user is currently selecting text with mouse */
 	char button2_pressed;     /* whether button 2 (middle button) is pressed */
 	char sel_valid;           /* whether there is currently a valid selection */
 	char redraw;              /* whether something has changed so the view needs to be redrawn */
 };
 
 enum delete_mode {
 	DELETE_CHAR,     /* delete an exact line and byte range */
 	DELETE_SOFTLINE, /* delete a range of complete softlines */
 	DELETE_HARDLINE  /* delete a range of complete hardlines */
 };
 
 /*
  * Set the mode of the view.
  * This changes the mode group of the associated buffer's
  * undo stack and changes the mode display in the window.
  */
 void view_set_mode(ledit_view *view, ledit_mode mode);
 
 /*
  * Create a view with associated buffer 'buffer'
  * The initial mode, line, and byte position are given, respectively,
  * by 'mode', 'line', and 'pos'.
  */
 ledit_view *view_create(ledit_buffer *buffer, ledit_mode mode, size_t line, size_t pos);
 
 /*
  * Lock a view.
  * Views are locked for instance when substitution with confirmation is
  * being performed in another view to avoid an inconsistent state.
  * This currently only sets the lock text - commands using the view need
  * to make sure to check that it isn't locked.
  */
 void view_lock(ledit_view *view, char *text);
 
 /*
  * Unlock a view.
  */
 void view_unlock(ledit_view *view);
 
 /*
  * Get the view line at the given index.
  * The returned line is only valid until the next
  * action that appends or deletes line entries.
  */
 /* ledit_view_line *view_get_line(ledit_view *view, size_t index); */
 
 /* This is very hacky - it's so the actual function calling view_get_line is returned in the assertion message.
  * There probably is a better way to do this.
  */
 #define view_get_line(view, index) (ledit_assert((index) < (view)->lines_num), (index) < (view)->lines_gap ? &(view)->lines[index] : &(view)->lines[(index) + (view)->lines_cap - (view)->lines_num])
 
 /*
  * These notification functions are called by the buffer when text
  * is changed in order to keep all views in sync.
  */
 
 /*
  * Notify the view that 'len' bytes of text have been inserted at
  * line 'line' and byte position 'index'.
  * This marks the line as dirty, adjusts the cursor position, if it
  * is on the same line, and sets the selection to just the current
  * cursor position, if there was a valid selection.
  * The line heights and offsets are not recalculated.
  */
 void view_notify_insert_text(ledit_view *view, size_t line, size_t index, size_t len);
 
 /*
  * Notify the view that 'len' bytes of text have been deleted
  * starting at line 'line' and byte position 'index'.
  * This marks the line as dirty, adjusts the cursor position, if it
  * is on the same line, and sets the selection to just the current
  * cursor position, if there was a valid selection.
  * The line heights and offsets are not recalculated.
  */
 void view_notify_delete_text(ledit_view *view, size_t line, size_t index, size_t len);
 
 /*
  * Notify the view that a line has been appended after line 'line'.
  * This adjusts the cursor position if necessary and sets the selection
  * to just the current cursor position, if there was a valid selection.
  * The line heights and offsets are not recalculated.
  */
 void view_notify_append_line(ledit_view *view, size_t line);
 
 /*
  * Notify the view that all lines from 'index1' to 'index2' (inclusive)
  * have been deleted.
  * This adjusts the cursor position if necessary and sets the selection
  * to just the current cursor position, if there was a valid selection.
  * The line heights and offsets are not recalculated.
  */
 void view_notify_delete_lines(ledit_view *view, size_t index1, size_t index2);
 
 /*
  * Destroy a view and its window.
  */
 void view_destroy(ledit_view *view);
 
 /*
  * Perform cleanup of global data.
  */
 void view_cleanup(void);
 
 /*
  * Set a cursor highlight on the character at line 'line' and
  * byte position 'index'.
  */
 void view_set_line_cursor_attrs(ledit_view *view, size_t line, size_t index);
 
 /*
  * Remove cursor highlight from line 'line'.
  */
 void view_wipe_line_cursor_attrs(ledit_view *view, size_t line);
 
 /*
  * Recalculate the height of line 'line'.
  * If it has changed, the offsets of all following lines are recalculated.
  */
 void view_recalc_line(ledit_view *view, size_t line);
 
 /*
  * Recalculate the height and offset of all lines starting at 'line'.
  * If 'line' is 0, the offset is set to 0.
  */
 void view_recalc_from_line(ledit_view *view, size_t line);
 
 /*
  * Shortcut for recalculating all lines starting at 0.
  */
 void view_recalc_all_lines(ledit_view *view);
 
 /*
  * The cursor movement functions here logically belong to the buffer,
  * but they use various unicode attributes that pango exposes, so
  * they have to be here as long as no separate library for unicode
  * processing is used.
  */
 
 /*
  * Get the line and byte position of the cursor position 'num' positions
  * after the position at line 'line' and byte position 'byte'. The new
  * position is returned in 'line_ret' and 'byte_ret'.
  * If multiline is non-zero, the new position may be on a different line.
  * Otherwise, it is at most the length of the given line.
  * A newline counts as one position.
  */
 void view_next_cursor_pos(
     ledit_view *view,
     size_t line, size_t byte,
     int num, int multiline,
     size_t *line_ret, size_t *byte_ret
 );
 
 /*
  * Get the line and byte position of the cursor position 'num' positions
  * before the position at line 'line' and byte position 'byte'. The new
  * position is returned in 'line_ret' and 'byte_ret'.
  * If multiline is non-zero, the new position may be on a different line.
  * Otherwise, it is never earlier than position 0 on the given line.
  * A newline counts as one position.
  */
 void view_prev_cursor_pos(
     ledit_view *view,
     size_t line, size_t byte,
     int num, int multiline,
     size_t *line_ret, size_t *byte_ret
 );
 
 /*
  * The next 6 functions all return a line, a byte position, and a
  * "real byte position". In the case of the "*prev*" functions, it
  * is actually the same as the normal byte position (it is just
  * returned to keep the interface the same), but in the case of the
  * "*next*" functions, it can be  different. For instance, when
  * moving forward to the end of a word, the normal byte index will
  * be before the last cursor of the word (i.e. the position of the
  * cursor highlight in normal mode), while the real byte index is
  * right after the word, so it can be used for deleting to the end
  * of the word.
  */
 
 /*
  * Words are defined by unicode semantics (as interpreted by pango),
  * while bigwords are simply blocks of non-whitespace characters.
  */
 
 void view_next_word(
     ledit_view *view, size_t line, size_t byte, int num_repeat,
     size_t *line_ret, size_t *byte_ret, size_t *real_byte_ret
 );
 void view_next_word_end(
     ledit_view *view, size_t line, size_t byte, int num_repeat,
     size_t *line_ret, size_t *byte_ret, size_t *real_byte_ret
 );
 void view_next_bigword(
     ledit_view *view, size_t line, size_t byte, int num_repeat,
     size_t *line_ret, size_t *byte_ret, size_t *real_byte_ret
 );
 void view_next_bigword_end(
     ledit_view *view, size_t line, size_t byte, int num_repeat,
     size_t *line_ret, size_t *byte_ret, size_t *real_byte_ret
 );
 void view_prev_word(
     ledit_view *view, size_t line, size_t byte, int num_repeat,
     size_t *line_ret, size_t *byte_ret, size_t *real_byte_ret
 );
 void view_prev_bigword(
     ledit_view *view, size_t line, size_t byte, int num_repeat,
     size_t *line_ret, size_t *byte_ret, size_t *real_byte_ret
 );
 
 /*
  * Get the byte position of the next non-whitespace character starting at
  * 'byte' (including 'byte' itself), or the length of the line if there is
  * no further non-whitespace character.
  */
 size_t view_line_next_non_whitespace(ledit_view *view, size_t line, size_t byte);
 
 /*
  * Get the byte boundary of the softline at line 'line' and byte position 'pos'.
  */
 void view_get_pos_softline_bounds(
     ledit_view *view, size_t line, size_t pos,
     size_t *start_byte_ret, size_t *end_byte_ret
 );
 
 /*
  * Get the byte boundary of the softline with index 'softline'
  * in the hardline 'line'.
  */
 void view_get_softline_bounds(
     ledit_view *view, size_t line, int softline,
     size_t *start_byte_ret, size_t *end_byte_ret
 );
 
 /*
  * Get the number of softlines in line 'line'.
  */
 int view_get_softline_count(ledit_view *view, size_t line);
 
 /*
  * Get the softline index at hardline 'line' and byte position 'pos'.
  */
 int view_pos_to_softline(ledit_view *view, size_t line, size_t pos);
 
 /*
  * Get the pixel position and height of the cursor on hardline 'line'
  * at byte position 'pos'.
  */
 void view_get_cursor_pixel_pos(ledit_view *view, size_t line, size_t pos, int *x_ret, int *y_ret, int *h_ret);
 
 /*
  * Get the byte index of the cursor if it is moved visually 'movement'
  * positions from the position as line 'line' and byte position 'pos',
  * where a negative number is to the left and a positive number to the
  * right. 
  * If 'prev_index_ret' is not NULL, the previous valid cursor position
  * is written to it - this is used in normal mode to move back one
  * position if the cursor is at the end of the line. For some reason,
  * using 'view_get_legal_normal_pos' doesn't work here. I still need
  * to figure out why.
  */
 size_t view_move_cursor_visually(ledit_view *view, size_t line, size_t pos, int movement, size_t *prev_index_ret);
 
 /*
  * Convert a line index and byte position to an x position and softline
  * index. The x position is in pango units, not pixels.
  * In normal mode, the middle of the character is returned instead of the
  * beginning.
  */
 void view_pos_to_x_softline(ledit_view *view, size_t line, size_t pos, int *x_ret, int *softline_ret);
 
 /*
  * Convert a line index, softline index, and x position (in pango units,
  * not pixels) to a byte position.
  * In insert mode, the returned byte position is the closest cursor
  * position. In normal mode, it is simply the beginning of the character
  * (or, rather, grapheme) that the x position was on, regardless of where
  * on that character the position was.
  */
 size_t view_x_softline_to_pos(ledit_view *view, size_t line, int x, int softline);
 
 /*
  * Get a legal normal mode position, i.e. move back one cursor position
  * if 'pos' is at the very end of the line.
  */
 size_t view_get_legal_normal_pos(ledit_view *view, size_t line, size_t pos);
 
 /*
  * Delete a range according to a delete_mode.
  * The line and byte indeces do not need to be sorted (in fact, they often
  * shouldn't be, as shown in the next sentence).
  * If 'delmode' is DELETE_HARDLINE or DELETE_SOFTLINE, 'line_index1' and
  * 'byte_index1' are used to determine where the cursor should be after
  * the deletion. This new position is written to 'new_line_ret' and
  * 'new_byte_ret'.
  * If 'delmode' is DELETE_SOFTLINE, the byte indeces are additionally used
  * to determine which softlines the range bounds are on.
  * Both line deletion modes make sure that there is at least one line left
  * in the buffer afterwards, although it may have its text deleted.
  * If 'delmode' is DELETE_CHAR, the exact specified range is deleted, and
  * the new line and byte are simply the beginning of the range.
  * The deleted text is written to 'text_ret'.
  * In normal mode, the new cursor index is always at a valid normal mode
  * position.
  * All return arguments may be NULL.
  * The deletion is added to the undo stack with 'start_undo_group'
  * specifying whether a new undo group should be started.
  * The start cursor position for the undo stack is taken directly from
  * the view's current position. The end cursor position is the same as
  * what is returned in 'new_line_ret' and 'new_byte_ret', except that it
  * is set before calling 'view_get_legal_normal_pos'.
  * If different cursor positions are needed, call
  * 'undo_change_last_cur_range' afterwards.
  * This function does not recalculate the line heights or offsets.
  */
 void view_delete_range_base(
     ledit_view *view,
     enum delete_mode delmode, int start_undo_group,
     size_t line_index1, size_t byte_index1,
     size_t line_index2, size_t byte_index2,
     size_t *new_line_ret, size_t *new_byte_ret,
     txtbuf *text_ret
 );
 
 /*
  * Same as 'view_delete_range_base', but the line heights and offsets of
  * all views are recalculated afterwards.
  */
 void view_delete_range(
     ledit_view *view,
     enum delete_mode delmode, int start_undo_group,
     size_t line_index1, size_t byte_index1,
     size_t line_index2, size_t byte_index2,
     size_t *new_line_ret, size_t *new_byte_ret,
     txtbuf *text_ret
 );
 
 /*
  * Resize the size of the textview, i.e. resize the line widths
  * and update all scrolling related data.
  * 'data' is the view, but is given as a void pointer so the
  * function can be used as a callback.
  */
 void view_resize_textview(void *data);
 
 /*
  * Scroll to the given pixel offset.
  * The given offset is sanity-checked so new illegal positions can result.
  */
 void view_scroll(ledit_view *view, long new_offset);
 
 /*
  * Get the position nearest to 'line' and 'byte' that is currently shown
  * on screen.
  */
 void view_get_nearest_legal_pos(
     ledit_view *view,
     size_t line, size_t byte,
     /*int snap_to_nearest, int snap_middle, FIXME: take these parameters */
     size_t *line_ret, size_t *byte_ret
 );
 
 /*
  * Convert pixel coordinates to line and byte indeces. The pixel coordinates
  * are relative to the current textview.
  * If 'snap_to_nearest' is set, but grapheme boundary nearest to the position
  * is returned. Otherwise, the start position of the grapheme under the position
  * is returned.
  */
 void view_xy_to_line_byte(ledit_view *view, int x, int y, int snap_to_nearest, size_t *line_ret, size_t *byte_ret);
 
 /*
  * Scroll so that the given cursor position is at the very top of the view.
  * Note that this may not be entirely true since the final position is
  * sanity-checked to be within the scroll bounds.
  */
 void view_scroll_to_pos_top(ledit_view *view, size_t line, size_t byte);
 
 /*
  * Scroll so that the given cursor position is at the very bottom of the view.
  * Note that this may not be entirely true since the final position is
  * sanity-checked to be within the scroll bounds.
  */
 void view_scroll_to_pos_bottom(ledit_view *view, size_t line, size_t byte);
 
 /*
  * Scroll so that the current cursor position is visible on screen.
  */
 void view_ensure_cursor_shown(ledit_view *view);
 
 /*
  * Clear the selection.
  */
 void view_wipe_selection(ledit_view *view);
 
 /*
  * Set the selection to the given range.
  * The range does not need to be sorted.
  */
 void view_set_selection(ledit_view *view, size_t line1, size_t byte1, size_t line2, size_t byte2);
 
 /*
  * Redraw the view.
  * This only redraws if the redraw bit of the view or window are set.
  * This should all be set automatically.
  */
 void view_redraw(ledit_view *view, size_t lang_index);
 /* FIXME: kind of ugly to pass lang_index here, but the window needs it - maybe store centrally somewhere? */
 
 /*
  * Perform up to num undo steps.
  * The cursor position of the view is set to the stored position
  * in the undo stack.
  * The line heights and offsets are recalculated.
  */
 void view_undo(ledit_view *view, int num);
 
 /*
  * Perform up to num redo steps.
  * The cursor position of the view is set to the stored position
  * in the undo stack.
  * The line heights and offsets are recalculated.
  */
 void view_redo(ledit_view *view, int num);
 
 /*
  * Paste the X11 clipboard at the current cursor position.
  */
 void view_paste_clipboard(ledit_view *view);
 
 /*
  * Paste the X11 primary selection at the current cursor position.
  */
 void view_paste_primary(ledit_view *view);
 
 #endif