vim: src/ui.c comparison

comparison src/ui.c @ 7835:4d7ce6c03fda v7.4.1214

commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7 Author: Bram Moolenaar <Bram@vim.org> Date: Sat Jan 30 21:10:09 2016 +0100 patch 7.4.1214 Problem: Using old style function declarations. Solution: Change to new style function declarations. (script by Hirohito Higashi)

author	Christian Brabandt <cb@256bit.org>
date	Sat, 30 Jan 2016 21:15:04 +0100
parents	0b6c37dd858d
children	10f17a228661

comparison

equal deleted inserted replaced

-:2d1dc9ec41ce
+:4d7ce6c03fda
 # include <windows.h>
 # include "winclip.pro"
 #endif
 void
-ui_write(s, len)
+ui_write(char_u *s, int len)
-char_u  *s;
-int	    len;
 {
 #ifdef FEAT_GUI
 if (gui.in_use && !gui.dying && !gui.starting)
 {
 	gui_write(s, len);
 static char_u *ta_str = NULL;
 static int ta_off;	/* offset for next char to use when ta_str != NULL */
 static int ta_len;	/* length of ta_str when it's not NULL*/
 void
-ui_inchar_undo(s, len)
+ui_inchar_undo(char_u *s, int len)
-char_u	*s;
-int		len;
 {
 char_u  *new;
 int	    newlen;
 newlen = len;
 * it.  When typebuf.tb_change_cnt changes (e.g., when a message is received
 * from a remote client) "buf" can no longer be used.  "tb_change_cnt" is NULL
 * otherwise.
 */
 int
-ui_inchar(buf, maxlen, wtime, tb_change_cnt)
+ui_inchar(
-char_u	*buf;
+char_u	*buf,
-int		maxlen;
+int		maxlen,
-long	wtime;	    /* don't use "time", MIPS cannot handle it */
+long	wtime,	    /* don't use "time", MIPS cannot handle it */
-int		tb_change_cnt;
+int		tb_change_cnt)
 {
 int		retval = 0;
 #if defined(FEAT_GUI) && (defined(UNIX) || defined(VMS))
 /*
 /*
 * return non-zero if a character is available
 */
 int
-ui_char_avail()
+ui_char_avail(void)
 {
 #ifdef FEAT_GUI
 if (gui.in_use)
 {
 	gui_mch_update();
 /*
 * Delay for the given number of milliseconds.	If ignoreinput is FALSE then we
 * cancel the delay if a key is hit.
 */
 void
-ui_delay(msec, ignoreinput)
+ui_delay(long msec, int ignoreinput)
-long	msec;
-int		ignoreinput;
 {
 #ifdef FEAT_GUI
 if (gui.in_use && !ignoreinput)
 	gui_wait_for_chars(msec);
 else
 * If the machine has job control, use it to suspend the program,
 * otherwise fake it by starting a new shell.
 * When running the GUI iconify the window.
 */
 void
-ui_suspend()
+ui_suspend(void)
 {
 #ifdef FEAT_GUI
 if (gui.in_use)
 {
 	gui_mch_iconify();
 /*
 * When the OS can't really suspend, call this function to start a shell.
 * This is never called in the GUI.
 */
 void
-suspend_shell()
+suspend_shell(void)
 {
 if (*p_sh == NUL)
 	EMSG(_(e_shellempty));
 else
 {
 * Try to get the current Vim shell size.  Put the result in Rows and Columns.
 * Use the new sizes as defaults for 'columns' and 'lines'.
 * Return OK when size could be determined, FAIL otherwise.
 */
 int
-ui_get_shellsize()
+ui_get_shellsize(void)
 {
 int	    retval;
 #ifdef FEAT_GUI
 if (gui.in_use)
 * Set the size of the Vim shell according to Rows and Columns, if possible.
 * The gui_set_shellsize() or mch_set_shellsize() function will try to set the
 * new size.  If this is not possible, it will adjust Rows and Columns.
 */
 void
-ui_set_shellsize(mustset)
+ui_set_shellsize(
-int		mustset UNUSED;	/* set by the user */
+int		mustset UNUSED)	/* set by the user */
 {
 #ifdef FEAT_GUI
 if (gui.in_use)
 	gui_set_shellsize(mustset, TRUE, RESIZE_BOTH);
 else
 /*
 * Called when Rows and/or Columns changed.  Adjust scroll region and mouse
 * region.
 */
 void
-ui_new_shellsize()
+ui_new_shellsize(void)
 {
 if (full_screen && !exiting)
 {
 #ifdef FEAT_GUI
 	if (gui.in_use)
 	    mch_new_shellsize();
 }
 }
 void
-ui_breakcheck()
+ui_breakcheck(void)
 {
 #ifdef FEAT_GUI
 if (gui.in_use)
 	gui_mch_update();
 else
 * is included, but the clipboard can not be used, or TRUE if the clipboard can
 * be used.  Eg unix may call this with FALSE, then call it again with TRUE if
 * the GUI starts.
 */
 void
-clip_init(can_use)
+clip_init(int can_use)
-int	    can_use;
 {
 VimClipboard *cb;
 cb = &clip_star;
 for (;;)
 * lying around.  If the VIsual mode has ended, make a copy of what was
 * selected so we can still give it to others.	Will probably have to make sure
 * this is called whenever VIsual mode is ended.
 */
 void
-clip_update_selection(clip)
+clip_update_selection(VimClipboard *clip)
-VimClipboard    *clip;
 {
 pos_T	    start, end;
 /* If visual mode is only due to a redo command ("."), then ignore it */
 if (!redo_VIsual_busy && VIsual_active && (State & NORMAL))
 	}
 }
 }
 void
-clip_own_selection(cbd)
+clip_own_selection(VimClipboard *cbd)
-VimClipboard	*cbd;
 {
 /*
 * Also want to check somehow that we are reading from the keyboard rather
 * than a mapping etc.
 */
 	cbd->owned = (clip_gen_own_selection(cbd) == OK);
 #endif
 }
 void
-clip_lose_selection(cbd)
+clip_lose_selection(VimClipboard *cbd)
-VimClipboard	*cbd;
 {
 #ifdef FEAT_X11
 int	    was_owned = cbd->owned;
 #endif
 int     visual_selection = FALSE;
 }
 #endif
 }
 static void
-clip_copy_selection(clip)
+clip_copy_selection(VimClipboard *clip)
-VimClipboard	*clip;
 {
 if (VIsual_active && (State & NORMAL) && clip->available)
 {
 	clip_update_selection(clip);
 	clip_free_selection(clip);
 /*
 * Save clip_unnamed and reset it.
 */
 void
-start_global_changes()
+start_global_changes(void)
 {
 if (++global_change_count > 1)
 	return;
 clip_unnamed_saved = clip_unnamed;
 clipboard_needs_update = FALSE;
 /*
 * Restore clip_unnamed and set the selection when needed.
 */
 void
-end_global_changes()
+end_global_changes(void)
 {
 if (--global_change_count > 0)
 	/* recursive */
 	return;
 if (!clip_did_set_selection)
 /*
 * Called when Visual mode is ended: update the selection.
 */
 void
-clip_auto_select()
+clip_auto_select(void)
 {
 if (clip_isautosel_star())
 	clip_copy_selection(&clip_star);
 if (clip_isautosel_plus())
 	clip_copy_selection(&clip_plus);
 /*
 * Return TRUE if automatic selection of Visual area is desired for the *
 * register.
 */
 int
-clip_isautosel_star()
+clip_isautosel_star(void)
 {
 return (
 #ifdef FEAT_GUI
 	    gui.in_use ? (vim_strchr(p_go, GO_ASEL) != NULL) :
 #endif
 /*
 * Return TRUE if automatic selection of Visual area is desired for the +
 * register.
 */
 int
-clip_isautosel_plus()
+clip_isautosel_plus(void)
 {
 return (
 #ifdef FEAT_GUI
 	    gui.in_use ? (vim_strchr(p_go, GO_ASELPLUS) != NULL) :
 #endif
 /*
 * Start, continue or end a modeless selection.  Used when editing the
 * command-line and in the cmdline window.
 */
 void
-clip_modeless(button, is_click, is_drag)
+clip_modeless(int button, int is_click, int is_drag)
-int		button;
-int		is_click;
-int		is_drag;
 {
 int		repeat;
 repeat = ((clip_star.mode == SELECT_MODE_CHAR
 		|| clip_star.mode == SELECT_MODE_LINE)
 /*
 * Compare two screen positions ala strcmp()
 */
 static int
-clip_compare_pos(row1, col1, row2, col2)
+clip_compare_pos(
-int		row1;
+int		row1,
-int		col1;
+int		col1,
-int		row2;
+int		row2,
-int		col2;
+int		col2)
 {
 if (row1 > row2) return(1);
 if (row1 < row2) return(-1);
 if (col1 > col2) return(1);
 if (col1 < col2) return(-1);
 /*
 * Start the selection
 */
 void
-clip_start_selection(col, row, repeated_click)
+clip_start_selection(int col, int row, int repeated_click)
-int		col;
-int		row;
-int		repeated_click;
 {
 VimClipboard	*cb = &clip_star;
 if (cb->state == SELECT_DONE)
 	clip_clear_selection(cb);
 /*
 * Continue processing the selection
 */
 void
-clip_process_selection(button, col, row, repeated_click)
+clip_process_selection(
-int		button;
+int		button,
-int		col;
+int		col,
-int		row;
+int		row,
-int_u	repeated_click;
+int_u	repeated_click)
 {
 VimClipboard	*cb = &clip_star;
 int			diff;
 int			slen = 1;	/* cursor shape width */
 /*
 * Redraw part of the selection if character at "row,col" is inside of it.
 * Only used for the GUI.
 */
 void
-clip_may_redraw_selection(row, col, len)
+clip_may_redraw_selection(int row, int col, int len)
-int		row, col;
-int		len;
 {
 int		start = col;
 int		end = col + len;
 if (clip_star.state != SELECT_CLEARED
 /*
 * Called from outside to clear selected region from the display
 */
 void
-clip_clear_selection(cbd)
+clip_clear_selection(VimClipboard *cbd)
-VimClipboard    *cbd;
 {
 if (cbd->state == SELECT_CLEARED)
 	return;
 /*
 * Clear the selection if any lines from "row1" to "row2" are inside of it.
 */
 void
-clip_may_clear_selection(row1, row2)
+clip_may_clear_selection(int row1, int row2)
-int	row1, row2;
 {
 if (clip_star.state == SELECT_DONE
 	    && row2 >= clip_star.start.lnum
 	    && row1 <= clip_star.end.lnum)
 	clip_clear_selection(&clip_star);
 /*
 * Called before the screen is scrolled up or down.  Adjusts the line numbers
 * of the selection.  Call with big number when clearing the screen.
 */
 void
-clip_scroll_selection(rows)
+clip_scroll_selection(
-int	    rows;		/* negative for scroll down */
+int	    rows)		/* negative for scroll down */
 {
 int	    lnum;
 if (clip_star.state == SELECT_CLEARED)
 	return;
 * CLIP_SET:    set inversion
 * CLIP_TOGGLE: set inversion if pos1 < pos2, undo inversion otherwise.
 * 0: invert (GUI only).
 */
 static void
-clip_invert_area(row1, col1, row2, col2, how)
+clip_invert_area(
-int		row1;
+int		row1,
-int		col1;
+int		col1,
-int		row2;
+int		row2,
-int		col2;
+int		col2,
-int		how;
+int		how)
 {
 int		invert = FALSE;
 if (how == CLIP_SET)
 	invert = TRUE;
 /*
 * Invert or un-invert a rectangle of the screen.
 * "invert" is true if the result is inverted.
 */
 static void
-clip_invert_rectangle(row, col, height, width, invert)
+clip_invert_rectangle(
-int		row;
+int		row,
-int		col;
+int		col,
-int		height;
+int		height,
-int		width;
+int		width,
-int		invert;
+int		invert)
 {
 #ifdef FEAT_GUI
 if (gui.in_use)
 	gui_mch_invert_rectangle(row, col, height, width);
 else
 * Copy the currently selected area into the '*' register so it will be
 * available for pasting.
 * When "both" is TRUE also copy to the '+' register.
 */
 void
-clip_copy_modeless_selection(both)
+clip_copy_modeless_selection(int both UNUSED)
-int		both UNUSED;
 {
 char_u	*buffer;
 char_u	*bufp;
 int		row;
 int		start_col;
 * column.  Only white-separated words are recognized here.
 */
 #define CHAR_CLASS(c)	(c <= ' ' ? ' ' : vim_iswordc(c))
 static void
-clip_get_word_boundaries(cb, row, col)
+clip_get_word_boundaries(VimClipboard *cb, int row, int col)
-VimClipboard	*cb;
-int			row;
-int			col;
 {
 int		start_class;
 int		temp_col;
 char_u	*p;
 #ifdef FEAT_MBYTE
 /*
 * Find the column position for the last non-whitespace character on the given
 * line.
 */
 static int
-clip_get_line_end(row)
+clip_get_line_end(int row)
-int		row;
 {
 int	    i;
 if (row >= screen_Rows || ScreenLines == NULL)
 	return 0;
 /*
 * Update the currently selected region by adding and/or subtracting from the
 * beginning or end and inverting the changed area(s).
 */
 static void
-clip_update_modeless_selection(cb, row1, col1, row2, col2)
+clip_update_modeless_selection(
-VimClipboard    *cb;
+VimClipboard    *cb,
-int		    row1;
+int		    row1,
-int		    col1;
+int		    col1,
-int		    row2;
+int		    row2,
-int		    col2;
+int		    col2)
 {
 /* See if we changed at the beginning of the selection */
 if (row1 != cb->start.lnum || col1 != (int)cb->start.col)
 {
 	clip_invert_area(row1, col1, (int)cb->start.lnum, cb->start.col,
 	cb->end.col  = col2;
 }
 }
 int
-clip_gen_own_selection(cbd)
+clip_gen_own_selection(VimClipboard *cbd)
-VimClipboard	*cbd;
 {
 #ifdef FEAT_XCLIPBOARD
 # ifdef FEAT_GUI
 if (gui.in_use)
 	return clip_mch_own_selection(cbd);
 return clip_mch_own_selection(cbd);
 #endif
 }
 void
-clip_gen_lose_selection(cbd)
+clip_gen_lose_selection(VimClipboard *cbd)
-VimClipboard	*cbd;
 {
 #ifdef FEAT_XCLIPBOARD
 # ifdef FEAT_GUI
 if (gui.in_use)
 	clip_mch_lose_selection(cbd);
 clip_mch_lose_selection(cbd);
 #endif
 }
 void
-clip_gen_set_selection(cbd)
+clip_gen_set_selection(VimClipboard *cbd)
-VimClipboard	*cbd;
 {
 if (!clip_did_set_selection)
 {
 	/* Updating postponed, so that accessing the system clipboard won't
 	 * hang Vim when accessing it many times (e.g. on a :g comand). */
 clip_mch_set_selection(cbd);
 #endif
 }
 void
-clip_gen_request_selection(cbd)
+clip_gen_request_selection(VimClipboard *cbd)
-VimClipboard	*cbd;
 {
 #ifdef FEAT_XCLIPBOARD
 # ifdef FEAT_GUI
 if (gui.in_use)
 	clip_mch_request_selection(cbd);
 clip_mch_request_selection(cbd);
 #endif
 }
 int
-clip_gen_owner_exists(cbd)
+clip_gen_owner_exists(VimClipboard *cbd UNUSED)
-VimClipboard	*cbd UNUSED;
 {
 #ifdef FEAT_XCLIPBOARD
 # ifdef FEAT_GUI_GTK
 if (gui.in_use)
 	return clip_gtk_owner_exists(cbd);
 * trash_input_buf() are functions for manipulating the input buffer.  These
 * are used by the gui_* calls when a GUI is used to handle keyboard input.
 */
 int
-vim_is_input_buf_full()
+vim_is_input_buf_full(void)
 {
 return (inbufcount >= INBUFLEN);
 }
 int
-vim_is_input_buf_empty()
+vim_is_input_buf_empty(void)
 {
 return (inbufcount == 0);
 }
 #if defined(FEAT_OLE) || defined(PROTO)
 int
-vim_free_in_input_buf()
+vim_free_in_input_buf(void)
 {
 return (INBUFLEN - inbufcount);
 }
 #endif
 #if defined(FEAT_GUI_GTK) || defined(PROTO)
 int
-vim_used_in_input_buf()
+vim_used_in_input_buf(void)
 {
 return inbufcount;
 }
 #endif
 /*
 * Return the current contents of the input buffer and make it empty.
 * The returned pointer must be passed to set_input_buf() later.
 */
 char_u *
-get_input_buf()
+get_input_buf(void)
 {
 garray_T	*gap;
 /* We use a growarray to store the data pointer and the length. */
 gap = (garray_T *)alloc((unsigned)sizeof(garray_T));
 /*
 * Restore the input buffer with a pointer returned from get_input_buf().
 * The allocated memory is freed, this only works once!
 */
 void
-set_input_buf(p)
+set_input_buf(char_u *p)
-char_u	*p;
 {
 garray_T	*gap = (garray_T *)p;
 if (gap != NULL)
 {
 * Add the given bytes to the input buffer
 * Special keys start with CSI.  A real CSI must have been translated to
 * CSI KS_EXTRA KE_CSI.  K_SPECIAL doesn't require translation.
 */
 void
-add_to_input_buf(s, len)
+add_to_input_buf(char_u *s, int len)
-char_u  *s;
-int	    len;
 {
 if (inbufcount + len > INBUFLEN + MAX_KEY_CODE_LEN)
 	return;	    /* Shouldn't ever happen! */
 #ifdef FEAT_HANGULIN
 }
 #endif
 #if defined(FEAT_HANGULIN) || defined(PROTO)
 void
-push_raw_key(s, len)
+push_raw_key(char_u *s, int len)
-char_u  *s;
-int	    len;
 {
 char_u *tmpbuf;
 tmpbuf = hangul_string_convert(s, &len);
 if (tmpbuf != NULL)
 #if defined(FEAT_GUI) || defined(FEAT_EVAL) || defined(FEAT_EX_EXTRA) \
 	|| defined(PROTO)
 /* Remove everything from the input buffer.  Called when ^C is found */
 void
-trash_input_buf()
+trash_input_buf(void)
 {
 inbufcount = 0;
 }
 #endif
 * Read as much data from the input buffer as possible up to maxlen, and store
 * it in buf.
 * Note: this function used to be Read() in unix.c
 */
 int
-read_from_input_buf(buf, maxlen)
+read_from_input_buf(char_u *buf, long maxlen)
-char_u  *buf;
-long    maxlen;
 {
 if (inbufcount == 0)	/* if the buffer is empty, fill it */
 	fill_input_buf(TRUE);
 if (maxlen > inbufcount)
 	maxlen = inbufcount;
 	mch_memmove(inbuf, inbuf + maxlen, (size_t)inbufcount);
 return (int)maxlen;
 }
 void
-fill_input_buf(exit_on_error)
+fill_input_buf(int exit_on_error UNUSED)
-int	exit_on_error UNUSED;
 {
 #if defined(UNIX) || defined(VMS) || defined(MACOS_X_UNIX)
 int		len;
 int		try;
 static int	did_read_something = FALSE;
 /*
 * Exit because of an input read error.
 */
 void
-read_error_exit()
+read_error_exit(void)
 {
 if (silent_mode)	/* Normal way to exit for "ex -s" */
 	getout(0);
 STRCPY(IObuff, _("Vim: Error reading input, exiting...\n"));
 preserve_exit();
 #if defined(CURSOR_SHAPE) || defined(PROTO)
 /*
 * May update the shape of the cursor.
 */
 void
-ui_cursor_shape()
+ui_cursor_shape(void)
 {
 # ifdef FEAT_GUI
 if (gui.in_use)
 	gui_update_cursor_later();
 else
 	|| defined(FEAT_MBYTE) || defined(PROTO)
 /*
 * Check bounds for column number
 */
 int
-check_col(col)
+check_col(int col)
-int	    col;
 {
 if (col < 0)
 	return 0;
 if (col >= (int)screen_Columns)
 	return (int)screen_Columns - 1;
 /*
 * Check bounds for row number
 */
 int
-check_row(row)
+check_row(int row)
-int	    row;
 {
 if (row < 0)
 	return 0;
 if (row >= (int)screen_Rows)
 	return (int)screen_Rows - 1;
 /*
 * Open the application context (if it hasn't been opened yet).
 * Used for Motif and Athena GUI and the xterm clipboard.
 */
 void
-open_app_context()
+open_app_context(void)
 {
 if (app_context == NULL)
 {
 	XtToolkitInitialize();
 	app_context = XtCreateApplicationContext();
 static Atom	text_atom;
 static Atom	targets_atom;
 static Atom	timestamp_atom;	/* Used to get a timestamp */
 void
-x11_setup_atoms(dpy)
+x11_setup_atoms(Display *dpy)
-Display	*dpy;
 {
 vim_atom	       = XInternAtom(dpy, VIM_ATOM_NAME,   False);
 #ifdef FEAT_MBYTE
 vimenc_atom	       = XInternAtom(dpy, VIMENC_ATOM_NAME,False);
 utf8_atom	       = XInternAtom(dpy, "UTF8_STRING",   False);
 /*
 * Property callback to get a timestamp for XtOwnSelection.
 */
 static void
-clip_x11_timestamp_cb(w, n, event, cont)
+clip_x11_timestamp_cb(
-Widget	w;
+Widget	w,
-XtPointer	n UNUSED;
+XtPointer	n UNUSED,
-XEvent	*event;
+XEvent	*event,
-Boolean	*cont UNUSED;
+Boolean	*cont UNUSED)
 {
 Atom	    actual_type;
 int		    format;
 unsigned  long  nitems, bytes_after;
 unsigned char   *prop=NULL;
 	    clip_star.owned = TRUE;
 }
 }
 void
-x11_setup_selection(w)
+x11_setup_selection(Widget w)
-Widget	w;
 {
 XtAddEventHandler(w, PropertyChangeMask, False,
 	    /*(XtEventHandler)*/clip_x11_timestamp_cb, (XtPointer)NULL);
 }
 static void
-clip_x11_request_selection_cb(w, success, sel_atom, type, value, length,
+clip_x11_request_selection_cb(
-			      format)
+Widget	w UNUSED,
-Widget	w UNUSED;
+XtPointer	success,
-XtPointer	success;
+Atom	*sel_atom,
-Atom	*sel_atom;
+Atom	*type,
-Atom	*type;
+XtPointer	value,
-XtPointer	value;
+long_u	*length,
-long_u	*length;
+int		*format)
-int		*format;
 {
 int		motion_type = MAUTO;
 long_u	len;
 char_u	*p;
 char	**text_list = NULL;
 XtFree((char *)value);
 *(int *)success = TRUE;
 }
 void
-clip_x11_request_selection(myShell, dpy, cbd)
+clip_x11_request_selection(
-Widget	myShell;
+Widget	myShell,
-Display	*dpy;
+Display	*dpy,
-VimClipboard	*cbd;
+VimClipboard	*cbd)
 {
 XEvent	event;
 Atom	type;
 static int	success;
 int		i;
 /* Final fallback position - use the X CUT_BUFFER0 store */
 yank_cut_buffer0(dpy, cbd);
 }
 static Boolean
-clip_x11_convert_selection_cb(w, sel_atom, target, type, value, length, format)
+clip_x11_convert_selection_cb(
-Widget	w UNUSED;
+Widget	w UNUSED,
-Atom	*sel_atom;
+Atom	*sel_atom,
-Atom	*target;
+Atom	*target,
-Atom	*type;
+Atom	*type,
-XtPointer	*value;
+XtPointer	*value,
-long_u	*length;
+long_u	*length,
-int		*format;
+int		*format)
 {
 char_u	*string;
 char_u	*result;
 int		motion_type;
 VimClipboard	*cbd;
 vim_free(string);
 return True;
 }
 static void
-clip_x11_lose_ownership_cb(w, sel_atom)
+clip_x11_lose_ownership_cb(Widget w UNUSED, Atom *sel_atom)
-Widget  w UNUSED;
-Atom    *sel_atom;
 {
 if (*sel_atom == clip_plus.sel_atom)
 	clip_lose_selection(&clip_plus);
 else
 	clip_lose_selection(&clip_star);
 }
 void
-clip_x11_lose_selection(myShell, cbd)
+clip_x11_lose_selection(Widget myShell, VimClipboard *cbd)
-Widget		myShell;
-VimClipboard	*cbd;
 {
 XtDisownSelection(myShell, cbd->sel_atom,
 				XtLastTimestampProcessed(XtDisplay(myShell)));
 }
 int
-clip_x11_own_selection(myShell, cbd)
+clip_x11_own_selection(Widget myShell, VimClipboard *cbd)
-Widget		myShell;
-VimClipboard	*cbd;
 {
 /* When using the GUI we have proper timestamps, use the one of the last
 * event.  When in the console we don't get events (the terminal gets
 * them), Get the time by a zero-length append, clip_x11_timestamp_cb will
 * be called with the current timestamp.  */
 /*
 * Send the current selection to the clipboard.  Do nothing for X because we
 * will fill in the selection only when requested by another app.
 */
 void
-clip_x11_set_selection(cbd)
+clip_x11_set_selection(VimClipboard *cbd UNUSED)
-VimClipboard *cbd UNUSED;
 {
 }
 int
-clip_x11_owner_exists(cbd)
+clip_x11_owner_exists(VimClipboard *cbd)
-VimClipboard	*cbd;
 {
 return XGetSelectionOwner(X_DISPLAY, cbd->sel_atom) != None;
 }
 #endif
 || defined(FEAT_GUI_GTK) || defined(PROTO)
 /*
 * Get the contents of the X CUT_BUFFER0 and put it in "cbd".
 */
 void
-yank_cut_buffer0(dpy, cbd)
+yank_cut_buffer0(Display *dpy, VimClipboard *cbd)
-Display		*dpy;
-VimClipboard	*cbd;
 {
 int		nbytes = 0;
 char_u	*buffer = (char_u *)XFetchBuffer(dpy, &nbytes, 0);
 if (nbytes > 0)
 *
 * If flags has MOUSE_SETPOS, nothing is done, only the current position is
 * remembered.
 */
 int
-jump_to_mouse(flags, inclusive, which_button)
+jump_to_mouse(
-int		flags;
+int		flags,
-int		*inclusive;	/* used for inclusive operator, can be NULL */
+int		*inclusive,	/* used for inclusive operator, can be NULL */
-int		which_button;	/* MOUSE_LEFT, MOUSE_RIGHT, MOUSE_MIDDLE */
+int		which_button)	/* MOUSE_LEFT, MOUSE_RIGHT, MOUSE_MIDDLE */
 {
 static int	on_status_line = 0;	/* #lines below bottom of window */
 #ifdef FEAT_VERTSPLIT
 static int	on_sep_line = 0;	/* on separator right of window */
 #endif
 * Compute the position in the buffer line from the posn on the screen in
 * window "win".
 * Returns TRUE if the position is below the last line.
 */
 int
-mouse_comp_pos(win, rowp, colp, lnump)
+mouse_comp_pos(
-win_T	*win;
+win_T	*win,
-int		*rowp;
+int		*rowp,
-int		*colp;
+int		*colp,
-linenr_T	*lnump;
+linenr_T	*lnump)
 {
 int		col = *colp;
 int		row = *rowp;
 linenr_T	lnum;
 int		retval = FALSE;
 /*
 * Find the window at screen position "*rowp" and "*colp".  The positions are
 * updated to become relative to the top-left of the window.
 */
 win_T *
-mouse_find_win(rowp, colp)
+mouse_find_win(int *rowp, int *colp UNUSED)
-int		*rowp;
-int		*colp UNUSED;
 {
 frame_T	*fp;
 fp = topframe;
 *rowp -= firstwin->w_winrow;
 	|| defined(FEAT_GUI_PHOTON) || defined(PROTO)
 /*
 * Translate window coordinates to buffer position without any side effects
 */
 int
-get_fpos_of_mouse(mpos)
+get_fpos_of_mouse(pos_T *mpos)
-pos_T	*mpos;
 {
 win_T	*wp;
 int		row = mouse_row;
 int		col = mouse_col;
 /*
 * Convert a virtual (screen) column to a character column.
 * The first column is one.
 */
 int
-vcol2col(wp, lnum, vcol)
+vcol2col(win_T *wp, linenr_T lnum, int vcol)
-win_T	*wp;
-linenr_T	lnum;
-int		vcol;
 {
 /* try to advance to the specified column */
 int		count = 0;
 char_u	*ptr;
 char_u	*line;
 /*
 * Called when focus changed.  Used for the GUI or for systems where this can
 * be done in the console (Win32).
 */
 void
-ui_focus_change(in_focus)
+ui_focus_change(
-int		in_focus;	/* TRUE if focus gained. */
+int		in_focus)	/* TRUE if focus gained. */
 {
 static time_t	last_time = (time_t)0;
 int			need_redraw = FALSE;
 /* When activated: Check if any file was modified outside of Vim.
 #if defined(USE_IM_CONTROL) || defined(PROTO)
 /*
 * Save current Input Method status to specified place.
 */
 void
-im_save_status(psave)
+im_save_status(long *psave)
-long *psave;
 {
 /* Don't save when 'imdisable' is set or "xic" is NULL, IM is always
 * disabled then (but might start later).
 * Also don't save when inside a mapping, vgetc_im_active has not been set
 * then.

Mercurial > vim

comparison src/ui.c @ 7835:4d7ce6c03fda v7.4.1214