mirrors/mc
1
0
Fork 0
mirror of https://github.com/MidnightCommander/mc synced 2025-03-29 11:13:11 +03:00
Code Issues Packages Projects Releases Wiki Activity

Rename mcview_t back to WView to be consistent with other widget names.

Browse Source
This commit is contained in:
Andrew Borodin 2015-08-24 19:21:00 +03:00 committed by Slava Zanko
parent db0412598e
commit bff225c5ff
18 changed files with 213 additions and 215 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/filemanager/ext.c
View File

@ -366,7 +366,7 @@ exec_extension_view (void *target, char *cmd, const vfs_path_t * filename_vpath,
if (target == NULL)
mcview_viewer (cmd, filename_vpath, start_line, 0, 0);
else
mcview_load ((mcview_t *) target, cmd, vfs_path_as_str (filename_vpath), start_line, 0, 0);
mcview_load ((WView *) target, cmd, vfs_path_as_str (filename_vpath), start_line, 0, 0);
if (changed_hex_mode && !mcview_altered_hex_mode)
mcview_default_hex_mode = def_hex_mode;

2
src/filemanager/layout.c
View File

@ -1020,7 +1020,7 @@ set_display_type (int num, panel_view_mode_t type)
else
file_name = "";
mcview_load ((struct mcview_struct *) new_widget, 0, file_name, 0, 0, 0);
mcview_load ((struct WView *) new_widget, 0, file_name, 0, 0, 0);
break;
default:

36
src/viewer/actions_cmd.c
View File

@ -35,7 +35,7 @@
/*
The functions in this section can be bound to hotkeys. They are all
of the same type (taking a pointer to mcview_t as parameter and
of the same type (taking a pointer to WView as parameter and
returning void). TODO: In the not-too-distant future, these commands
will become fully configurable, like they already are in the
internal editor. By convention, all the function names end in
@ -83,7 +83,7 @@
/* --------------------------------------------------------------------------------------------- */
static void
mcview_remove_ext_script (mcview_t * view)
mcview_remove_ext_script (WView * view)
{
if (view->ext_script != NULL)
{
@ -97,7 +97,7 @@ mcview_remove_ext_script (mcview_t * view)
/* Both views */
static void
mcview_search (mcview_t * view, gboolean start_search)
mcview_search (WView * view, gboolean start_search)
{
off_t want_search_start = view->search_start;
@ -130,7 +130,7 @@ mcview_search (mcview_t * view, gboolean start_search)
/* --------------------------------------------------------------------------------------------- */
static void
mcview_continue_search_cmd (mcview_t * view)
mcview_continue_search_cmd (WView * view)
{
if (view->last_search_string != NULL)
mcview_search (view, FALSE);
@ -187,7 +187,7 @@ mcview_continue_search_cmd (mcview_t * view)
static void
mcview_hook (void *v)
{
mcview_t *view = (mcview_t *) v;
WView *view = (WView *) v;
WPanel *panel;
/* If the user is busy typing, wait until he finishes to update the
@ -217,7 +217,7 @@ mcview_hook (void *v)
/* --------------------------------------------------------------------------------------------- */
static cb_ret_t
mcview_handle_editkey (mcview_t * view, int key)
mcview_handle_editkey (WView * view, int key)
{
struct hexedit_change_node *node;
int byte_val;
@ -284,7 +284,7 @@ mcview_handle_editkey (mcview_t * view, int key)
/* --------------------------------------------------------------------------------------------- */
static void
mcview_load_next_prev_init (mcview_t * view)
mcview_load_next_prev_init (WView * view)
{
if (mc_global.mc_run_mode != MC_RUN_VIEWER)
{
@ -329,7 +329,7 @@ mcview_load_next_prev_init (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
static void
mcview_scan_for_file (mcview_t * view, int direction)
mcview_scan_for_file (WView * view, int direction)
{
int i;
@ -349,7 +349,7 @@ mcview_scan_for_file (mcview_t * view, int direction)
/* --------------------------------------------------------------------------------------------- */
static void
mcview_load_next_prev (mcview_t * view, int direction)
mcview_load_next_prev (WView * view, int direction)
{
dir_list *dir;
int *dir_idx;
@ -382,7 +382,7 @@ mcview_load_next_prev (mcview_t * view, int direction)
/* --------------------------------------------------------------------------------------------- */
static cb_ret_t
mcview_execute_cmd (mcview_t * view, unsigned long command)
mcview_execute_cmd (WView * view, unsigned long command)
{
int res = MSG_HANDLED;
@ -544,7 +544,7 @@ mcview_execute_cmd (mcview_t * view, unsigned long command)
/* --------------------------------------------------------------------------------------------- */
/** Both views */
static cb_ret_t
mcview_handle_key (mcview_t * view, int key)
mcview_handle_key (WView * view, int key)
{
unsigned long command;
@ -586,11 +586,11 @@ mcview_handle_key (mcview_t * view, int key)
static inline void
mcview_adjust_size (WDialog * h)
{
mcview_t *view;
WView *view;
WButtonBar *b;
/* Look up the viewer and the buttonbar, we assume only two widgets here */
view = (mcview_t *) find_widget_type (h, mcview_callback);
view = (WView *) find_widget_type (h, mcview_callback);
b = find_buttonbar (h);
widget_set_size (WIDGET (view), 0, 0, LINES - 1, COLS);
@ -604,7 +604,7 @@ mcview_adjust_size (WDialog * h)
/* --------------------------------------------------------------------------------------------- */
static gboolean
mcview_ok_to_quit (mcview_t * view)
mcview_ok_to_quit (WView * view)
{
int r;
@ -647,7 +647,7 @@ mcview_ok_to_quit (mcview_t * view)
cb_ret_t
mcview_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void *data)
{
mcview_t *view = (mcview_t *) w;
WView *view = (WView *) w;
cb_ret_t i;
mcview_compute_areas (view);
@ -715,7 +715,7 @@ cb_ret_t
mcview_dialog_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void *data)
{
WDialog *h = DIALOG (w);
mcview_t *view;
WView *view;
switch (msg)
{
@ -733,13 +733,13 @@ mcview_dialog_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm,
if (data != NULL)
return send_message (data, NULL, MSG_ACTION, parm, NULL);
view = (mcview_t *) find_widget_type (h, mcview_callback);
view = (WView *) find_widget_type (h, mcview_callback);
return mcview_execute_cmd (view, parm);
}
return MSG_NOT_HANDLED;
case MSG_VALIDATE:
view = (mcview_t *) find_widget_type (h, mcview_callback);
view = (WView *) find_widget_type (h, mcview_callback);
h->state = DLG_ACTIVE; /* don't stop the dialog before final decision */
if (mcview_ok_to_quit (view))
h->state = DLG_CLOSED;

35
src/viewer/ascii.c
View File

@ -204,7 +204,7 @@
/* TODO: These methods shouldn't be necessary, see ticket 3257 */
static int
mcview_wcwidth (const mcview_t * view, int c)
mcview_wcwidth (const WView * view, int c)
{
#ifdef HAVE_CHARSET
if (view->utf8)
@ -224,7 +224,7 @@ mcview_wcwidth (const mcview_t * view, int c)
/* --------------------------------------------------------------------------------------------- */
static gboolean
mcview_ismark (const mcview_t * view, int c)
mcview_ismark (const WView * view, int c)
{
#ifdef HAVE_CHARSET
if (view->utf8)
@ -240,7 +240,7 @@ mcview_ismark (const mcview_t * view, int c)
/* actually is_non_spacing_mark_or_enclosing_mark */
static gboolean
mcview_is_non_spacing_mark (const mcview_t * view, int c)
mcview_is_non_spacing_mark (const WView * view, int c)
{
#ifdef HAVE_CHARSET
if (view->utf8)
@ -262,7 +262,7 @@ mcview_is_non_spacing_mark (const mcview_t * view, int c)
#if 0
static gboolean
mcview_is_spacing_mark (const mcview_t * view, int c)
mcview_is_spacing_mark (const WView * view, int c)
{
#ifdef HAVE_CHARSET
if (view->utf8)
@ -278,7 +278,7 @@ mcview_is_spacing_mark (const mcview_t * view, int c)
/* --------------------------------------------------------------------------------------------- */
static gboolean
mcview_isprint (const mcview_t * view, int c)
mcview_isprint (const WView * view, int c)
{
#ifdef HAVE_CHARSET
if (!view->utf8)
@ -294,7 +294,7 @@ mcview_isprint (const mcview_t * view, int c)
/* --------------------------------------------------------------------------------------------- */
static int
mcview_char_display (const mcview_t * view, int c, char *s)
mcview_char_display (const WView * view, int c, char *s)
{
#ifdef HAVE_CHARSET
if (mc_global.utf8_display)
@ -345,7 +345,7 @@ mcview_char_display (const mcview_t * view, int c, char *s)
* TODO: move it to lower layers (datasource.c)?
*/
static gboolean
mcview_get_next_char (mcview_t * view, mcview_state_machine_t * state, int *c)
mcview_get_next_char (WView * view, mcview_state_machine_t * state, int *c)
{
/* Pretend EOF if we reached force_max */
if (view->force_max >= 0 && state->offset >= view->force_max)
@ -394,8 +394,7 @@ mcview_get_next_char (mcview_t * view, mcview_state_machine_t * state, int *c)
* color can be null if the caller doesn't care.
*/
static gboolean
mcview_get_next_maybe_nroff_char (mcview_t * view, mcview_state_machine_t * state, int *c,
int *color)
mcview_get_next_maybe_nroff_char (WView * view, mcview_state_machine_t * state, int *c, int *color)
{
mcview_state_machine_t state_after_nroff;
int c2, c3;
@ -478,7 +477,7 @@ mcview_get_next_maybe_nroff_char (mcview_t * view, mcview_state_machine_t * stat
* @return the number of entries placed in cs, or 0 on EOF
*/
static int
mcview_next_combining_char_sequence (mcview_t * view, mcview_state_machine_t * state, int *cs,
mcview_next_combining_char_sequence (WView * view, mcview_state_machine_t * state, int *cs,
int clen, int *color)
{
int i = 1;
@ -577,7 +576,7 @@ mcview_next_combining_char_sequence (mcview_t * view, mcview_state_machine_t * s
* @return the number of rows, that is, 0 if we were already at EOF, otherwise 1
*/
static int
mcview_display_line (mcview_t * view, mcview_state_machine_t * state, int row,
mcview_display_line (WView * view, mcview_state_machine_t * state, int row,
gboolean * paragraph_ended, off_t * linewidth)
{
const screen_dimen left = view->data_area.left;
@ -772,7 +771,7 @@ mcview_display_line (mcview_t * view, mcview_state_machine_t * state, int row,
* viewport, it's not counted how many more lines the paragraph would occupy
*/
static int
mcview_display_paragraph (mcview_t * view, mcview_state_machine_t * state, int row)
mcview_display_paragraph (WView * view, mcview_state_machine_t * state, int row)
{
const screen_dimen height = view->data_area.height;
int lines = 0;
@ -809,7 +808,7 @@ mcview_display_paragraph (mcview_t * view, mcview_state_machine_t * state, int r
* vertical position, in that case move to its last row.
*/
static void
mcview_wrap_fixup (mcview_t * view)
mcview_wrap_fixup (WView * view)
{
int lines = view->dpy_paragraph_skip_lines;
@ -853,7 +852,7 @@ mcview_wrap_fixup (mcview_t * view)
* case dpy_state_top is invalid and we need to recompute first.
*/
void
mcview_display_text (mcview_t * view)
mcview_display_text (WView * view)
{
const screen_dimen left = view->data_area.left;
const screen_dimen top = view->data_area.top;
@ -927,7 +926,7 @@ mcview_display_text (mcview_t * view)
* the bottom of mcview_ascii_move_up()) which invalidate this value.
*/
void
mcview_ascii_move_down (mcview_t * view, off_t lines)
mcview_ascii_move_down (WView * view, off_t lines)
{
while (lines-- != 0)
{
@ -976,7 +975,7 @@ mcview_ascii_move_down (mcview_t * view, off_t lines)
* changes, we don't want to endlessly consume a file of maybe full of zeros upon moving upwards.
*/
void
mcview_ascii_move_up (mcview_t * view, off_t lines)
mcview_ascii_move_up (WView * view, off_t lines)
{
if (!view->text_wrap_mode)
{
@ -1026,7 +1025,7 @@ mcview_ascii_move_up (mcview_t * view, off_t lines)
/* --------------------------------------------------------------------------------------------- */
void
mcview_ascii_moveto_bol (mcview_t * view)
mcview_ascii_moveto_bol (WView * view)
{
if (!view->text_wrap_mode)
view->dpy_text_column = 0;
@ -1035,7 +1034,7 @@ mcview_ascii_moveto_bol (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
void
mcview_ascii_moveto_eol (mcview_t * view)
mcview_ascii_moveto_eol (WView * view)
{
if (!view->text_wrap_mode)
{

6
src/viewer/coord_cache.c
View File

@ -141,7 +141,7 @@ mcview_coord_cache_entry_less_nroff (const coord_cache_entry_t * a, const coord_
* smaller than ''coord'', according to the criterion ''sort_by''. */
static inline size_t
mcview_ccache_find (mcview_t * view, const coord_cache_entry_t * coord, cmp_func_t cmp_func)
mcview_ccache_find (WView * view, const coord_cache_entry_t * coord, cmp_func_t cmp_func)
{
size_t base = 0;
size_t limit = view->coord_cache->size;
@ -208,7 +208,7 @@ coord_cache_free (coord_cache_t * cache)
#ifdef MC_ENABLE_DEBUGGING_CODE
void
mcview_ccache_dump (mcview_t * view)
mcview_ccache_dump (WView * view)
{
FILE *f;
off_t offset, line, column, nextline_offset, filesize;
@ -282,7 +282,7 @@ mcview_ccache_dump (mcview_t * view)
*/
void
mcview_ccache_lookup (mcview_t * view, coord_cache_entry_t * coord, enum ccache_type lookup_what)
mcview_ccache_lookup (WView * view, coord_cache_entry_t * coord, enum ccache_type lookup_what)
{
size_t i;
coord_cache_t *cache;

32
src/viewer/datasource.c
View File

@ -74,7 +74,7 @@
/* --------------------------------------------------------------------------------------------- */
static void
mcview_set_datasource_stdio_pipe (mcview_t * view, mc_pipe_t * p)
mcview_set_datasource_stdio_pipe (WView * view, mc_pipe_t * p)
{
p->out.len = MC_PIPE_BUFSIZE;
p->out.null_term = FALSE;
@ -92,7 +92,7 @@ mcview_set_datasource_stdio_pipe (mcview_t * view, mc_pipe_t * p)
/* --------------------------------------------------------------------------------------------- */
void
mcview_set_datasource_none (mcview_t * view)
mcview_set_datasource_none (WView * view)
{
view->datasource = DS_NONE;
}
@ -100,7 +100,7 @@ mcview_set_datasource_none (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
off_t
mcview_get_filesize (mcview_t * view)
mcview_get_filesize (WView * view)
{
switch (view->datasource)
{
@ -124,7 +124,7 @@ mcview_get_filesize (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
void
mcview_update_filesize (mcview_t * view)
mcview_update_filesize (WView * view)
{
if (view->datasource == DS_FILE)
{
@ -137,7 +137,7 @@ mcview_update_filesize (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
char *
mcview_get_ptr_file (mcview_t * view, off_t byte_index)
mcview_get_ptr_file (WView * view, off_t byte_index)
{
#ifdef HAVE_ASSERT_H
assert (view->datasource == DS_FILE);
@ -152,7 +152,7 @@ mcview_get_ptr_file (mcview_t * view, off_t byte_index)
/* --------------------------------------------------------------------------------------------- */
int
mcview_get_utf (mcview_t * view, off_t byte_index, int *char_length, gboolean * result)
mcview_get_utf (WView * view, off_t byte_index, int *char_length, gboolean * result)
{
gchar *str = NULL;
int res = -1;
@ -223,7 +223,7 @@ mcview_get_utf (mcview_t * view, off_t byte_index, int *char_length, gboolean *
/* --------------------------------------------------------------------------------------------- */
char *
mcview_get_ptr_string (mcview_t * view, off_t byte_index)
mcview_get_ptr_string (WView * view, off_t byte_index)
{
#ifdef HAVE_ASSERT_H
assert (view->datasource == DS_STRING);
@ -236,7 +236,7 @@ mcview_get_ptr_string (mcview_t * view, off_t byte_index)
/* --------------------------------------------------------------------------------------------- */
gboolean
mcview_get_byte_string (mcview_t * view, off_t byte_index, int *retval)
mcview_get_byte_string (WView * view, off_t byte_index, int *retval)
{
char *p;
@ -255,7 +255,7 @@ mcview_get_byte_string (mcview_t * view, off_t byte_index, int *retval)
/* --------------------------------------------------------------------------------------------- */
gboolean
mcview_get_byte_none (mcview_t * view, off_t byte_index, int *retval)
mcview_get_byte_none (WView * view, off_t byte_index, int *retval)
{
(void) &view;
(void) byte_index;
@ -272,7 +272,7 @@ mcview_get_byte_none (mcview_t * view, off_t byte_index, int *retval)
/* --------------------------------------------------------------------------------------------- */
void
mcview_set_byte (mcview_t * view, off_t offset, byte b)
mcview_set_byte (WView * view, off_t offset, byte b)
{
(void) &b;
#ifndef HAVE_ASSERT_H
@ -289,7 +289,7 @@ mcview_set_byte (mcview_t * view, off_t offset, byte b)
/*static */
void
mcview_file_load_data (mcview_t * view, off_t byte_index)
mcview_file_load_data (WView * view, off_t byte_index)
{
off_t blockoffset;
ssize_t res;
@ -340,7 +340,7 @@ mcview_file_load_data (mcview_t * view, off_t byte_index)
/* --------------------------------------------------------------------------------------------- */
void
mcview_close_datasource (mcview_t * view)
mcview_close_datasource (WView * view)
{
switch (view->datasource)
{
@ -379,7 +379,7 @@ mcview_close_datasource (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
void
mcview_set_datasource_file (mcview_t * view, int fd, const struct stat *st)
mcview_set_datasource_file (WView * view, int fd, const struct stat *st)
{
view->datasource = DS_FILE;
view->ds_file_fd = fd;
@ -393,7 +393,7 @@ mcview_set_datasource_file (mcview_t * view, int fd, const struct stat *st)
/* --------------------------------------------------------------------------------------------- */
gboolean
mcview_load_command_output (mcview_t * view, const char *command)
mcview_load_command_output (WView * view, const char *command)
{
mc_pipe_t *pipe;
GError *error = NULL;
@ -424,7 +424,7 @@ mcview_load_command_output (mcview_t * view, const char *command)
/* --------------------------------------------------------------------------------------------- */
void
mcview_set_datasource_vfs_pipe (mcview_t * view, int fd)
mcview_set_datasource_vfs_pipe (WView * view, int fd)
{
#ifdef HAVE_ASSERT_H
assert (fd != -1);
@ -438,7 +438,7 @@ mcview_set_datasource_vfs_pipe (mcview_t * view, int fd)
/* --------------------------------------------------------------------------------------------- */
void
mcview_set_datasource_string (mcview_t * view, const char *s)
mcview_set_datasource_string (WView * view, const char *s)
{
view->datasource = DS_STRING;
view->ds_string_len = strlen (s);

4
src/viewer/dialogs.c
View File

@ -74,7 +74,7 @@ mcview_search_options_t mcview_search_options = {
/* --------------------------------------------------------------------------------------------- */
gboolean
mcview_dialog_search (mcview_t * view)
mcview_dialog_search (WView * view)
{
char *exp = NULL;
int qd_result;
@ -165,7 +165,7 @@ mcview_dialog_search (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
gboolean
mcview_dialog_goto (mcview_t * view, off_t * offset)
mcview_dialog_goto (WView * view, off_t * offset)
{
typedef enum
{

20
src/viewer/display.c
View File

@ -76,7 +76,7 @@ static enum ruler_type
/** Define labels and handlers for functional keys */
static void
mcview_set_buttonbar (mcview_t * view)
mcview_set_buttonbar (WView * view)
{
WDialog *h = WIDGET (view)->owner;
WButtonBar *b = find_buttonbar (h);
@ -126,7 +126,7 @@ mcview_set_buttonbar (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
static void
mcview_display_percent (mcview_t * view, off_t p)
mcview_display_percent (WView * view, off_t p)
{
int percent;
@ -146,7 +146,7 @@ mcview_display_percent (mcview_t * view, off_t p)
/* --------------------------------------------------------------------------------------------- */
static void
mcview_display_status (mcview_t * view)
mcview_display_status (WView * view)
{
const screen_dimen top = view->status_area.top;
const screen_dimen left = view->status_area.left;
@ -199,7 +199,7 @@ mcview_display_status (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
void
mcview_update (mcview_t * view)
mcview_update (WView * view)
{
static int dirt_limit = 1;
@ -245,7 +245,7 @@ mcview_update (mcview_t * view)
/** Displays as much data from view->dpy_start as fits on the screen */
void
mcview_display (mcview_t * view)
mcview_display (WView * view)
{
if (view->hex_mode)
{
@ -261,7 +261,7 @@ mcview_display (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
void
mcview_compute_areas (mcview_t * view)
mcview_compute_areas (WView * view)
{
struct area view_area;
screen_dimen height, rest, y;
@ -317,7 +317,7 @@ mcview_compute_areas (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
void
mcview_update_bytes_per_line (mcview_t * view)
mcview_update_bytes_per_line (WView * view)
{
const screen_dimen cols = view->data_area.width;
int bytes;
@ -337,7 +337,7 @@ mcview_update_bytes_per_line (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
void
mcview_display_toggle_ruler (mcview_t * view)
mcview_display_toggle_ruler (WView * view)
{
static const enum ruler_type next[3] =
{
@ -357,7 +357,7 @@ mcview_display_toggle_ruler (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
void
mcview_display_clean (mcview_t * view)
mcview_display_clean (WView * view)
{
Widget *w = WIDGET (view);
@ -370,7 +370,7 @@ mcview_display_clean (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
void
mcview_display_ruler (mcview_t * view)
mcview_display_ruler (WView * view)
{
static const char ruler_chars[] = "|----*----";
const screen_dimen top = view->ruler_area.top;

14
src/viewer/growbuf.c
View File

@ -62,7 +62,7 @@
/* --------------------------------------------------------------------------------------------- */
void
mcview_growbuf_init (mcview_t * view)
mcview_growbuf_init (WView * view)
{
view->growbuf_in_use = TRUE;
view->growbuf_blockptr = g_ptr_array_new ();
@ -73,7 +73,7 @@ mcview_growbuf_init (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
void
mcview_growbuf_done (mcview_t * view)
mcview_growbuf_done (WView * view)
{
view->growbuf_finished = TRUE;
@ -92,7 +92,7 @@ mcview_growbuf_done (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
void
mcview_growbuf_free (mcview_t * view)
mcview_growbuf_free (WView * view)
{
#ifdef HAVE_ASSERT_H
assert (view->growbuf_in_use);
@ -109,7 +109,7 @@ mcview_growbuf_free (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
off_t
mcview_growbuf_filesize (mcview_t * view)
mcview_growbuf_filesize (WView * view)
{
#ifdef HAVE_ASSERT_H
assert (view->growbuf_in_use);
@ -128,7 +128,7 @@ mcview_growbuf_filesize (mcview_t * view)
*/
void
mcview_growbuf_read_until (mcview_t * view, off_t ofs)
mcview_growbuf_read_until (WView * view, off_t ofs)
{
gboolean short_read = FALSE;
@ -249,7 +249,7 @@ mcview_growbuf_read_until (mcview_t * view, off_t ofs)
/* --------------------------------------------------------------------------------------------- */
gboolean
mcview_get_byte_growing_buffer (mcview_t * view, off_t byte_index, int *retval)
mcview_get_byte_growing_buffer (WView * view, off_t byte_index, int *retval)
{
char *p;
@ -276,7 +276,7 @@ mcview_get_byte_growing_buffer (mcview_t * view, off_t byte_index, int *retval)
/* --------------------------------------------------------------------------------------------- */
char *
mcview_get_ptr_growing_buffer (mcview_t * view, off_t byte_index)
mcview_get_ptr_growing_buffer (WView * view, off_t byte_index)
{
off_t pageno, pageindex;

10
src/viewer/hex.c
View File

@ -81,7 +81,7 @@ static const char hex_char[] = "0123456789ABCDEF";
*/
static mark_t
mcview_hex_calculate_boldflag (mcview_t * view, off_t from, struct hexedit_change_node *curr,
mcview_hex_calculate_boldflag (WView * view, off_t from, struct hexedit_change_node *curr,
gboolean force_changed)
{
return (from == view->hex_cursor) ? MARK_CURSOR
@ -94,7 +94,7 @@ mcview_hex_calculate_boldflag (mcview_t * view, off_t from, struct hexedit_chang
/* --------------------------------------------------------------------------------------------- */
void
mcview_display_hex (mcview_t * view)
mcview_display_hex (WView * view)
{
const screen_dimen top = view->data_area.top;
const screen_dimen left = view->data_area.left;
@ -376,7 +376,7 @@ mcview_display_hex (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
gboolean
mcview_hexedit_save_changes (mcview_t * view)
mcview_hexedit_save_changes (WView * view)
{
int answer = 0;
@ -439,7 +439,7 @@ mcview_hexedit_save_changes (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
void
mcview_toggle_hexedit_mode (mcview_t * view)
mcview_toggle_hexedit_mode (WView * view)
{
view->hexedit_mode = !view->hexedit_mode;
view->dpy_bbar_dirty = TRUE;
@ -449,7 +449,7 @@ mcview_toggle_hexedit_mode (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
void
mcview_hexedit_free_change_list (mcview_t * view)
mcview_hexedit_free_change_list (WView * view)
{
struct hexedit_change_node *curr, *next;

16
src/viewer/inlines.h
View File

@ -46,9 +46,9 @@ mcview_dimen_doz (screen_dimen a, screen_dimen b)
/* --------------------------------------------------------------------------------------------- */
/* {{{ Simple Primitive Functions for mcview_t }}} */
/* {{{ Simple Primitive Functions for WView }}} */
static inline gboolean
mcview_is_in_panel (mcview_t * view)
mcview_is_in_panel (WView * view)
{
return (view->dpy_frame_size != 0);
}
@ -56,7 +56,7 @@ mcview_is_in_panel (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
static inline gboolean
mcview_may_still_grow (mcview_t * view)
mcview_may_still_grow (WView * view)
{
return (view->growbuf_in_use && !view->growbuf_finished);
}
@ -75,7 +75,7 @@ mcview_already_loaded (off_t offset, off_t idx, size_t size)
/* --------------------------------------------------------------------------------------------- */
static inline gboolean
mcview_get_byte_file (mcview_t * view, off_t byte_index, int *retval)
mcview_get_byte_file (WView * view, off_t byte_index, int *retval)
{
#ifdef HAVE_ASSERT_H
assert (view->datasource == DS_FILE);
@ -96,7 +96,7 @@ mcview_get_byte_file (mcview_t * view, off_t byte_index, int *retval)
/* --------------------------------------------------------------------------------------------- */
static inline gboolean
mcview_get_byte (mcview_t * view, off_t offset, int *retval)
mcview_get_byte (WView * view, off_t offset, int *retval)
{
switch (view->datasource)
{
@ -120,7 +120,7 @@ mcview_get_byte (mcview_t * view, off_t offset, int *retval)
/* --------------------------------------------------------------------------------------------- */
static inline gboolean
mcview_get_byte_indexed (mcview_t * view, off_t base, off_t ofs, int *retval)
mcview_get_byte_indexed (WView * view, off_t base, off_t ofs, int *retval)
{
if (base <= OFFSETTYPE_MAX - ofs)
{
@ -134,7 +134,7 @@ mcview_get_byte_indexed (mcview_t * view, off_t base, off_t ofs, int *retval)
/* --------------------------------------------------------------------------------------------- */
static inline int
mcview_count_backspaces (mcview_t * view, off_t offset)
mcview_count_backspaces (WView * view, off_t offset)
{
int backspaces = 0;
int c;
@ -147,7 +147,7 @@ mcview_count_backspaces (mcview_t * view, off_t offset)
/* --------------------------------------------------------------------------------------------- */
static inline gboolean
mcview_is_nroff_sequence (mcview_t * view, off_t offset)
mcview_is_nroff_sequence (WView * view, off_t offset)
{
int c0, c1, c2;

149
src/viewer/internal.h
View File

@ -101,7 +101,7 @@ typedef struct
struct mcview_nroff_struct;
struct mcview_struct
struct WView
{
Widget widget;
@ -213,7 +213,7 @@ struct mcview_struct
typedef struct mcview_nroff_struct
{
mcview_t *view;
WView *view;
off_t index;
int char_length;
int current_char;
@ -242,105 +242,104 @@ cb_ret_t mcview_dialog_callback (Widget * w, Widget * sender, widget_msg_t msg,
void *data);
/* ascii.c: */
void mcview_display_text (mcview_t *);
void mcview_display_text (WView *);
void mcview_state_machine_init (mcview_state_machine_t *, off_t);
void mcview_ascii_move_down (mcview_t *, off_t);
void mcview_ascii_move_up (mcview_t *, off_t);
void mcview_ascii_moveto_bol (mcview_t *);
void mcview_ascii_moveto_eol (mcview_t *);
void mcview_ascii_move_down (WView *, off_t);
void mcview_ascii_move_up (WView *, off_t);
void mcview_ascii_moveto_bol (WView *);
void mcview_ascii_moveto_eol (WView *);
/* coord_cache.c: */
coord_cache_t *coord_cache_new (void);
void coord_cache_free (coord_cache_t * cache);
#ifdef MC_ENABLE_DEBUGGING_CODE
void mcview_ccache_dump (mcview_t * view);
void mcview_ccache_dump (WView * view);
#endif
void mcview_ccache_lookup (mcview_t * view, coord_cache_entry_t * coord,
enum ccache_type lookup_what);
void mcview_ccache_lookup (WView * view, coord_cache_entry_t * coord, enum ccache_type lookup_what);
/* datasource.c: */
void mcview_set_datasource_none (mcview_t *);
off_t mcview_get_filesize (mcview_t *);
void mcview_update_filesize (mcview_t * view);
char *mcview_get_ptr_file (mcview_t *, off_t);
char *mcview_get_ptr_string (mcview_t *, off_t);
int mcview_get_utf (mcview_t *, off_t, int *, gboolean *);
gboolean mcview_get_byte_string (mcview_t *, off_t, int *);
gboolean mcview_get_byte_none (mcview_t *, off_t, int *);
void mcview_set_byte (mcview_t *, off_t, byte);
void mcview_file_load_data (mcview_t *, off_t);
void mcview_close_datasource (mcview_t *);
void mcview_set_datasource_file (mcview_t *, int, const struct stat *);
gboolean mcview_load_command_output (mcview_t *, const char *);
void mcview_set_datasource_vfs_pipe (mcview_t *, int);
void mcview_set_datasource_string (mcview_t *, const char *);
void mcview_set_datasource_none (WView *);
off_t mcview_get_filesize (WView *);
void mcview_update_filesize (WView * view);
char *mcview_get_ptr_file (WView *, off_t);
char *mcview_get_ptr_string (WView *, off_t);
int mcview_get_utf (WView *, off_t, int *, gboolean *);
gboolean mcview_get_byte_string (WView *, off_t, int *);
gboolean mcview_get_byte_none (WView *, off_t, int *);
void mcview_set_byte (WView *, off_t, byte);
void mcview_file_load_data (WView *, off_t);
void mcview_close_datasource (WView *);
void mcview_set_datasource_file (WView *, int, const struct stat *);
gboolean mcview_load_command_output (WView *, const char *);
void mcview_set_datasource_vfs_pipe (WView *, int);
void mcview_set_datasource_string (WView *, const char *);
/* dialog.c: */
gboolean mcview_dialog_search (mcview_t * view);
gboolean mcview_dialog_goto (mcview_t * view, off_t * offset);
gboolean mcview_dialog_search (WView * view);
gboolean mcview_dialog_goto (WView * view, off_t * offset);
/* display.c: */
void mcview_update (mcview_t * view);
void mcview_display (mcview_t * view);
void mcview_compute_areas (mcview_t * view);
void mcview_update_bytes_per_line (mcview_t * view);
void mcview_display_toggle_ruler (mcview_t * view);
void mcview_display_clean (mcview_t * view);
void mcview_display_ruler (mcview_t * view);
void mcview_update (WView * view);
void mcview_display (WView * view);
void mcview_compute_areas (WView * view);
void mcview_update_bytes_per_line (WView * view);
void mcview_display_toggle_ruler (WView * view);
void mcview_display_clean (WView * view);
void mcview_display_ruler (WView * view);
/* growbuf.c: */
void mcview_growbuf_init (mcview_t * view);
void mcview_growbuf_done (mcview_t * view);
void mcview_growbuf_free (mcview_t * view);
off_t mcview_growbuf_filesize (mcview_t * view);
void mcview_growbuf_read_until (mcview_t * view, off_t p);
gboolean mcview_get_byte_growing_buffer (mcview_t * view, off_t p, int *);
char *mcview_get_ptr_growing_buffer (mcview_t * view, off_t p);
void mcview_growbuf_init (WView * view);
void mcview_growbuf_done (WView * view);
void mcview_growbuf_free (WView * view);
off_t mcview_growbuf_filesize (WView * view);
void mcview_growbuf_read_until (WView * view, off_t p);
gboolean mcview_get_byte_growing_buffer (WView * view, off_t p, int *);
char *mcview_get_ptr_growing_buffer (WView * view, off_t p);
/* hex.c: */
void mcview_display_hex (mcview_t * view);
gboolean mcview_hexedit_save_changes (mcview_t * view);
void mcview_toggle_hexedit_mode (mcview_t * view);
void mcview_hexedit_free_change_list (mcview_t * view);
void mcview_display_hex (WView * view);
gboolean mcview_hexedit_save_changes (WView * view);
void mcview_toggle_hexedit_mode (WView * view);
void mcview_hexedit_free_change_list (WView * view);
void mcview_enqueue_change (struct hexedit_change_node **, struct hexedit_change_node *);
/* lib.c: */
void mcview_toggle_magic_mode (mcview_t * view);
void mcview_toggle_wrap_mode (mcview_t * view);
void mcview_toggle_nroff_mode (mcview_t * view);
void mcview_toggle_hex_mode (mcview_t * view);
void mcview_init (mcview_t * view);
void mcview_done (mcview_t * view);
void mcview_select_encoding (mcview_t * view);
void mcview_set_codeset (mcview_t * view);
void mcview_show_error (mcview_t * view, const char *error);
off_t mcview_bol (mcview_t * view, off_t current, off_t limit);
off_t mcview_eol (mcview_t * view, off_t current, off_t limit);
void mcview_toggle_magic_mode (WView * view);
void mcview_toggle_wrap_mode (WView * view);
void mcview_toggle_nroff_mode (WView * view);
void mcview_toggle_hex_mode (WView * view);
void mcview_init (WView * view);
void mcview_done (WView * view);
void mcview_select_encoding (WView * view);
void mcview_set_codeset (WView * view);
void mcview_show_error (WView * view, const char *error);
off_t mcview_bol (WView * view, off_t current, off_t limit);
off_t mcview_eol (WView * view, off_t current, off_t limit);
char *mcview_get_title (const WDialog * h, size_t len);
int mcview_calc_percent (mcview_t * view, off_t p);
int mcview_calc_percent (WView * view, off_t p);
/* move.c */
void mcview_move_up (mcview_t *, off_t);
void mcview_move_down (mcview_t *, off_t);
void mcview_move_left (mcview_t *, off_t);
void mcview_move_right (mcview_t *, off_t);
void mcview_moveto_top (mcview_t *);
void mcview_moveto_bottom (mcview_t *);
void mcview_moveto_bol (mcview_t *);
void mcview_moveto_eol (mcview_t *);
void mcview_moveto_offset (mcview_t *, off_t);
void mcview_moveto (mcview_t *, off_t, off_t);
void mcview_coord_to_offset (mcview_t *, off_t *, off_t, off_t);
void mcview_offset_to_coord (mcview_t *, off_t *, off_t *, off_t);
void mcview_place_cursor (mcview_t *);
void mcview_moveto_match (mcview_t *);
void mcview_move_up (WView *, off_t);
void mcview_move_down (WView *, off_t);
void mcview_move_left (WView *, off_t);
void mcview_move_right (WView *, off_t);
void mcview_moveto_top (WView *);
void mcview_moveto_bottom (WView *);
void mcview_moveto_bol (WView *);
void mcview_moveto_eol (WView *);
void mcview_moveto_offset (WView *, off_t);
void mcview_moveto (WView *, off_t, off_t);
void mcview_coord_to_offset (WView *, off_t *, off_t, off_t);
void mcview_offset_to_coord (WView *, off_t *, off_t *, off_t);
void mcview_place_cursor (WView *);
void mcview_moveto_match (WView *);
/* nroff.c: */
int mcview__get_nroff_real_len (mcview_t * view, off_t, off_t p);
mcview_nroff_t *mcview_nroff_seq_new_num (mcview_t * view, off_t p);
mcview_nroff_t *mcview_nroff_seq_new (mcview_t * view);
int mcview__get_nroff_real_len (WView * view, off_t, off_t p);
mcview_nroff_t *mcview_nroff_seq_new_num (WView * view, off_t p);
mcview_nroff_t *mcview_nroff_seq_new (WView * view);
void mcview_nroff_seq_free (mcview_nroff_t **);
nroff_type_t mcview_nroff_seq_info (mcview_nroff_t *);
int mcview_nroff_seq_next (mcview_nroff_t *);
@ -350,7 +349,7 @@ int mcview_nroff_seq_prev (mcview_nroff_t *);
mc_search_cbret_t mcview_search_cmd_callback (const void *user_data, gsize char_offset,
int *current_char);
mc_search_cbret_t mcview_search_update_cmd_callback (const void *user_data, gsize char_offset);
void mcview_do_search (mcview_t * view, off_t want_search_start);
void mcview_do_search (WView * view, off_t want_search_start);
/*** inline functions ****************************************************************************/

26
src/viewer/lib.c
View File

@ -73,7 +73,7 @@ const off_t OFFSETTYPE_MAX = ((off_t) 1 << (OFF_T_BITWIDTH - 1)) - 1;
/* --------------------------------------------------------------------------------------------- */
void
mcview_toggle_magic_mode (mcview_t * view)
mcview_toggle_magic_mode (WView * view)
{
char *filename, *command;
dir_list *dir;
@ -104,7 +104,7 @@ mcview_toggle_magic_mode (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
void
mcview_toggle_wrap_mode (mcview_t * view)
mcview_toggle_wrap_mode (WView * view)
{
view->text_wrap_mode = !view->text_wrap_mode;
view->dpy_wrap_dirty = TRUE;
@ -115,7 +115,7 @@ mcview_toggle_wrap_mode (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
void
mcview_toggle_nroff_mode (mcview_t * view)
mcview_toggle_nroff_mode (WView * view)
{
view->text_nroff_mode = !view->text_nroff_mode;
mcview_altered_nroff_flag = 1;
@ -127,7 +127,7 @@ mcview_toggle_nroff_mode (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
void
mcview_toggle_hex_mode (mcview_t * view)
mcview_toggle_hex_mode (WView * view)
{
view->hex_mode = !view->hex_mode;
@ -153,7 +153,7 @@ mcview_toggle_hex_mode (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
void
mcview_init (mcview_t * view)
mcview_init (WView * view)
{
size_t i;
@ -205,7 +205,7 @@ mcview_init (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
void
mcview_done (mcview_t * view)
mcview_done (WView * view)
{
/* Save current file position */
if (mcview_remember_file_position && view->filename_vpath != NULL)
@ -267,7 +267,7 @@ mcview_done (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
void
mcview_set_codeset (mcview_t * view)
mcview_set_codeset (WView * view)
{
#ifdef HAVE_CHARSET
const char *cp_id = NULL;
@ -298,7 +298,7 @@ mcview_set_codeset (mcview_t * view)
#ifdef HAVE_CHARSET
void
mcview_select_encoding (mcview_t * view)
mcview_select_encoding (WView * view)
{
if (do_select_codepage ())
mcview_set_codeset (view);
@ -308,7 +308,7 @@ mcview_select_encoding (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
void
mcview_show_error (mcview_t * view, const char *msg)
mcview_show_error (WView * view, const char *msg)
{
if (mcview_is_in_panel (view))
mcview_set_datasource_string (view, msg);
@ -322,7 +322,7 @@ mcview_show_error (mcview_t * view, const char *msg)
*/
off_t
mcview_bol (mcview_t * view, off_t current, off_t limit)
mcview_bol (WView * view, off_t current, off_t limit)
{
int c;
off_t filesize;
@ -357,7 +357,7 @@ mcview_bol (mcview_t * view, off_t current, off_t limit)
*/
off_t
mcview_eol (mcview_t * view, off_t current, off_t limit)
mcview_eol (WView * view, off_t current, off_t limit)
{
int c, prev_ch = 0;
off_t filesize;
@ -390,7 +390,7 @@ mcview_eol (mcview_t * view, off_t current, off_t limit)
char *
mcview_get_title (const WDialog * h, size_t len)
{
const mcview_t *view = (const mcview_t *) find_widget_type (h, mcview_callback);
const WView *view = (const WView *) find_widget_type (h, mcview_callback);
const char *modified = view->hexedit_mode && (view->change_list != NULL) ? "(*) " : " ";
const char *file_label;
const char *view_filename;
@ -410,7 +410,7 @@ mcview_get_title (const WDialog * h, size_t len)
/* --------------------------------------------------------------------------------------------- */
int
mcview_calc_percent (mcview_t * view, off_t p)
mcview_calc_percent (WView * view, off_t p)
{
const screen_dimen right = view->status_area.left + view->status_area.width;
const screen_dimen height = view->status_area.height;

14
src/viewer/mcviewer.c
View File

@ -83,7 +83,7 @@ char *mcview_show_eof = NULL;
/** Both views */
static gboolean
do_mcview_event (mcview_t * view, Gpm_Event * event, int *result)
do_mcview_event (WView * view, Gpm_Event * event, int *result)
{
screen_dimen y, x;
Gpm_Event local;
@ -179,7 +179,7 @@ do_mcview_event (mcview_t * view, Gpm_Event * event, int *result)
static int
mcview_event (Gpm_Event * event, void *data)
{
mcview_t *view = (mcview_t *) data;
WView *view = (WView *) data;
int result;
if (!mouse_global_in_widget (event, WIDGET (data)))
@ -194,12 +194,12 @@ mcview_event (Gpm_Event * event, void *data)
/*** public functions ****************************************************************************/
/* --------------------------------------------------------------------------------------------- */
mcview_t *
WView *
mcview_new (int y, int x, int lines, int cols, gboolean is_panel)
{
mcview_t *view;
WView *view;
view = g_new0 (mcview_t, 1);
view = g_new0 (WView, 1);
widget_init (WIDGET (view), y, x, lines, cols, mcview_callback, mcview_event);
view->hex_mode = FALSE;
@ -236,7 +236,7 @@ mcview_viewer (const char *command, const vfs_path_t * file_vpath, int start_lin
off_t search_start, off_t search_end)
{
gboolean succeeded;
mcview_t *lc_mcview;
WView *lc_mcview;
WDialog *view_dlg;
/* Create dialog and widgets, put them on the dialog */
@ -270,7 +270,7 @@ mcview_viewer (const char *command, const vfs_path_t * file_vpath, int start_lin
/* --------------------------------------------------------------------------------------------- */
gboolean
mcview_load (mcview_t * view, const char *command, const char *file, int start_line,
mcview_load (WView * view, const char *command, const char *file, int start_line,
off_t search_start, off_t search_end)
{
gboolean retval = FALSE;

12
src/viewer/mcviewer.h
View File

@ -13,8 +13,8 @@
/*** structures declarations (and typedefs of structures)*****************************************/
struct mcview_struct;
typedef struct mcview_struct mcview_t;
struct WView;
typedef struct WView WView;
/*** global variables defined in .c file *********************************************************/
@ -35,9 +35,9 @@ extern char *mcview_show_eof;
/*** declarations of public functions ************************************************************/
/* Creates a new mcview_t object with the given properties. Caveat: the
/* Creates a new WView object with the given properties. Caveat: the
* origin is in y-x order, while the extent is in x-y order. */
extern mcview_t *mcview_new (int y, int x, int lines, int cols, gboolean is_panel);
extern WView *mcview_new (int y, int x, int lines, int cols, gboolean is_panel);
/* Shows {file} or the output of {command} in the internal viewer,
@ -46,8 +46,8 @@ extern mcview_t *mcview_new (int y, int x, int lines, int cols, gboolean is_pane
extern gboolean mcview_viewer (const char *command, const vfs_path_t * file_vpath, int start_line,
off_t search_start, off_t search_end);
extern gboolean mcview_load (mcview_t * view, const char *command, const char *file,
int start_line, off_t search_start, off_t search_end);
extern gboolean mcview_load (WView * view, const char *command, const char *file, int start_line,
off_t search_start, off_t search_end);
/*** inline functions ****************************************************************************/
#endif /* MC__VIEWER_H */

32
src/viewer/move.c
View File

@ -68,7 +68,7 @@
/* --------------------------------------------------------------------------------------------- */
static void
mcview_scroll_to_cursor (mcview_t * view)
mcview_scroll_to_cursor (WView * view)
{
if (view->hex_mode)
{
@ -91,7 +91,7 @@ mcview_scroll_to_cursor (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
static void
mcview_movement_fixups (mcview_t * view, gboolean reset_search)
mcview_movement_fixups (WView * view, gboolean reset_search)
{
mcview_scroll_to_cursor (view);
if (reset_search)
@ -107,7 +107,7 @@ mcview_movement_fixups (mcview_t * view, gboolean reset_search)
/* --------------------------------------------------------------------------------------------- */
void
mcview_move_up (mcview_t * view, off_t lines)
mcview_move_up (WView * view, off_t lines)
{
if (view->hex_mode)
{
@ -137,7 +137,7 @@ mcview_move_up (mcview_t * view, off_t lines)
/* --------------------------------------------------------------------------------------------- */
void
mcview_move_down (mcview_t * view, off_t lines)
mcview_move_down (WView * view, off_t lines)
{
off_t last_byte;
last_byte = mcview_get_filesize (view);
@ -168,7 +168,7 @@ mcview_move_down (mcview_t * view, off_t lines)
/* --------------------------------------------------------------------------------------------- */
void
mcview_move_left (mcview_t * view, off_t columns)
mcview_move_left (WView * view, off_t columns)
{
if (view->hex_mode)
{
@ -193,7 +193,7 @@ mcview_move_left (mcview_t * view, off_t columns)
/* --------------------------------------------------------------------------------------------- */
void
mcview_move_right (mcview_t * view, off_t columns)
mcview_move_right (WView * view, off_t columns)
{
if (view->hex_mode)
{
@ -223,7 +223,7 @@ mcview_move_right (mcview_t * view, off_t columns)
/* --------------------------------------------------------------------------------------------- */
void
mcview_moveto_top (mcview_t * view)
mcview_moveto_top (WView * view)
{
view->dpy_start = 0;
view->dpy_paragraph_skip_lines = 0;
@ -236,7 +236,7 @@ mcview_moveto_top (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
void
mcview_moveto_bottom (mcview_t * view)
mcview_moveto_bottom (WView * view)
{
off_t filesize;
@ -266,7 +266,7 @@ mcview_moveto_bottom (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
void
mcview_moveto_bol (mcview_t * view)
mcview_moveto_bol (WView * view)
{
if (view->hex_mode)
{
@ -283,7 +283,7 @@ mcview_moveto_bol (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
void
mcview_moveto_eol (mcview_t * view)
mcview_moveto_eol (WView * view)
{
off_t bol;
if (view->hex_mode)
@ -311,7 +311,7 @@ mcview_moveto_eol (mcview_t * view)
/* --------------------------------------------------------------------------------------------- */
void
mcview_moveto_offset (mcview_t * view, off_t offset)
mcview_moveto_offset (WView * view, off_t offset)
{
if (view->hex_mode)
{
@ -332,7 +332,7 @@ mcview_moveto_offset (mcview_t * view, off_t offset)
/* --------------------------------------------------------------------------------------------- */
void
mcview_moveto (mcview_t * view, off_t line, off_t col)
mcview_moveto (WView * view, off_t line, off_t col)
{
off_t offset;
@ -343,7 +343,7 @@ mcview_moveto (mcview_t * view, off_t line, off_t col)
/* --------------------------------------------------------------------------------------------- */
void
mcview_coord_to_offset (mcview_t * view, off_t * ret_offset, off_t line, off_t column)
mcview_coord_to_offset (WView * view, off_t * ret_offset, off_t line, off_t column)
{
coord_cache_entry_t coord;
@ -357,7 +357,7 @@ mcview_coord_to_offset (mcview_t * view, off_t * ret_offset, off_t line, off_t c
/* --------------------------------------------------------------------------------------------- */
void
mcview_offset_to_coord (mcview_t * view, off_t * ret_line, off_t * ret_column, off_t offset)
mcview_offset_to_coord (WView * view, off_t * ret_line, off_t * ret_column, off_t offset)
{
coord_cache_entry_t coord;
@ -371,7 +371,7 @@ mcview_offset_to_coord (mcview_t * view, off_t * ret_line, off_t * ret_column, o
/* --------------------------------------------------------------------------------------------- */
void
mcview_place_cursor (mcview_t * view)
mcview_place_cursor (WView * view)
{
const screen_dimen top = view->data_area.top;
const screen_dimen left = view->data_area.left;
@ -387,7 +387,7 @@ mcview_place_cursor (mcview_t * view)
* try to display maximum of match */
void
mcview_moveto_match (mcview_t * view)
mcview_moveto_match (WView * view)
{
if (view->hex_mode)
{

6
src/viewer/nroff.c
View File

@ -92,7 +92,7 @@ mcview_nroff_get_char (mcview_nroff_t * nroff, int *ret_val, off_t nroff_index)
/* --------------------------------------------------------------------------------------------- */
int
mcview__get_nroff_real_len (mcview_t * view, off_t start, off_t length)
mcview__get_nroff_real_len (WView * view, off_t start, off_t length)
{
mcview_nroff_t *nroff;
int ret = 0;
@ -128,7 +128,7 @@ mcview__get_nroff_real_len (mcview_t * view, off_t start, off_t length)
/* --------------------------------------------------------------------------------------------- */
mcview_nroff_t *
mcview_nroff_seq_new_num (mcview_t * view, off_t lc_index)
mcview_nroff_seq_new_num (WView * view, off_t lc_index)
{
mcview_nroff_t *nroff;
@ -145,7 +145,7 @@ mcview_nroff_seq_new_num (mcview_t * view, off_t lc_index)
/* --------------------------------------------------------------------------------------------- */
mcview_nroff_t *
mcview_nroff_seq_new (mcview_t * view)
mcview_nroff_seq_new (WView * view)
{
return mcview_nroff_seq_new_num (view, (off_t) 0);

12
src/viewer/search.c
View File

@ -54,7 +54,7 @@ typedef struct
simple_status_msg_t status_msg; /* base class */
gboolean first;
mcview_t *view;
WView *view;
off_t offset;
} mcview_search_status_msg_t;
@ -101,7 +101,7 @@ mcview_search_status_update_cb (status_msg_t * sm)
/* --------------------------------------------------------------------------------------------- */
static void
mcview_search_update_steps (mcview_t * view)
mcview_search_update_steps (WView * view)
{
off_t filesize = mcview_get_filesize (view);
if (filesize != 0)
@ -119,7 +119,7 @@ mcview_search_update_steps (mcview_t * view)
static gboolean
mcview_find (mcview_search_status_msg_t * ssm, off_t search_start, off_t search_end, gsize * len)
{
mcview_t *view = ssm->view;
WView *view = ssm->view;
view->search_numNeedSkipChar = 0;
search_cb_char_curr_index = -1;
@ -158,7 +158,7 @@ mcview_find (mcview_search_status_msg_t * ssm, off_t search_start, off_t search_
/* --------------------------------------------------------------------------------------------- */
static void
mcview_search_show_result (mcview_t * view, size_t match_len)
mcview_search_show_result (WView * view, size_t match_len)
{
int nroff_len;
@ -186,7 +186,7 @@ mcview_search_show_result (mcview_t * view, size_t match_len)
mc_search_cbret_t
mcview_search_cmd_callback (const void *user_data, gsize char_offset, int *current_char)
{
mcview_t *view = ((mcview_search_status_msg_t *) user_data)->view;
WView *view = ((mcview_search_status_msg_t *) user_data)->view;
/* view_read_continue (view, &view->search_onechar_info); *//* AB:FIXME */
if (!view->text_nroff_mode)
@ -262,7 +262,7 @@ mcview_search_update_cmd_callback (const void *user_data, gsize char_offset)
/* --------------------------------------------------------------------------------------------- */
void
mcview_do_search (mcview_t * view, off_t want_search_start)
mcview_do_search (WView * view, off_t want_search_start)
{
mcview_search_status_msg_t vsm;