vim: src/gui_gtk_x11.c comparison

comparison src/gui_gtk_x11.c @ 1884:3dd986bfef63 v7.2.181

updated for version 7.2-181

author	vimboss
date	Sun, 17 May 2009 14:24:23 +0000
parents	f10fe14748e2
children	430f555d7d15

comparison

equal deleted inserted replaced

-:c8f343a465a2
+:3dd986bfef63
 /*
 * This should be maybe completely removed.
 * Doesn't seem possible, since check_copy_area() relies on
 * this information.  --danielk
 */
-/*ARGSUSED*/
 static gint
-visibility_event(GtkWidget *widget, GdkEventVisibility *event, gpointer data)
+visibility_event(GtkWidget *widget UNUSED,
+		 GdkEventVisibility *event,
+		 gpointer data UNUSED)
 {
 gui.visibility = event->state;
 /*
 * When we do an gdk_window_copy_area(), and the window is partially
 * obscured, we want to receive an event to tell us whether it worked
 }
 /*
 * Redraw the corresponding portions of the screen.
 */
-/*ARGSUSED*/
 static gint
-expose_event(GtkWidget *widget, GdkEventExpose *event, gpointer data)
+expose_event(GtkWidget *widget UNUSED,
+	     GdkEventExpose *event,
+	     gpointer data UNUSED)
 {
 /* Skip this when the GUI isn't set up yet, will redraw later. */
 if (gui.starting)
 	return FALSE;
 #ifdef FEAT_CLIENTSERVER
 /*
 * Handle changes to the "Comm" property
 */
-/*ARGSUSED2*/
 static gint
-property_event(GtkWidget *widget, GdkEventProperty *event, gpointer data)
+property_event(GtkWidget *widget,
+	       GdkEventProperty *event,
+	       gpointer data UNUSED)
 {
 if (event->type == GDK_PROPERTY_NOTIFY
 	    && event->state == (int)GDK_PROPERTY_NEW_VALUE
 	    && GDK_WINDOW_XWINDOW(event->window) == commWindow
 	    && GET_X_ATOM(event->atom) == commProperty)
 if (blink_state == BLINK_OFF)
 	gui_update_cursor(TRUE, FALSE);
 blink_state = BLINK_NONE;
 }
-/*ARGSUSED*/
 static gint
-blink_cb(gpointer data)
+blink_cb(gpointer data UNUSED)
 {
 if (blink_state == BLINK_ON)
 {
 	gui_undraw_cursor();
 	blink_state = BLINK_OFF;
 	blink_state = BLINK_ON;
 	gui_update_cursor(TRUE, FALSE);
 }
 }
-/*ARGSUSED*/
 static gint
-enter_notify_event(GtkWidget *widget, GdkEventCrossing *event, gpointer data)
+enter_notify_event(GtkWidget *widget UNUSED,
+		   GdkEventCrossing *event UNUSED,
+		   gpointer data UNUSED)
 {
 if (blink_state == BLINK_NONE)
 	gui_mch_start_blink();
 /* make sure keyboard input goes there */
 	gtk_widget_grab_focus(gui.drawarea);
 return FALSE;
 }
-/*ARGSUSED*/
 static gint
-leave_notify_event(GtkWidget *widget, GdkEventCrossing *event, gpointer data)
+leave_notify_event(GtkWidget *widget UNUSED,
+		   GdkEventCrossing *event UNUSED,
+		   gpointer data UNUSED)
 {
 if (blink_state != BLINK_NONE)
 	gui_mch_stop_blink();
 return FALSE;
 }
-/*ARGSUSED*/
 static gint
-focus_in_event(GtkWidget *widget, GdkEventFocus *event, gpointer data)
+focus_in_event(GtkWidget *widget,
+	       GdkEventFocus *event UNUSED,
+	       gpointer data UNUSED)
 {
 gui_focus_change(TRUE);
 if (blink_state == BLINK_NONE)
 	gui_mch_start_blink();
 	gtk_main_quit();
 return TRUE;
 }
-/*ARGSUSED*/
 static gint
-focus_out_event(GtkWidget *widget, GdkEventFocus *event, gpointer data)
+focus_out_event(GtkWidget *widget UNUSED,
+	        GdkEventFocus *event UNUSED,
+		gpointer data UNUSED)
 {
 gui_focus_change(FALSE);
 if (blink_state != BLINK_NONE)
 	gui_mch_stop_blink();
 }
 /*
 * Main keyboard handler:
 */
-/*ARGSUSED*/
 static gint
-key_press_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
+key_press_event(GtkWidget *widget UNUSED,
+		GdkEventKey *event,
+		gpointer data UNUSED)
 {
 #ifdef HAVE_GTK2
 /* 256 bytes is way over the top, but for safety let's reduce it only
 * for GTK+ 2 where we know for sure how large the string might get.
 * (That is, up to 6 bytes + NUL + CSI escapes + safety measure.) */
 return TRUE;
 }
 #if defined(FEAT_XIM) && defined(HAVE_GTK2)
-/*ARGSUSED0*/
 static gboolean
-key_release_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
+key_release_event(GtkWidget *widget UNUSED,
+		  GdkEventKey *event,
+		  gpointer data UNUSED)
 {
 /*
 * GTK+ 2 input methods may do fancy stuff on key release events too.
 * With the default IM for instance, you can enter any UCS code point
 * by holding down CTRL-SHIFT and typing hexadecimal digits.
 /****************************************************************************
 * Selection handlers:
 */
-/*ARGSUSED*/
 static gint
-selection_clear_event(GtkWidget		*widget,
+selection_clear_event(GtkWidget		*widget UNUSED,
 		      GdkEventSelection	*event,
-		      gpointer		user_data)
+		      gpointer		user_data UNUSED)
 {
 if (event->selection == clip_plus.gtk_sel_atom)
 	clip_lose_selection(&clip_plus);
 else
 	clip_lose_selection(&clip_star);
 #define RS_NONE	0	/* selection_received_cb() not called yet */
 #define RS_OK	1	/* selection_received_cb() called and OK */
 #define RS_FAIL	2	/* selection_received_cb() called and failed */
 static int received_selection = RS_NONE;
-/*ARGSUSED*/
 static void
-selection_received_cb(GtkWidget		*widget,
+selection_received_cb(GtkWidget		*widget UNUSED,
 		      GtkSelectionData	*data,
-		      guint		time_,
+		      guint		time_ UNUSED,
-		      gpointer		user_data)
+		      gpointer		user_data UNUSED)
 {
 VimClipboard    *cbd;
 char_u	    *text;
 char_u	    *tmpbuf = NULL;
 #ifdef HAVE_GTK2
 /*
 * Prepare our selection data for passing it to the external selection
 * client.
 */
-/*ARGSUSED*/
 static void
-selection_get_cb(GtkWidget	    *widget,
+selection_get_cb(GtkWidget	    *widget UNUSED,
 		 GtkSelectionData   *selection_data,
 		 guint		    info,
-		 guint		    time_,
+		 guint		    time_ UNUSED,
-		 gpointer	    user_data)
+		 gpointer	    user_data UNUSED)
 {
 char_u	    *string;
 char_u	    *tmpbuf;
 long_u	    tmplen;
 int		    length;
 	dx = x < 0 ? -x : x - gui.drawarea->allocation.width;
 	dy = y < 0 ? -y : y - gui.drawarea->allocation.height;
 	offshoot = dx > dy ? dx : dy;
-	/* Make a linearly declaying timer delay with a threshold of 5 at a
+	/* Make a linearly decaying timer delay with a threshold of 5 at a
 	 * distance of 127 pixels from the main window.
 	 *
 	 * One could think endlessly about the most ergonomic variant here.
 	 * For example it could make sense to calculate the distance from the
 	 * drags start instead...
 }
 /*
 * Timer used to recognize multiple clicks of the mouse button.
 */
-/*ARGSUSED0*/
 static gint
-motion_repeat_timer_cb(gpointer data)
+motion_repeat_timer_cb(gpointer data UNUSED)
 {
 int		    x;
 int		    y;
 GdkModifierType state;
 /* Don't happen again.  We will get reinstalled in the synthetic event
 * if needed -- thus repeating should still work. */
 return FALSE;
 }
-/*ARGSUSED2*/
 static gint
-motion_notify_event(GtkWidget *widget, GdkEventMotion *event, gpointer data)
+motion_notify_event(GtkWidget *widget,
+		    GdkEventMotion *event,
+		    gpointer data UNUSED)
 {
 if (event->is_hint)
 {
 	int		x;
 	int		y;
 /*
 * Mouse button handling.  Note please that we are capturing multiple click's
 * by our own timeout mechanism instead of the one provided by GTK+ itself.
 * This is due to the way the generic VIM code is recognizing multiple clicks.
 */
-/*ARGSUSED2*/
 static gint
-button_press_event(GtkWidget *widget, GdkEventButton *event, gpointer data)
+button_press_event(GtkWidget *widget,
+		   GdkEventButton *event,
+		   gpointer data UNUSED)
 {
 int button;
 int repeated_click = FALSE;
 int x, y;
 int_u vim_modifiers;
 #ifdef HAVE_GTK2
 /*
 * GTK+ 2 doesn't handle mouse buttons 4, 5, 6 and 7 the same way as GTK+ 1.
 * Instead, it abstracts scrolling via the new GdkEventScroll.
 */
-/*ARGSUSED2*/
 static gboolean
-scroll_event(GtkWidget *widget, GdkEventScroll *event, gpointer data)
+scroll_event(GtkWidget *widget,
+	     GdkEventScroll *event,
+	     gpointer data UNUSED)
 {
 int	    button;
 int_u   vim_modifiers;
 if (gtk_socket_id != 0 && !GTK_WIDGET_HAS_FOCUS(widget))
 return TRUE;
 }
 #endif /* HAVE_GTK2 */
-/*ARGSUSED*/
 static gint
-button_release_event(GtkWidget *widget, GdkEventButton *event, gpointer data)
+button_release_event(GtkWidget *widget UNUSED,
+		     GdkEventButton *event,
+		     gpointer data UNUSED)
 {
 int x, y;
 int_u vim_modifiers;
 /* Remove any motion "machine gun" timers used for automatic further
 }
 /*
 * DND receiver.
 */
-/*ARGSUSED2*/
 static void
 drag_data_received_cb(GtkWidget		*widget,
 		      GdkDragContext	*context,
 		      gint		x,
 		      gint		y,
 		      GtkSelectionData	*data,
 		      guint		info,
 		      guint		time_,
-		      gpointer		user_data)
+		      gpointer		user_data UNUSED)
 {
 GdkModifierType state;
 /* Guard against trash */
 if (data->data == NULL
 /*
 * GnomeClient interact callback.  Check for unsaved buffers that cannot
 * be abandoned and pop up a dialog asking the user for confirmation if
 * necessary.
 */
-/*ARGSUSED0*/
 static void
 sm_client_check_changed_any(GnomeClient	    *client,
 			    gint	    key,
 			    GnomeDialogType type,
 			    gpointer	    data)
 /*
 * "save_yourself" signal handler.  Initiate an interaction to ask the user
 * for confirmation if necessary.  Save the current editing session and tell
 * the session manager how to restart Vim.
 */
-/*ARGSUSED1*/
 static gboolean
 sm_client_save_yourself(GnomeClient	    *client,
 			gint		    phase,
 			GnomeSaveStyle	    save_style,
 			gboolean	    shutdown,
 /*
 * Called when the session manager wants us to die.  There isn't much to save
 * here since "save_yourself" has been emitted before (unless serious trouble
 * is happening).
 */
-/*ARGSUSED0*/
 static void
 sm_client_die(GnomeClient *client, gpointer data)
 {
 /* Don't write messages to the GUI anymore */
 full_screen = FALSE;
 # ifdef USE_XSMP
 /*
 * GTK tells us that XSMP needs attention
 */
-/*ARGSUSED*/
 static gboolean
 local_xsmp_handle_requests(source, condition, data)
-GIOChannel		*source;
+GIOChannel		*source UNUSED;
 GIOCondition	condition;
 gpointer		data;
 {
 if (condition == G_IO_IN)
 {
 *
 * The GNOME session support is much cooler anyway.  Unlike this ugly
 * WM_SAVE_YOURSELF hack it actually stores the session...  And yes,
 * it should work with KDE as well.
 */
-/*ARGSUSED1*/
 static GdkFilterReturn
-global_event_filter(GdkXEvent *xev, GdkEvent *event, gpointer data)
+global_event_filter(GdkXEvent *xev,
+		    GdkEvent *event UNUSED,
+		    gpointer data UNUSED)
 {
 XEvent *xevent = (XEvent *)xev;
 if (xevent != NULL
 	    && xevent->type == ClientMessage
 	    && xevent->xclient.message_type == GET_X_ATOM(wm_protocols_atom)
-	    && xevent->xclient.data.l[0] == GET_X_ATOM(save_yourself_atom))
+	    && (long_u)xevent->xclient.data.l[0]
+					    == GET_X_ATOM(save_yourself_atom))
 {
 	out_flush();
 	ml_sync_all(FALSE, FALSE); /* preserve all swap files */
 	/*
 	 * Set the window's WM_COMMAND property, to let the window manager
 # else /* !HAVE_GTK2 */
 /*
 * GDK handler for X ClientMessage events.
 */
-/*ARGSUSED2*/
 static GdkFilterReturn
 gdk_wm_protocols_filter(GdkXEvent *xev, GdkEvent *event, gpointer data)
 {
 /* From example in gdkevents.c/gdk_wm_protocols_filter */
 XEvent *xevent = (XEvent *)xev;
 /*
 * Setup the window icon & xcmdsrv comm after the main window has been realized.
 */
-/*ARGSUSED*/
 static void
-mainwin_realize(GtkWidget *widget, gpointer data)
+mainwin_realize(GtkWidget *widget UNUSED, gpointer data UNUSED)
 {
 /* If you get an error message here, you still need to unpack the runtime
 * archive! */
 #ifdef magick
 # undef magick
 return cursor;
 }
 #ifdef HAVE_GTK_MULTIHEAD
-/*ARGSUSED1*/
 static void
 mainwin_screen_changed_cb(GtkWidget  *widget,
-			  GdkScreen  *previous_screen,
+			  GdkScreen  *previous_screen UNUSED,
-			  gpointer   data)
+			  gpointer   data UNUSED)
 {
 if (!gtk_widget_has_screen(widget))
 	return;
 /*
 * dummy blank cursor.
 *
 * Don't try to set any VIM scrollbar sizes anywhere here. I'm relying on the
 * fact that the main VIM engine doesn't take them into account anywhere.
 */
-/*ARGSUSED1*/
 static void
-drawarea_realize_cb(GtkWidget *widget, gpointer data)
+drawarea_realize_cb(GtkWidget *widget, gpointer data UNUSED)
 {
 GtkWidget *sbar;
 #ifdef FEAT_XIM
 xim_init();
 }
 /*
 * Properly clean up on shutdown.
 */
-/*ARGSUSED0*/
 static void
-drawarea_unrealize_cb(GtkWidget *widget, gpointer data)
+drawarea_unrealize_cb(GtkWidget *widget UNUSED, gpointer data UNUSED)
 {
 /* Don't write messages to the GUI anymore */
 full_screen = FALSE;
 #ifdef FEAT_XIM
 gdk_cursor_destroy(gui.blank_pointer);
 gui.blank_pointer = NULL;
 #endif
 }
-/*ARGSUSED0*/
 static void
-drawarea_style_set_cb(GtkWidget	*widget,
+drawarea_style_set_cb(GtkWidget	*widget UNUSED,
-		      GtkStyle	*previous_style,
+		      GtkStyle	*previous_style UNUSED,
-		      gpointer	data)
+		      gpointer	data UNUSED)
 {
 gui_mch_new_colors();
 }
 /*
 * Callback routine for the "delete_event" signal on the toplevel window.
 * Tries to vim gracefully, or refuses to exit with changed buffers.
 */
-/*ARGSUSED*/
 static gint
-delete_event_cb(GtkWidget *widget, GdkEventAny *event, gpointer data)
+delete_event_cb(GtkWidget *widget UNUSED,
+		GdkEventAny *event UNUSED,
+		gpointer data UNUSED)
 {
 gui_shell_closed();
 return TRUE;
 }
 int min_width;
 int min_height;
 /* At start-up, don't try to set the hints until the initial
 * values have been used (those that dictate our initial size)
-* Let forced (i.e., correct) values thruogh always.
+* Let forced (i.e., correct) values through always.
 */
 if (!(force_width && force_height)  &&  init_window_hints_state > 0)
 {
 	/* Don't do it! */
 	init_window_hints_state = 2;
 static int clicked_page;	    /* page clicked in tab line */
 /*
 * Handle selecting an item in the tab line popup menu.
 */
-/*ARGSUSED*/
 static void
-tabline_menu_handler(GtkMenuItem *item, gpointer user_data)
+tabline_menu_handler(GtkMenuItem *item UNUSED, gpointer user_data)
 {
 /* Add the string cmd into input buffer */
 send_tabline_menu_event(clicked_page, (int)(long)user_data);
 if (gtk_main_level() > 0)
 }
 /*
 * Handle selecting one of the tabs.
 */
-/*ARGSUSED*/
 static void
 on_select_tab(
-	GtkNotebook	*notebook,
+	GtkNotebook	*notebook UNUSED,
-	GtkNotebookPage *page,
+	GtkNotebookPage *page UNUSED,
 	gint		idx,
-	gpointer	data)
+	gpointer	data UNUSED)
 {
 if (!ignore_tabline_evt)
 {
 	if (send_tabline_event(idx + 1) && gtk_main_level() > 0)
 	    gtk_main_quit();
 wm_protocols_atom = gdk_atom_intern("WM_PROTOCOLS", FALSE);
 save_yourself_atom = gdk_atom_intern("WM_SAVE_YOURSELF", FALSE);
 #endif
 if (gtk_socket_id != 0)
-	/* make sure keybord input can go to the drawarea */
+	/* make sure keyboard input can go to the drawarea */
 	GTK_WIDGET_SET_FLAGS(gui.drawarea, GTK_CAN_FOCUS);
 /*
 * Set clipboard specific atoms
 */
 }
 /*
 * This signal informs us about the need to rearrange our sub-widgets.
 */
-/*ARGSUSED*/
 static gint
-form_configure_event(GtkWidget *widget, GdkEventConfigure *event,
+form_configure_event(GtkWidget *widget UNUSED,
-		     gpointer data)
+		     GdkEventConfigure *event,
+		     gpointer data UNUSED)
 {
 int usable_height = event->height;
 /* When in a GtkPlug, we can't guarantee valid heights (as a round
 * no. of char-heights), so we have to manually sanitise them.
 /*
 * Function called when window already closed.
 * We can't do much more here than to trying to preserve what had been done,
 * since the window is already inevitably going away.
 */
-/*ARGSUSED0*/
 static void
-mainwin_destroy_cb(GtkObject *object, gpointer data)
+mainwin_destroy_cb(GtkObject *object UNUSED, gpointer data UNUSED)
 {
 /* Don't write messages to the GUI anymore */
 full_screen = FALSE;
 gui.mainwin  = NULL;
 * Thus set hints at start-up to ensure correct init. size, then a
 * second after the final attempt to reset the real minimum hinst (done by
 * scrollbar init.), actually do the standard hinst and stop the timer.
 * We'll not let the default hints be set while this timer's active.
 */
-/*ARGSUSED*/
 static gboolean
-check_startup_plug_hints(gpointer data)
+check_startup_plug_hints(gpointer data UNUSED)
 {
 if (init_window_hints_state == 1)
 {
 	/* Safe to use normal hints now */
 	init_window_hints_state = 0;
 	if (mask & WidthValue)
 	    Columns = w;
 	if (mask & HeightValue)
 	{
-	    if (p_window > h - 1 || !option_was_set((char_u *)"window"))
+	    if (p_window > (long)h - 1 || !option_was_set((char_u *)"window"))
 		p_window = h - 1;
 	    Rows = h;
 	}
 	pixel_width = (guint)(gui_get_base_width() + Columns * gui.char_width);
 return OK;
 }
-/*ARGSUSED0*/
 void
-gui_mch_exit(int rc)
+gui_mch_exit(int rc UNUSED)
 {
 if (gui.mainwin != NULL)
 	gtk_widget_destroy(gui.mainwin);
 if (gtk_main_level() > 0)
 * DISABLED: When doing ":set lines+=1" this function would first invoke
 * gui_resize_shell() with the old size, then the normal callback would
 * report the new size through form_configure_event().  That caused the window
 * layout to be messed up.
 */
-/*ARGSUSED0*/
 static gboolean
 force_shell_resize_idle(gpointer data)
 {
 if (gui.mainwin != NULL
 	    && GTK_WIDGET_REALIZED(gui.mainwin)
 #endif /* HAVE_GTK2 */
 /*
 * Set the windows size.
 */
-/*ARGSUSED2*/
 void
 gui_mch_set_shellsize(int width, int height,
-		      int min_width,  int min_height,
+		      int min_width UNUSED,  int min_height UNUSED,
-		      int base_width, int base_height,
+		      int base_width UNUSED, int base_height UNUSED,
-		      int direction)
+		      int direction UNUSED)
 {
 #ifndef HAVE_GTK2
 /* Hack: When the form already is at the desired size, the window might
 * have been resized with the mouse.  Force a resize by setting a
 * different size first. */
 *screen_w -= get_menu_tool_width();
 *screen_h -= get_menu_tool_height();
 }
 #if defined(FEAT_TITLE) || defined(PROTO)
-/*ARGSUSED*/
 void
-gui_mch_settitle(char_u *title, char_u *icon)
+gui_mch_settitle(char_u *title, char_u *icon UNUSED)
 {
 # ifdef HAVE_GTK2
 if (title != NULL && output_conv.vc_type != CONV_NONE)
 	title = string_convert(&output_conv, title, NULL);
 # endif
 #ifndef HAVE_GTK2
 /*
 * Get a font structure for highlighting.
 * "cbdata" is a pointer to the global gui structure.
 */
-/*ARGSUSED*/
 static void
 font_sel_ok(GtkWidget *wgt, gpointer cbdata)
 {
 gui_T *vw = (gui_T *)cbdata;
 GtkFontSelectionDialog *fs = (GtkFontSelectionDialog *)vw->fontdlg;
 gtk_widget_hide(vw->fontdlg);
 if (gtk_main_level() > 0)
 	gtk_main_quit();
 }
-/*ARGSUSED*/
 static void
 font_sel_cancel(GtkWidget *wgt, gpointer cbdata)
 {
 gui_T *vw = (gui_T *)cbdata;
 gtk_widget_hide(vw->fontdlg);
 if (gtk_main_level() > 0)
 	gtk_main_quit();
 }
-/*ARGSUSED*/
 static void
 font_sel_destroy(GtkWidget *wgt, gpointer cbdata)
 {
 gui_T *vw = (gui_T *)cbdata;
 #if defined(FEAT_XFONTSET) || defined(PROTO)
 /*
 * Try to load the requested fontset.
 */
-/*ARGSUSED2*/
 GuiFontset
 gui_mch_get_fontset(char_u *name, int report_error, int fixed_width)
 {
 GdkFont *font;
 styled_font[0] = &gui.bold_font;
 styled_font[1] = &gui.ital_font;
 styled_font[2] = &gui.boldital_font;
-/* First free whatever was freviously there. */
+/* First free whatever was previously there. */
 for (i = 0; i < 3; ++i)
 	if (*styled_font[i])
 	{
 	    gdk_font_unref(*styled_font[i]);
 	    *styled_font[i] = NULL;
 /*
 * Initialize Vim to use the font or fontset with the given name.
 * Return FAIL if the font could not be loaded, OK otherwise.
 */
-/*ARGSUSED1*/
 int
-gui_mch_init_font(char_u *font_name, int fontset)
+gui_mch_init_font(char_u *font_name, int fontset UNUSED)
 {
 #ifdef HAVE_GTK2
 PangoFontDescription    *font_desc;
 PangoLayout		    *layout;
 int			    width;
 #if defined(FEAT_EVAL) || defined(PROTO)
 /*
 * Return the name of font "font" in allocated memory.
 */
-/*ARGSUSED*/
 char_u *
-gui_mch_get_fontname(GuiFont font, char_u *name)
+gui_mch_get_fontname(GuiFont font, char_u *name UNUSED)
 {
 # ifdef HAVE_GTK2
 if (font != NOFONT)
 {
 	char	*pangoname = pango_font_description_to_string(font);
 static void
 draw_under(int flags, int row, int col, int cells)
 {
 int			i;
 int			offset;
-const static int	val[8] = {1, 0, 0, 0, 1, 2, 2, 2 };
+static const int	val[8] = {1, 0, 0, 0, 1, 2, 2, 2 };
 int			y = FILL_Y(row + 1) - 1;
 /* Undercurl: draw curl at the bottom of the character cell. */
 if (flags & DRAW_UNDERC)
 {
 #ifdef FEAT_SNIFF
 /*
 * Callback function, used when data is available on the SNiFF connection.
 */
-/* ARGSUSED */
 static void
 sniff_request_cb(
 gpointer	data,
 gint	source_fd,
 GdkInputCondition condition)
 }
 /*
 * Disown the selection.
 */
-/*ARGSUSED*/
 void
-clip_mch_lose_selection(VimClipboard *cbd)
+clip_mch_lose_selection(VimClipboard *cbd UNUSED)
 {
 /* WEIRD: when using NULL to actually disown the selection, we lose the
 * selection the first time we own it. */
 /*
 gtk_selection_owner_set(NULL, cbd->gtk_sel_atom, (guint32)GDK_CURRENT_TIME);
 /*
 * Send the current selection to the clipboard.  Do nothing for X because we
 * will fill in the selection only when requested by another app.
 */
-/*ARGSUSED*/
 void
-clip_mch_set_selection(VimClipboard *cbd)
+clip_mch_set_selection(VimClipboard *cbd UNUSED)
 {
 }
 #if defined(FEAT_MENU) || defined(PROTO)
 	    if (id >= GDK_LAST_CURSOR)
 		id = GDK_LEFT_PTR;
 	    else
 		id &= ~1;	/* they are always even (why?) */
 	}
-	else if (shape < sizeof(mshape_ids) / sizeof(int))
+	else if (shape < (int)(sizeof(mshape_ids) / sizeof(int)))
 	    id = mshape_ids[shape];
 	else
 	    return;
 # ifdef HAVE_GTK_MULTIHEAD
 	c = gdk_cursor_new_for_display(

Mercurial > vim

comparison src/gui_gtk_x11.c @ 1884:3dd986bfef63 v7.2.181