vim: src/gui.c comparison

comparison src/gui.c @ 7821:81794242a275 v7.4.1207

commit https://github.com/vim/vim/commit/66f948e928d5e0cd3123af902aa8ac1613534c94 Author: Bram Moolenaar <Bram@vim.org> Date: Sat Jan 30 16:39:25 2016 +0100 patch 7.4.1207 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 16:45:04 +0100
parents	a1e71a01dbd6
children	563c923b1584

comparison

equal deleted inserted replaced

-:38d22ab3d9a0
+:81794242a275
 * Careful: This function can be called recursively when there is a ":gui"
 * command in the .gvimrc file.  Only the first call should fork, not the
 * recursive call.
 */
 void
-gui_start()
+gui_start(void)
 {
 char_u	*old_term;
 static int	recursive = 0;
 old_term = vim_strsave(T_NAME);
 * what size the shell should be.  So if there are errors in the .gvimrc
 * file, they will have to go to the terminal: Set full_screen to FALSE.
 * full_screen will be set to TRUE again by a successful termcapinit().
 */
 static void
-gui_attempt_start()
+gui_attempt_start(void)
 {
 static int recursive = 0;
 ++recursive;
 gui.starting = TRUE;
 * If the child fails to start the GUI, then the child will exit and the
 * parent will return. If the child succeeds, then the parent will exit
 * and the child will return.
 */
 static void
-gui_do_fork()
+gui_do_fork(void)
 {
 int		pipefd[2];	/* pipe between parent and child */
 int		pipe_error;
 int		status;
 int		exit_status;
 /*
 * Call this when vim starts up, whether or not the GUI is started
 */
 void
-gui_prepare(argc, argv)
+gui_prepare(int *argc, char **argv)
-int	    *argc;
-char    **argv;
 {
 gui.in_use = FALSE;		    /* No GUI yet (maybe later) */
 gui.starting = FALSE;	    /* No GUI yet (maybe later) */
 gui_mch_prepare(argc, argv);
 }
 * Used from main() to check early if "vim -g" can start the GUI.
 * Used from gui_init() to prepare for starting the GUI.
 * Returns FAIL or OK.
 */
 int
-gui_init_check()
+gui_init_check(void)
 {
 static int result = MAYBE;
 if (result != MAYBE)
 {
 /*
 * This is the call which starts the GUI.
 */
 void
-gui_init()
+gui_init(void)
 {
 win_T	*wp;
 static int	recursive = 0;
 /*
 clip_init(FALSE);
 }
 void
-gui_exit(rc)
+gui_exit(int rc)
-int		rc;
 {
 /* don't free the fonts, it leads to a BUS error
 * richard@whitequeen.com Jul 99 */
 free_highlight_fonts();
 gui.in_use = FALSE;
 * files Vim exits, otherwise there will be a dialog to ask the user what to
 * do.
 * When this function returns, Vim should NOT exit!
 */
 void
-gui_shell_closed()
+gui_shell_closed(void)
 {
 cmdmod_T	    save_cmdmod;
 save_cmdmod = cmdmod;
 * If "fontset" is TRUE, the "font_list" is used as one name for the fontset.
 * Return OK when able to set the font.  When it failed FAIL is returned and
 * the fonts are unchanged.
 */
 int
-gui_init_font(font_list, fontset)
+gui_init_font(char_u *font_list, int fontset UNUSED)
-char_u	*font_list;
-int		fontset UNUSED;
 {
 #define FONTLEN 320
 char_u	font_name[FONTLEN];
 int		font_list_empty = FALSE;
 int		ret = FAIL;
 # ifndef FEAT_GUI_GTK
 /*
 * Try setting 'guifontwide' to a font twice as wide as "name".
 */
 static void
-set_guifontwide(name)
+set_guifontwide(char_u *name)
-char_u	*name;
 {
 int		i = 0;
 char_u	wide_name[FONTLEN + 10]; /* room for 2 * width and '*' */
 char_u	*wp = NULL;
 char_u	*p;
 /*
 * Get the font for 'guifontwide'.
 * Return FAIL for an invalid font name.
 */
 int
-gui_get_wide_font()
+gui_get_wide_font(void)
 {
 GuiFont	font = NOFONT;
 char_u	font_name[FONTLEN];
 char_u	*p;
 return OK;
 }
 #endif
 void
-gui_set_cursor(row, col)
+gui_set_cursor(int row, int col)
-int	    row;
-int	    col;
 {
 gui.row = row;
 gui.col = col;
 }
 /*
 * gui_check_pos - check if the cursor is on the screen.
 */
 static void
-gui_check_pos()
+gui_check_pos(void)
 {
 if (gui.row >= screen_Rows)
 	gui.row = screen_Rows - 1;
 if (gui.col >= screen_Columns)
 	gui.col = screen_Columns - 1;
 * Redraw the cursor if necessary or when forced.
 * Careful: The contents of ScreenLines[] must match what is on the screen,
 * otherwise this goes wrong.  May need to call out_flush() first.
 */
 void
-gui_update_cursor(force, clear_selection)
+gui_update_cursor(
-int		force;		/* when TRUE, update even when not moved */
+int		force,		/* when TRUE, update even when not moved */
-int		clear_selection;/* clear selection under cursor */
+int		clear_selection)/* clear selection under cursor */
 {
 int		cur_width = 0;
 int		cur_height = 0;
 int		old_hl_mask;
 int		idx;
 }
 }
 #if defined(FEAT_MENU) || defined(PROTO)
 void
-gui_position_menu()
+gui_position_menu(void)
 {
 # if !defined(FEAT_GUI_GTK) && !defined(FEAT_GUI_MOTIF)
 if (gui.menu_is_active && gui.in_use)
 	gui_mch_set_menu_pos(0, 0, gui.menu_width, gui.menu_height);
 # endif
 /*
 * Position the various GUI components (text area, menu).  The vertical
 * scrollbars are NOT handled here.  See gui_update_scrollbars().
 */
 static void
-gui_position_components(total_width)
+gui_position_components(int total_width UNUSED)
-int	    total_width UNUSED;
 {
 int	    text_area_x;
 int	    text_area_y;
 int	    text_area_width;
 int	    text_area_height;
 /*
 * Get the width of the widgets and decorations to the side of the text area.
 */
 int
-gui_get_base_width()
+gui_get_base_width(void)
 {
 int	    base_width;
 base_width = 2 * gui.border_offset;
 if (gui.which_scrollbars[SBAR_LEFT])
 /*
 * Get the height of the widgets and decorations above and below the text area.
 */
 int
-gui_get_base_height()
+gui_get_base_height(void)
 {
 int	    base_height;
 base_height = 2 * gui.border_offset;
 if (gui.which_scrollbars[SBAR_BOTTOM])
 /*
 * Should be called after the GUI shell has been resized.  Its arguments are
 * the new width and height of the shell in pixels.
 */
 void
-gui_resize_shell(pixel_width, pixel_height)
+gui_resize_shell(int pixel_width, int pixel_height)
-int		pixel_width;
-int		pixel_height;
 {
 static int	busy = FALSE;
 if (!gui.shell_created)	    /* ignore when still initializing */
 	return;
 /*
 * Check if gui_resize_shell() must be called.
 */
 void
-gui_may_resize_shell()
+gui_may_resize_shell(void)
 {
 int		h, w;
 if (new_pixel_height)
 {
 	gui_resize_shell(w, h);
 }
 }
 int
-gui_get_shellsize()
+gui_get_shellsize(void)
 {
 Rows = gui.num_rows;
 Columns = gui.num_cols;
 return OK;
 }
 * Set the size of the Vim shell according to Rows and Columns.
 * If "fit_to_display" is TRUE then the size may be reduced to fit the window
 * on the screen.
 */
 void
-gui_set_shellsize(mustset, fit_to_display, direction)
+gui_set_shellsize(
-int		mustset UNUSED;		/* set by the user */
+int		mustset UNUSED,		/* set by the user */
-int		fit_to_display;
+int		fit_to_display,
-int		direction;		/* RESIZE_HOR, RESIZE_VER */
+int		direction)		/* RESIZE_HOR, RESIZE_VER */
 {
 int		base_width;
 int		base_height;
 int		width;
 int		height;
 /*
 * Called when Rows and/or Columns has changed.
 */
 void
-gui_new_shellsize()
+gui_new_shellsize(void)
 {
 gui_reset_scroll_region();
 }
 /*
 * Make scroll region cover whole screen.
 */
 void
-gui_reset_scroll_region()
+gui_reset_scroll_region(void)
 {
 gui.scroll_region_top = 0;
 gui.scroll_region_bot = gui.num_rows - 1;
 gui.scroll_region_left = 0;
 gui.scroll_region_right = gui.num_cols - 1;
 }
 void
-gui_start_highlight(mask)
+gui_start_highlight(int mask)
-int	    mask;
 {
 if (mask > HL_ALL)		    /* highlight code */
 	gui.highlight_mask = mask;
 else			    /* mask */
 	gui.highlight_mask |= mask;
 }
 void
-gui_stop_highlight(mask)
+gui_stop_highlight(int mask)
-int	    mask;
 {
 if (mask > HL_ALL)		    /* highlight code */
 	gui.highlight_mask = HL_NORMAL;
 else			    /* mask */
 	gui.highlight_mask &= ~mask;
 /*
 * Clear a rectangular region of the screen from text pos (row1, col1) to
 * (row2, col2) inclusive.
 */
 void
-gui_clear_block(row1, col1, row2, col2)
+gui_clear_block(
-int	    row1;
+int	    row1,
-int	    col1;
+int	    col1,
-int	    row2;
+int	    row2,
-int	    col2;
+int	    col2)
 {
 /* Clear the selection if we are about to write over it */
 clip_may_clear_selection(row1, row2);
 gui_mch_clear_block(row1, col1, row2, col2);
 /*
 * Write code to update the cursor later.  This avoids the need to flush the
 * output buffer before calling gui_update_cursor().
 */
 void
-gui_update_cursor_later()
+gui_update_cursor_later(void)
 {
 OUT_STR(IF_EB("\033|s", ESC_STR "|s"));
 }
 void
-gui_write(s, len)
+gui_write(
-char_u	*s;
+char_u	*s,
-int		len;
+int		len)
 {
 char_u	*p;
 int		arg1 = 0, arg2 = 0;
 int		force_cursor = FALSE;	/* force cursor update */
 int		force_scrollbar = FALSE;
 * When ScreenLines[] is invalid, updating the cursor should not be done, it
 * produces wrong results.  Call gui_dont_update_cursor() before that code and
 * gui_can_update_cursor() afterwards.
 */
 void
-gui_dont_update_cursor()
+gui_dont_update_cursor(void)
 {
 if (gui.in_use)
 {
 	/* Undraw the cursor now, we probably can't do it after the change. */
 	gui_undraw_cursor();
 	can_update_cursor = FALSE;
 }
 }
 void
-gui_can_update_cursor()
+gui_can_update_cursor(void)
 {
 can_update_cursor = TRUE;
 /* No need to update the cursor right now, there is always more output
 * after scrolling. */
 }
 static void
-gui_outstr(s, len)
+gui_outstr(char_u *s, int len)
-char_u  *s;
-int	    len;
 {
 int	    this_len;
 #ifdef FEAT_MBYTE
 int	    cells;
 #endif
 * Output one character (may be one or two display cells).
 * Caller must check for valid "off".
 * Returns FAIL or OK, just like gui_outstr_nowrap().
 */
 static int
-gui_screenchar(off, flags, fg, bg, back)
+gui_screenchar(
-int		off;	    /* Offset from start of screen */
+int		off,	    /* Offset from start of screen */
-int		flags;
+int		flags,
-guicolor_T	fg, bg;	    /* colors for cursor */
+guicolor_T	fg,	    /* colors for cursor */
-int		back;	    /* backup this many chars when using bold trick */
+guicolor_T	bg,	    /* colors for cursor */
+int		back)	    /* backup this many chars when using bold trick */
 {
 #ifdef FEAT_MBYTE
 char_u	buf[MB_MAXBYTES + 1];
 /* Don't draw right halve of a double-width UTF-8 char. "cannot happen" */
 * Output the string at the given screen position.  This is used in place
 * of gui_screenchar() where possible because Pango needs as much context
 * as possible to work nicely.  It's a lot faster as well.
 */
 static int
-gui_screenstr(off, len, flags, fg, bg, back)
+gui_screenstr(
-int		off;	    /* Offset from start of screen */
+int		off,	    /* Offset from start of screen */
-int		len;	    /* string length in screen cells */
+int		len,	    /* string length in screen cells */
-int		flags;
+int		flags,
-guicolor_T	fg, bg;	    /* colors for cursor */
+guicolor_T	fg,	    /* colors for cursor */
-int		back;	    /* backup this many chars when using bold trick */
+guicolor_T	bg,	    /* colors for cursor */
+int		back)	    /* backup this many chars when using bold trick */
 {
 char_u  *buf;
 int	    outlen = 0;
 int	    i;
 int	    retval;
 * it.
 * Returns OK, unless "back" is non-zero and using the bold trick, then return
 * FAIL (the caller should start drawing "back" chars back).
 */
 int
-gui_outstr_nowrap(s, len, flags, fg, bg, back)
+gui_outstr_nowrap(
-char_u	*s;
+char_u	*s,
-int		len;
+int		len,
-int		flags;
+int		flags,
-guicolor_T	fg, bg;	    /* colors for cursor */
+guicolor_T	fg,	    /* colors for cursor */
-int		back;	    /* backup this many chars when using bold trick */
+guicolor_T	bg,	    /* colors for cursor */
+int		back)	    /* backup this many chars when using bold trick */
 {
 long_u	highlight_mask;
 long_u	hl_mask_todo;
 guicolor_T	fg_color;
 guicolor_T	bg_color;
 /*
 * Un-draw the cursor.	Actually this just redraws the character at the given
 * position.  The character just before it too, for when it was in bold.
 */
 void
-gui_undraw_cursor()
+gui_undraw_cursor(void)
 {
 if (gui.cursor_is_valid)
 {
 #ifdef FEAT_HANGULIN
 	if (composing_hangul
 	gui.cursor_is_valid = FALSE;
 }
 }
 void
-gui_redraw(x, y, w, h)
+gui_redraw(
-int		x;
+int		x,
-int		y;
+int		y,
-int		w;
+int		w,
-int		h;
+int		h)
 {
 int		row1, col1, row2, col2;
 row1 = Y_2_ROW(y);
 col1 = X_2_COL(x);
 * from col1 to col2 (inclusive).
 * Return TRUE when the character before the first drawn character has
 * different attributes (may have to be redrawn too).
 */
 int
-gui_redraw_block(row1, col1, row2, col2, flags)
+gui_redraw_block(
-int		row1;
+int		row1,
-int		col1;
+int		col1,
-int		row2;
+int		row2,
-int		col2;
+int		col2,
-int		flags;	/* flags for gui_outstr_nowrap() */
+int		flags)	/* flags for gui_outstr_nowrap() */
 {
 int		old_row, old_col;
 long_u	old_hl_mask;
 int		off;
 sattr_T	first_attr;
 return retval;
 }
 static void
-gui_delete_lines(row, count)
+gui_delete_lines(int row, int count)
-int	    row;
-int	    count;
 {
 if (count <= 0)
 	return;
 if (row + count > gui.scroll_region_bot)
 	}
 }
 }
 static void
-gui_insert_lines(row, count)
+gui_insert_lines(int row, int count)
-int	    row;
-int	    count;
 {
 if (count <= 0)
 	return;
 if (row + count > gui.scroll_region_bot)
 * wtime > 0	    Wait wtime milliseconds for a character.
 * Returns OK if a character was found to be available within the given time,
 * or FAIL otherwise.
 */
 int
-gui_wait_for_chars(wtime)
+gui_wait_for_chars(long wtime)
-long    wtime;
 {
 int	    retval;
 #ifdef FEAT_MENU
 /*
 /*
 * Fill p[4] with mouse coordinates encoded for check_termcode().
 */
 static void
-fill_mouse_coord(p, col, row)
+fill_mouse_coord(char_u *p, int col, int row)
-char_u	*p;
-int		col;
-int		row;
 {
 p[0] = (char_u)(col / 128 + ' ' + 1);
 p[1] = (char_u)(col % 128 + ' ' + 1);
 p[2] = (char_u)(row / 128 + ' ' + 1);
 p[3] = (char_u)(row % 128 + ' ' + 1);
 *			or'ed together: MOUSE_SHIFT | MOUSE_CTRL | MOUSE_ALT.
 * This function will ignore drag events where the mouse has not moved to a new
 * character.
 */
 void
-gui_send_mouse_event(button, x, y, repeated_click, modifiers)
+gui_send_mouse_event(
-int	    button;
+int	    button,
-int	    x;
+int	    x,
-int	    y;
+int	    y,
-int	    repeated_click;
+int	    repeated_click,
-int_u   modifiers;
+int_u   modifiers)
 {
 static int	    prev_row = 0, prev_col = 0;
 static int	    prev_button = -1;
 static int	    num_clicks = 1;
 char_u	    string[10];
 * Convert x and y coordinate to column and row in text window.
 * Corrects for multi-byte character.
 * returns column in "*colp" and row as return value;
 */
 int
-gui_xy2colrow(x, y, colp)
+gui_xy2colrow(int x, int y, int *colp)
-int		x;
-int		y;
-int		*colp;
 {
 int		col = check_col(X_2_COL(x));
 int		row = check_row(Y_2_ROW(y));
 #ifdef FEAT_MBYTE
 #if defined(FEAT_MENU) || defined(PROTO)
 /*
 * Callback function for when a menu entry has been selected.
 */
 void
-gui_menu_cb(menu)
+gui_menu_cb(vimmenu_T *menu)
-vimmenu_T *menu;
 {
 char_u  bytes[sizeof(long_u)];
 /* Don't put events in the input queue now. */
 if (hold_gui_events)
 * Set which components are present.
 * If "oldval" is not NULL, "oldval" is the previous value, the new value is
 * in p_go.
 */
 void
-gui_init_which_components(oldval)
+gui_init_which_components(char_u *oldval UNUSED)
-char_u	*oldval UNUSED;
 {
 #ifdef FEAT_MENU
 static int	prev_menu_is_active = -1;
 #endif
 #ifdef FEAT_TOOLBAR
 /*
 * Return TRUE if the GUI is taking care of the tabline.
 * It may still be hidden if 'showtabline' is zero.
 */
 int
-gui_use_tabline()
+gui_use_tabline(void)
 {
 return gui.in_use && vim_strchr(p_go, GO_TABLINE) != NULL;
 }
 /*
 * Return TRUE if the GUI is showing the tabline.
 * This uses 'showtabline'.
 */
 static int
-gui_has_tabline()
+gui_has_tabline(void)
 {
 if (!gui_use_tabline()
 	    || p_stal == 0
 	    || (p_stal == 1 && first_tabpage->tp_next == NULL))
 	return FALSE;
 /*
 * Update the tabline.
 * This may display/undisplay the tabline and update the labels.
 */
 void
-gui_update_tabline()
+gui_update_tabline(void)
 {
 int	    showit = gui_has_tabline();
 int	    shown = gui_mch_showing_tabline();
 if (!gui.starting && starting == 0)
 /*
 * Get the label or tooltip for tab page "tp" into NameBuff[].
 */
 void
-get_tabline_label(tp, tooltip)
+get_tabline_label(
-tabpage_T	*tp;
+tabpage_T	*tp,
-int		tooltip;	/* TRUE: get tooltip */
+int		tooltip)	/* TRUE: get tooltip */
 {
 int		modified = FALSE;
 char_u	buf[40];
 int		wincount;
 win_T	*wp;
 * Send the event for clicking to select tab page "nr".
 * Returns TRUE if it was done, FALSE when skipped because we are already at
 * that tab page or the cmdline window is open.
 */
 int
-send_tabline_event(nr)
+send_tabline_event(int nr)
-int	    nr;
 {
 char_u string[3];
 if (nr == tabpage_index(curtab))
 	return FALSE;
 /*
 * Send a tabline menu event
 */
 void
-send_tabline_menu_event(tabidx, event)
+send_tabline_menu_event(int tabidx, int event)
-int	    tabidx;
-int	    event;
 {
 char_u	    string[3];
 /* Don't put events in the input queue now. */
 if (hold_gui_events)
 #if defined(FEAT_WINDOWS) || defined(PROTO)
 /*
 * Remove all scrollbars.  Used before switching to another tab page.
 */
 void
-gui_remove_scrollbars()
+gui_remove_scrollbars(void)
 {
 int	    i;
 win_T   *wp;
 for (i = 0; i < 3; i++)
 }
 }
 #endif
 void
-gui_create_scrollbar(sb, type, wp)
+gui_create_scrollbar(scrollbar_T *sb, int type, win_T *wp)
-scrollbar_T	*sb;
-int		type;
-win_T	*wp;
 {
 static int	sbar_ident = 0;
 sb->ident = sbar_ident++;	/* No check for too big, but would it happen? */
 sb->wp = wp;
 /*
 * Find the scrollbar with the given index.
 */
 scrollbar_T *
-gui_find_scrollbar(ident)
+gui_find_scrollbar(long ident)
-long	ident;
 {
 win_T	*wp;
 if (gui.bottom_sbar.ident == ident)
 	return &gui.bottom_sbar;
 * Solution: Do the scrolling right here.  But only when allowed.
 * Ignore the scrollbars while executing an external command or when there
 * are still characters to be processed.
 */
 void
-gui_drag_scrollbar(sb, value, still_dragging)
+gui_drag_scrollbar(scrollbar_T *sb, long value, int still_dragging)
-scrollbar_T	*sb;
-long	value;
-int		still_dragging;
 {
 #ifdef FEAT_WINDOWS
 win_T	*wp;
 #endif
 int		sb_num;
 #if defined(FEAT_AUTOCMD) || defined(FEAT_WINDOWS) || defined(PROTO)
 /*
 * Called when something in the window layout has changed.
 */
 void
-gui_may_update_scrollbars()
+gui_may_update_scrollbars(void)
 {
 if (gui.in_use && starting == 0)
 {
 	out_flush();
 	gui_init_which_components(NULL);
 need_mouse_correct = TRUE;
 }
 #endif
 void
-gui_update_scrollbars(force)
+gui_update_scrollbars(
-int		force;	    /* Force all scrollbars to get updated */
+int		force)	    /* Force all scrollbars to get updated */
 {
 win_T	*wp;
 scrollbar_T	*sb;
 long	val, size, max;		/* need 32 bits here */
 int		which_sb;
 * Enable or disable a scrollbar.
 * Check for scrollbars for vertically split windows which are not enabled
 * sometimes.
 */
 static void
-gui_do_scrollbar(wp, which, enable)
+gui_do_scrollbar(
-win_T	*wp;
+win_T	*wp,
-int		which;	    /* SBAR_LEFT or SBAR_RIGHT */
+int		which,	    /* SBAR_LEFT or SBAR_RIGHT */
-int		enable;	    /* TRUE to enable scrollbar */
+int		enable)	    /* TRUE to enable scrollbar */
 {
 #ifdef FEAT_VERTSPLIT
 int		midcol = curwin->w_wincol + curwin->w_width / 2;
 int		has_midcol = (wp->w_wincol <= midcol
 				     && wp->w_wincol + wp->w_width >= midcol);
 * Scroll a window according to the values set in the globals current_scrollbar
 * and scrollbar_value.  Return TRUE if the cursor in the current window moved
 * or FALSE otherwise.
 */
 int
-gui_do_scroll()
+gui_do_scroll(void)
 {
 win_T	*wp, *save_wp;
 int		i;
 long	nlines;
 pos_T	old_cursor;
 /*
 * Return length of line "lnum" for horizontal scrolling.
 */
 static colnr_T
-scroll_line_len(lnum)
+scroll_line_len(linenr_T lnum)
-linenr_T	lnum;
 {
 char_u	*p;
 colnr_T	col;
 int		w;
 /*
 * Find longest visible line number.  If this is not possible (or not desired,
 * by setting 'h' in "guioptions") then the current line number is returned.
 */
 static linenr_T
-gui_find_longest_lnum()
+gui_find_longest_lnum(void)
 {
 linenr_T ret = 0;
 /* Calculate maximum for horizontal scrollbar.  Check for reasonable
 * line numbers, topline and botline can be invalid when displaying is
 return ret;
 }
 static void
-gui_update_horiz_scrollbar(force)
+gui_update_horiz_scrollbar(int force)
-int		force;
 {
 long	value, size, max;	/* need 32 bit ints here */
 if (!gui.which_scrollbars[SBAR_BOTTOM])
 	return;
 /*
 * Do a horizontal scroll.  Return TRUE if the cursor moved, FALSE otherwise.
 */
 int
-gui_do_horiz_scroll(leftcol, compute_longest_lnum)
+gui_do_horiz_scroll(long_u leftcol, int compute_longest_lnum)
-long_u	leftcol;
-int		compute_longest_lnum;
 {
 /* no wrapping, no scrolling */
 if (curwin->w_p_wrap)
 	return FALSE;
 /*
 * Check that none of the colors are the same as the background color
 */
 void
-gui_check_colors()
+gui_check_colors(void)
 {
 if (gui.norm_pixel == gui.back_pixel || gui.norm_pixel == INVALCOLOR)
 {
 	gui_set_bg_color((char_u *)"White");
 	if (gui.norm_pixel == gui.back_pixel || gui.norm_pixel == INVALCOLOR)
 	    gui_set_fg_color((char_u *)"Black");
 }
 }
 static void
-gui_set_fg_color(name)
+gui_set_fg_color(char_u *name)
-char_u	*name;
 {
 gui.norm_pixel = gui_get_color(name);
 hl_set_fg_color_name(vim_strsave(name));
 }
 static void
-gui_set_bg_color(name)
+gui_set_bg_color(char_u *name)
-char_u	*name;
 {
 gui.back_pixel = gui_get_color(name);
 hl_set_bg_color_name(vim_strsave(name));
 }
 /*
 * Allocate a color by name.
 * Returns INVALCOLOR and gives an error message when failed.
 */
 guicolor_T
-gui_get_color(name)
+gui_get_color(char_u *name)
-char_u	*name;
 {
 guicolor_T	t;
 if (*name == NUL)
 	return INVALCOLOR;
 /*
 * Return the grey value of a color (range 0-255).
 */
 int
-gui_get_lightness(pixel)
+gui_get_lightness(guicolor_T pixel)
-guicolor_T	pixel;
 {
 long_u	rgb = gui_mch_get_rgb(pixel);
 return  (int)(  (((rgb >> 16) & 0xff) * 299)
 		   + (((rgb >> 8) & 0xff) * 587)
 		   +  ((rgb	  & 0xff) * 114)) / 1000;
 }
 #if defined(FEAT_GUI_X11) || defined(PROTO)
 void
-gui_new_scrollbar_colors()
+gui_new_scrollbar_colors(void)
 {
 win_T	*wp;
 /* Nothing to do if GUI hasn't started yet. */
 if (!gui.in_use)
 /*
 * Call this when focus has changed.
 */
 void
-gui_focus_change(in_focus)
+gui_focus_change(int in_focus)
-int		in_focus;
 {
 /*
 * Skip this code to avoid drawing the cursor when debugging and switching
 * between the debugger window and gvim.
 */
 /*
 * Called when the mouse moved (but not when dragging).
 */
 void
-gui_mouse_moved(x, y)
+gui_mouse_moved(int x, int y)
-int		x;
-int		y;
 {
 win_T	*wp;
 char_u	st[8];
 /* Ignore this while still starting up. */
 /*
 * Called when mouse should be moved to window with focus.
 */
 void
-gui_mouse_correct()
+gui_mouse_correct(void)
 {
 int		x, y;
 win_T	*wp = NULL;
 need_mouse_correct = FALSE;
 /*
 * Find window where the mouse pointer "y" coordinate is in.
 */
 static win_T *
-xy2win(x, y)
+xy2win(int x UNUSED, int y UNUSED)
-int		x UNUSED;
-int		y UNUSED;
 {
 #ifdef FEAT_WINDOWS
 int		row;
 int		col;
 win_T	*wp;
 /*
 * ":gui" and ":gvim": Change from the terminal version to the GUI version.
 * File names may be given to redefine the args list.
 */
 void
-ex_gui(eap)
+ex_gui(exarg_T *eap)
-exarg_T	*eap;
 {
 char_u	*arg = eap->arg;
 /*
 * Check for "-f" argument: foreground, don't fork.
 /*
 * Callback function for do_in_runtimepath().
 */
 static void
-gfp_setname(fname, cookie)
+gfp_setname(char_u *fname, void *cookie)
-char_u	*fname;
-void	*cookie;
 {
 char_u	*gfp_buffer = cookie;
 if (STRLEN(fname) >= MAXPATHL)
 	*gfp_buffer = NUL;
 /*
 * Find the path of bitmap "name" with extension "ext" in 'runtimepath'.
 * Return FAIL for failure and OK if buffer[MAXPATHL] contains the result.
 */
 int
-gui_find_bitmap(name, buffer, ext)
+gui_find_bitmap(char_u *name, char_u *buffer, char *ext)
-char_u	*name;
-char_u	*buffer;
-char	*ext;
 {
 if (STRLEN(name) > MAXPATHL - 14)
 	return FAIL;
 vim_snprintf((char *)buffer, MAXPATHL, "bitmaps/%s.%s", name, ext);
 if (do_in_runtimepath(buffer, FALSE, gfp_setname, buffer) == FAIL
 * "ext" and search for it in 'runtimepath'.
 * The result is put in "buffer[MAXPATHL]".  If something fails "buffer"
 * contains "name".
 */
 void
-gui_find_iconfile(name, buffer, ext)
+gui_find_iconfile(char_u *name, char_u *buffer, char *ext)
-char_u	*name;
-char_u	*buffer;
-char	*ext;
 {
 char_u	buf[MAXPATHL + 1];
 expand_env(name, buffer, MAXPATHL);
 if (!mch_isFullName(buffer) && gui_find_bitmap(buffer, buf, ext) == OK)
 # endif
 #endif
 #if defined(FEAT_GUI_GTK) || defined(FEAT_GUI_X11) || defined(PROTO)
 void
-display_errors()
+display_errors(void)
 {
 char_u	*p;
 if (isatty(2))
 	fflush(stderr);
 * For GTK and X11 we check if stderr is not a tty, which means we were
 * (probably) started from the desktop.  Also check stdin, "vim >& file" does
 * allow typing on stdin.
 */
 int
-no_console_input()
+no_console_input(void)
 {
 return ((!gui.in_use || gui.starting)
 # ifndef NO_CONSOLE
 	    && !isatty(0) && !isatty(2)
 # endif
 	|| defined(PROTO)
 /*
 * Update the current window and the screen.
 */
 void
-gui_update_screen()
+gui_update_screen(void)
 {
 #ifdef FEAT_CONCEAL
 linenr_T	conceal_old_cursor_line = 0;
 linenr_T	conceal_new_cursor_line = 0;
 int		conceal_update_lines = FALSE;
 * Get the text to use in a find/replace dialog.  Uses the last search pattern
 * if the argument is empty.
 * Returns an allocated string.
 */
 char_u *
-get_find_dialog_text(arg, wwordp, mcasep)
+get_find_dialog_text(
-char_u	*arg;
+char_u	*arg,
-int		*wwordp;	/* return: TRUE if \< \> found */
+int		*wwordp,	/* return: TRUE if \< \> found */
-int		*mcasep;	/* return: TRUE if \C found */
+int		*mcasep)	/* return: TRUE if \C found */
 {
 char_u	*text;
 if (*arg == NUL)
 	text = last_search_pat();
 /*
 * Concatenate "text" to grow array "gap", escaping "what" with a backslash.
 */
 static void
-concat_esc(gap, text, what)
+concat_esc(garray_T *gap, char_u *text, int what)
-garray_T	*gap;
-char_u	*text;
-int		what;
 {
 while (*text != NUL)
 {
 #ifdef FEAT_MBYTE
 	int l = (*mb_ptr2len)(text);
 /*
 * Handle the press of a button in the find-replace dialog.
 * Return TRUE when something was added to the input buffer.
 */
 int
-gui_do_findrepl(flags, find_text, repl_text, down)
+gui_do_findrepl(
-int		flags;		/* one of FRD_REPLACE, FRD_FINDNEXT, etc. */
+int		flags,		/* one of FRD_REPLACE, FRD_FINDNEXT, etc. */
-char_u	*find_text;
+char_u	*find_text,
-char_u	*repl_text;
+char_u	*repl_text,
-int		down;		/* Search downwards. */
+int		down)		/* Search downwards. */
 {
 garray_T	ga;
 int		i;
 int		type = (flags & FRD_TYPE_MASK);
 char_u	*p;
 /*
 * Jump to the window at specified point (x, y).
 */
 static void
-gui_wingoto_xy(x, y)
+gui_wingoto_xy(int x, int y)
-int x;
-int y;
 {
 int		row = Y_2_ROW(y);
 int		col = X_2_COL(x);
 win_T	*wp;
 * and count of files are given.  Argument "fnames[count]" has full pathnames
 * of dropped files, they will be freed in this function, and caller can't use
 * fnames after call this function.
 */
 void
-gui_handle_drop(x, y, modifiers, fnames, count)
+gui_handle_drop(
-int		x UNUSED;
+int		x UNUSED,
-int		y UNUSED;
+int		y UNUSED,
-int_u	modifiers;
+int_u	modifiers,
-char_u	**fnames;
+char_u	**fnames,
-int		count;
+int		count)
 {
 int		i;
 char_u	*p;
 static int	entered = FALSE;

Mercurial > vim

comparison src/gui.c @ 7821:81794242a275 v7.4.1207