mirror of
https://gitlab.gnome.org/GNOME/gtk.git
synced 2024-12-23 20:30:15 +00:00
docs: use apostrophes in *n't
This commit is contained in:
parent
f0000b2f3d
commit
e34bd4137d
@ -154,7 +154,7 @@ struct encoder {
|
||||
*
|
||||
* - all 1 pixel colors are encoded literally
|
||||
*
|
||||
* - We don't need to support colors with alpha 0 and non-zero
|
||||
* - We don’t need to support colors with alpha 0 and non-zero
|
||||
* color components, as they mean the same on the canvas anyway.
|
||||
* So we use these as special codes:
|
||||
*
|
||||
|
12
gdk/gdk.c
12
gdk/gdk.c
@ -299,7 +299,7 @@ gdk_pre_parse_libgtk_only (void)
|
||||
* Any arguments used by GDK are removed from the array and @argc and @argv are
|
||||
* updated accordingly.
|
||||
*
|
||||
* You shouldn't call this function explicitly if you are using
|
||||
* You shouldn’t call this function explicitly if you are using
|
||||
* gtk_init(), gtk_init_check(), gdk_init(), or gdk_init_check().
|
||||
*
|
||||
* Since: 2.2
|
||||
@ -495,7 +495,7 @@ gdk_init (int *argc, char ***argv)
|
||||
* Before calling gdk_threads_leave() from a thread other
|
||||
* than your main thread, you probably want to call gdk_flush()
|
||||
* to send all pending commands to the windowing system.
|
||||
* (The reason you don't need to do this from the main thread
|
||||
* (The reason you don’t need to do this from the main thread
|
||||
* is that GDK always automatically flushes pending commands
|
||||
* when it runs out of incoming events to process and has
|
||||
* to sleep while waiting for more events.)
|
||||
@ -776,7 +776,7 @@ gdk_threads_init (void)
|
||||
* the GTK+ lock when entering a recursive main loop, the application
|
||||
* must temporarily release its lock as well.
|
||||
*
|
||||
* Most threaded GTK+ apps won't need to use this method.
|
||||
* Most threaded GTK+ apps won’t need to use this method.
|
||||
*
|
||||
* This method must be called before gdk_threads_init(), and cannot
|
||||
* be called multiple times.
|
||||
@ -1041,7 +1041,7 @@ gdk_threads_add_timeout (guint interval,
|
||||
*
|
||||
* A variant of gdk_threads_add_timeout_full() with second-granularity.
|
||||
* See g_timeout_add_seconds_full() for a discussion of why it is
|
||||
* a good idea to use this function if you don't need finer granularity.
|
||||
* a good idea to use this function if you don’t need finer granularity.
|
||||
*
|
||||
* Return value: the ID (greater than 0) of the event source.
|
||||
*
|
||||
@ -1133,10 +1133,10 @@ gdk_set_program_class (const char *program_class)
|
||||
* to gdk_display_open(), gtk_init(), gtk_init_with_args() or
|
||||
* gtk_init_check() in order to take effect.
|
||||
*
|
||||
* Most common GTK+ applications won't ever need to call this. Only
|
||||
* Most common GTK+ applications won’t ever need to call this. Only
|
||||
* applications that do mixed GDK/Xlib calls could want to disable
|
||||
* multidevice support if such Xlib code deals with input devices in
|
||||
* any way and doesn't observe the presence of XInput 2.
|
||||
* any way and doesn’t observe the presence of XInput 2.
|
||||
*
|
||||
* Since: 3.0
|
||||
*/
|
||||
|
@ -88,7 +88,7 @@ gdk_keyboard_ungrab (guint32 time)
|
||||
* Obtains the window underneath the mouse pointer, returning the
|
||||
* location of that window in @win_x, @win_y. Returns %NULL if the
|
||||
* window under the mouse pointer is not known to GDK (if the window
|
||||
* belongs to another application and a #GdkWindow hasn't been created
|
||||
* belongs to another application and a #GdkWindow hasn’t been created
|
||||
* for it with gdk_window_foreign_new())
|
||||
*
|
||||
* NOTE: For multihead-aware widgets or applications use
|
||||
|
@ -1226,8 +1226,8 @@ get_native_grab_event_mask (GdkEventMask grab_mask)
|
||||
* gdk_device_grab:
|
||||
* @device: a #GdkDevice. To get the device you can use gtk_get_current_event_device()
|
||||
* or gdk_event_get_device() if the grab is in reaction to an event. Also, you can use
|
||||
* gdk_device_manager_get_client_pointer() but only in code that isn't triggered by a
|
||||
* #GdkEvent and there aren't other means to get a meaningful #GdkDevice to operate on.
|
||||
* gdk_device_manager_get_client_pointer() but only in code that isn’t triggered by a
|
||||
* #GdkEvent and there aren’t other means to get a meaningful #GdkDevice to operate on.
|
||||
* @window: the #GdkWindow which will own the grab (the grab window)
|
||||
* @grab_ownership: specifies the grab ownership.
|
||||
* @owner_events: if %FALSE then all device events are reported with respect to
|
||||
@ -1244,7 +1244,7 @@ get_native_grab_event_mask (GdkEventMask grab_mask)
|
||||
* elsewhere.
|
||||
* @time_: the timestamp of the event which led to this pointer grab. This
|
||||
* usually comes from the #GdkEvent struct, though %GDK_CURRENT_TIME
|
||||
* can be used if the time isn't known.
|
||||
* can be used if the time isn’t known.
|
||||
*
|
||||
* Grabs the device so that all events coming from this device are passed to
|
||||
* this application until the device is ungrabbed with gdk_device_ungrab(),
|
||||
|
@ -57,7 +57,7 @@
|
||||
* #GdkDeviceManager implementation will be used as the input source.
|
||||
* Otherwise either the core or XInput 1 implementations will be used.
|
||||
*
|
||||
* For simple applications that don't have any special interest in
|
||||
* For simple applications that don’t have any special interest in
|
||||
* input devices, the so-called “client pointer”
|
||||
* provides a reasonable approximation to a simple setup with a single
|
||||
* pointer and keyboard. The device that has been set as the client
|
||||
@ -330,8 +330,8 @@ gdk_device_manager_list_devices (GdkDeviceManager *device_manager,
|
||||
* for this application. In X11, window managers may change this depending on the interaction
|
||||
* pattern under the presence of several pointers.
|
||||
*
|
||||
* You should use this function seldomly, only in code that isn't triggered by a #GdkEvent
|
||||
* and there aren't other means to get a meaningful #GdkDevice to operate on.
|
||||
* You should use this function seldomly, only in code that isn’t triggered by a #GdkEvent
|
||||
* and there aren’t other means to get a meaningful #GdkDevice to operate on.
|
||||
*
|
||||
* Returns: (transfer none): The client pointer. This memory is
|
||||
* owned by GDK and must not be freed or unreferenced.
|
||||
|
@ -2097,7 +2097,7 @@ static GQueue gdk_error_traps = G_QUEUE_INIT;
|
||||
* behavior of exiting the application. It should only be used if it
|
||||
* is not possible to avoid the X error in any other way. Errors are
|
||||
* ignored on all #GdkDisplay currently known to the
|
||||
* #GdkDisplayManager. If you don't care which error happens and just
|
||||
* #GdkDisplayManager. If you don’t care which error happens and just
|
||||
* want to ignore everything, pop with gdk_error_trap_pop_ignored().
|
||||
* If you need the error code, use gdk_error_trap_pop() which may have
|
||||
* to block and wait for the error to arrive from the X server.
|
||||
@ -2206,7 +2206,7 @@ gdk_error_trap_pop_ignored (void)
|
||||
* Removes an error trap pushed with gdk_error_trap_push().
|
||||
* May block until an error has been definitively received
|
||||
* or not received from the X server. gdk_error_trap_pop_ignored()
|
||||
* is preferred if you don't need to know whether an error
|
||||
* is preferred if you don’t need to know whether an error
|
||||
* occurred, because it never has to block. If you don't
|
||||
* need the return value of gdk_error_trap_pop(), use
|
||||
* gdk_error_trap_pop_ignored().
|
||||
|
@ -40,7 +40,7 @@
|
||||
#ifdef GDK_WINDOWING_QUARTZ
|
||||
/* When the gdk_quartz_display_open function is removed We can
|
||||
* immediately include gdkquartzdisplaymanager.h here instead of
|
||||
* gdkprivate-quartz.h so that we won't have to enable -xobjective-c
|
||||
* gdkprivate-quartz.h so that we won’t have to enable -xobjective-c
|
||||
* for the “generic” GDK source code.
|
||||
* #include "quartz/gdkquartzdisplaymanager.h"
|
||||
*/
|
||||
|
@ -47,7 +47,7 @@ G_BEGIN_DECLS
|
||||
* @GDK_ACTION_LINK: Add a link to the data. Note that this is only
|
||||
* useful if source and destination agree on what it means.
|
||||
* @GDK_ACTION_PRIVATE: Special action which tells the source that the
|
||||
* destination will do something that the source doesn't understand.
|
||||
* destination will do something that the source doesn’t understand.
|
||||
* @GDK_ACTION_ASK: Ask the user what to do with the data.
|
||||
*
|
||||
* Used in #GdkDragContext to indicate what the destination
|
||||
|
@ -161,7 +161,7 @@ _gdk_event_queue_append (GdkDisplay *display,
|
||||
* @sibling: Append after this event.
|
||||
* @event: Event to append.
|
||||
*
|
||||
* Appends an event after the specified event, or if it isn't in
|
||||
* Appends an event after the specified event, or if it isn’t in
|
||||
* the queue, onto the tail of the event queue.
|
||||
*
|
||||
* Returns: the newly appended list node.
|
||||
@ -189,7 +189,7 @@ _gdk_event_queue_insert_after (GdkDisplay *display,
|
||||
* @sibling: Append before this event
|
||||
* @event: Event to prepend
|
||||
*
|
||||
* Prepends an event before the specified event, or if it isn't in
|
||||
* Prepends an event before the specified event, or if it isn’t in
|
||||
* the queue, onto the head of the event queue.
|
||||
*
|
||||
* Returns: the newly prepended list node.
|
||||
@ -1633,7 +1633,7 @@ gdk_event_set_source_device (GdkEvent *event,
|
||||
*
|
||||
* This function returns the hardware (slave) #GdkDevice that has
|
||||
* triggered the event, falling back to the virtual (master) device
|
||||
* (as in gdk_event_get_device()) if the event wasn't caused by
|
||||
* (as in gdk_event_get_device()) if the event wasn’t caused by
|
||||
* interaction with a hardware device. This may happen for example
|
||||
* in synthesized crossing events after a #GdkWindow updates its
|
||||
* geometry or a grab is acquired/released.
|
||||
|
@ -415,7 +415,7 @@ typedef enum
|
||||
* this event is synthetic as the pointer might have not left the window.
|
||||
* @GDK_CROSSING_DEVICE_SWITCH: crossing because of a device switch (i.e.
|
||||
* a mouse taking control of the pointer after a touch device), this event
|
||||
* is synthetic as the pointer didn't leave the window.
|
||||
* is synthetic as the pointer didn’t leave the window.
|
||||
*
|
||||
* Specifies the crossing mode for #GdkEventCrossing.
|
||||
*/
|
||||
|
@ -95,7 +95,7 @@
|
||||
* Note that gdk_keymap_translate_keyboard_state() also returns the keyval, i.e. it
|
||||
* goes ahead and performs the keymap lookup in addition to telling you which
|
||||
* effective group/level values were used for the lookup. #GdkEventKey already
|
||||
* contains this keyval, however, so you don't normally need to call
|
||||
* contains this keyval, however, so you don’t normally need to call
|
||||
* gdk_keymap_translate_keyboard_state() just to get the keyval.
|
||||
*/
|
||||
|
||||
@ -493,7 +493,7 @@ gdk_keymap_lookup_key (GdkKeymap *keymap,
|
||||
* actually used for the translation; some keys such as Enter are not
|
||||
* affected by the active keyboard group. The @level is derived from
|
||||
* @state. For convenience, #GdkEventKey already contains the translated
|
||||
* keyval, so this function isn't as useful as you might think.
|
||||
* keyval, so this function isn’t as useful as you might think.
|
||||
*
|
||||
* @consumed_modifiers gives modifiers that should be masked out
|
||||
* from @state when comparing this key press to a hot key. For
|
||||
@ -518,7 +518,7 @@ gdk_keymap_lookup_key (GdkKeymap *keymap,
|
||||
* this allowed accelerators to be stored with irrelevant consumed
|
||||
* modifiers, by doing:
|
||||
* |[<!-- language="C" -->
|
||||
* /* XXX Don't do this XXX */
|
||||
* /* XXX Don’t do this XXX */
|
||||
* if (keyval == accel_keyval &&
|
||||
* (event->state & ~consumed & ALL_ACCELS_MASK) == (accel_mods & ~consumed))
|
||||
* /* Accelerator was pressed */
|
||||
|
@ -34,7 +34,7 @@
|
||||
|
||||
/* LIMITATIONS:
|
||||
*
|
||||
* Offscreen windows can't be the child of a foreign window,
|
||||
* Offscreen windows can’t be the child of a foreign window,
|
||||
* nor contain foreign windows
|
||||
* GDK_POINTER_MOTION_HINT_MASK isn't effective
|
||||
*/
|
||||
|
@ -71,7 +71,7 @@
|
||||
* If the window is not mapped (typically because it’s iconified/minimized
|
||||
* or not on the current workspace), then %NULL will be returned.
|
||||
*
|
||||
* If memory can't be allocated for the return value, %NULL will be returned
|
||||
* If memory can’t be allocated for the return value, %NULL will be returned
|
||||
* instead.
|
||||
*
|
||||
* (In short, there are several ways this function can fail, and if it fails
|
||||
|
@ -182,7 +182,7 @@ intern_atom_internal (const gchar *atom_name, gboolean allocate)
|
||||
* gdk_atom_intern:
|
||||
* @atom_name: a string.
|
||||
* @only_if_exists: if %TRUE, GDK is allowed to not create a new atom, but
|
||||
* just return %GDK_NONE if the requested atom doesn't already
|
||||
* just return %GDK_NONE if the requested atom doesn’t already
|
||||
* exists. Currently, the flag is ignored, since checking the
|
||||
* existance of an atom is as expensive as creating it.
|
||||
*
|
||||
|
@ -195,7 +195,7 @@ _gdk_screen_close (GdkScreen *screen)
|
||||
}
|
||||
|
||||
/* Fallback used when the monitor "at" a point or window
|
||||
* doesn't exist.
|
||||
* doesn’t exist.
|
||||
*/
|
||||
static gint
|
||||
get_nearest_monitor (GdkScreen *screen,
|
||||
@ -443,7 +443,7 @@ gdk_screen_get_font_options (GdkScreen *screen)
|
||||
/**
|
||||
* gdk_screen_set_resolution:
|
||||
* @screen: a #GdkScreen
|
||||
* @dpi: the resolution in “dots per inch”. (Physical inches aren't actually
|
||||
* @dpi: the resolution in “dots per inch”. (Physical inches aren’t actually
|
||||
* involved; the terminology is conventional.)
|
||||
|
||||
* Sets the resolution for font handling on the screen. This is a
|
||||
@ -889,7 +889,7 @@ gdk_screen_get_system_visual (GdkScreen * screen)
|
||||
* The windowing system on which GTK+ is running
|
||||
* may not support this capability, in which case %NULL will
|
||||
* be returned. Even if a non-%NULL value is returned, its
|
||||
* possible that the window’s alpha channel won't be honored
|
||||
* possible that the window’s alpha channel won’t be honored
|
||||
* when displaying the window on the screen: in particular, for
|
||||
* X an appropriate windowing manager and compositing manager
|
||||
* must be running to provide appropriate display.
|
||||
|
@ -1025,10 +1025,10 @@ recompute_visible_regions_internal (GdkWindow *private,
|
||||
*
|
||||
* It will recalculate abs_x/y and the clip regions
|
||||
*
|
||||
* Unless the window didn't change stacking order or size/pos, pass in TRUE
|
||||
* Unless the window didn’t change stacking order or size/pos, pass in TRUE
|
||||
* for recalculate_siblings. (Mostly used internally for the recursion)
|
||||
*
|
||||
* If a child window was removed (and you can't use that child for
|
||||
* If a child window was removed (and you can’t use that child for
|
||||
* recompute_visible_regions), pass in TRUE for recalculate_children on the parent
|
||||
*/
|
||||
static void
|
||||
@ -1053,7 +1053,7 @@ _gdk_window_update_size (GdkWindow *window)
|
||||
|
||||
/* Find the native window that would be just above "child"
|
||||
* in the native stacking order if “child” was a native window
|
||||
* (it doesn't have to be native). If there is no such native
|
||||
* (it doesn’t have to be native). If there is no such native
|
||||
* window inside this native parent then NULL is returned.
|
||||
* If child is NULL, find lowest native window in parent.
|
||||
*/
|
||||
@ -2943,7 +2943,7 @@ gdk_window_free_paint_stack (GdkWindow *window)
|
||||
* Normally this should be completely invisible to applications, as
|
||||
* we automatically flush the windows when required, but this might
|
||||
* be needed if you for instance mix direct native drawing with
|
||||
* gdk drawing. For Gtk widgets that don't use double buffering this
|
||||
* gdk drawing. For Gtk widgets that don’t use double buffering this
|
||||
* will be called automatically before sending the expose event.
|
||||
*
|
||||
* Since: 2.18
|
||||
@ -4152,7 +4152,7 @@ _gdk_window_clear_update_area (GdkWindow *window)
|
||||
* gdk_window_freeze_updates:
|
||||
* @window: a #GdkWindow
|
||||
*
|
||||
* Temporarily freezes a window such that it won't receive expose
|
||||
* Temporarily freezes a window such that it won’t receive expose
|
||||
* events. The window will begin receiving expose events again when
|
||||
* gdk_window_thaw_updates() is called. If gdk_window_freeze_updates()
|
||||
* has been called more than once, gdk_window_thaw_updates() must be called
|
||||
@ -4414,7 +4414,7 @@ gdk_window_constrain_size (GdkGeometry *geometry,
|
||||
*
|
||||
* Return value: (transfer none): the window containing the pointer (as with
|
||||
* gdk_window_at_pointer()), or %NULL if the window containing the
|
||||
* pointer isn't known to GDK
|
||||
* pointer isn’t known to GDK
|
||||
*
|
||||
* Deprecated: 3.0: Use gdk_window_get_device_position() instead.
|
||||
**/
|
||||
@ -4783,7 +4783,7 @@ gdk_window_show_internal (GdkWindow *window, gboolean raise)
|
||||
*
|
||||
* On the X11 platform, in Xlib terms, this function calls
|
||||
* XMapWindow() (it also updates some internal GDK state, which means
|
||||
* that you can't really use XMapWindow() directly on a GDK window).
|
||||
* that you can’t really use XMapWindow() directly on a GDK window).
|
||||
*/
|
||||
void
|
||||
gdk_window_show_unraised (GdkWindow *window)
|
||||
@ -4919,7 +4919,7 @@ gdk_window_invalidate_in_parent (GdkWindow *private)
|
||||
* request to move the window in the Z-order, gdk_window_lower() only
|
||||
* requests the restack, does not guarantee it.
|
||||
*
|
||||
* Note that gdk_window_show() raises the window again, so don't call this
|
||||
* Note that gdk_window_show() raises the window again, so don’t call this
|
||||
* function before gdk_window_show(). (Try gdk_window_show_unraised().)
|
||||
*/
|
||||
void
|
||||
@ -5076,7 +5076,7 @@ gdk_window_show (GdkWindow *window)
|
||||
*
|
||||
* For toplevel windows, withdraws them, so they will no longer be
|
||||
* known to the window manager; for all windows, unmaps them, so
|
||||
* they won't be displayed. Normally done automatically as
|
||||
* they won’t be displayed. Normally done automatically as
|
||||
* part of gtk_widget_hide().
|
||||
*/
|
||||
void
|
||||
@ -5602,7 +5602,7 @@ gdk_window_resize (GdkWindow *window,
|
||||
* Equivalent to calling gdk_window_move() and gdk_window_resize(),
|
||||
* except that both operations are performed at once, avoiding strange
|
||||
* visual effects. (i.e. the user may be able to see the window first
|
||||
* move, then resize, if you don't use gdk_window_move_resize().)
|
||||
* move, then resize, if you don’t use gdk_window_move_resize().)
|
||||
**/
|
||||
void
|
||||
gdk_window_move_resize (GdkWindow *window,
|
||||
@ -6001,7 +6001,7 @@ gdk_window_set_device_cursor (GdkWindow *window,
|
||||
* @height: (out) (allow-none): return location for height of window
|
||||
*
|
||||
* Any of the return location arguments to this function may be %NULL,
|
||||
* if you aren't interested in getting the value of that field.
|
||||
* if you aren’t interested in getting the value of that field.
|
||||
*
|
||||
* The X and Y coordinates returned are relative to the parent window
|
||||
* of @window, which for toplevels usually means relative to the
|
||||
@ -6601,7 +6601,7 @@ gdk_window_merge_child_input_shapes (GdkWindow *window)
|
||||
* Set the bit gravity of the given window to static, and flag it so
|
||||
* all children get static subwindow gravity. This is used if you are
|
||||
* implementing scary features that involve deep knowledge of the
|
||||
* windowing system. Don't worry about it unless you have to.
|
||||
* windowing system. Don’t worry about it unless you have to.
|
||||
*
|
||||
* Return value: %TRUE if the server supports static gravity
|
||||
*/
|
||||
@ -7792,7 +7792,7 @@ _gdk_display_set_window_under_pointer (GdkDisplay *display,
|
||||
* for @window is used for all other windows.
|
||||
* @time_: the timestamp of the event which led to this pointer grab. This usually
|
||||
* comes from a #GdkEventButton struct, though %GDK_CURRENT_TIME can be used if
|
||||
* the time isn't known.
|
||||
* the time isn’t known.
|
||||
*
|
||||
* Grabs the pointer (usually a mouse) so that all events are passed to this
|
||||
* application until the pointer is ungrabbed with gdk_pointer_ungrab(), or
|
||||
@ -9527,7 +9527,7 @@ gdk_window_set_urgency_hint (GdkWindow *window,
|
||||
* has been turned on via gdk_window_set_override_redirect()
|
||||
* since these windows are not resizable by the user.
|
||||
*
|
||||
* Since you can't count on the windowing system doing the
|
||||
* Since you can’t count on the windowing system doing the
|
||||
* constraints for programmatic resizes, you should generally
|
||||
* call gdk_window_constrain_size() yourself to determine
|
||||
* appropriate sizes.
|
||||
@ -9547,7 +9547,7 @@ gdk_window_set_geometry_hints (GdkWindow *window,
|
||||
* @title: title of @window
|
||||
*
|
||||
* Sets the title of a toplevel window, to be displayed in the titlebar.
|
||||
* If you haven't explicitly set the icon name for the window
|
||||
* If you haven’t explicitly set the icon name for the window
|
||||
* (using gdk_window_set_icon_name()), the icon name will be set to
|
||||
* @title as well. @title must be in UTF-8 encoding (as with all
|
||||
* user-readable strings in GDK/GTK+). @title may not be %NULL.
|
||||
@ -9573,7 +9573,7 @@ gdk_window_set_title (GdkWindow *window,
|
||||
* session, all windows with the same title and role are treated as
|
||||
* interchangeable. So if you have two windows with the same title
|
||||
* that should be distinguished for session management purposes, you
|
||||
* should set the role on those windows. It doesn't matter what string
|
||||
* should set the role on those windows. It doesn’t matter what string
|
||||
* you use for the role, as long as you have a different role for each
|
||||
* non-interchangeable kind of window.
|
||||
*
|
||||
@ -9665,9 +9665,9 @@ gdk_window_get_frame_extents (GdkWindow *window,
|
||||
* @override_redirect: %TRUE if window should be override redirect
|
||||
*
|
||||
* An override redirect window is not under the control of the window manager.
|
||||
* This means it won't have a titlebar, won't be minimizable, etc. - it will
|
||||
* This means it won’t have a titlebar, won’t be minimizable, etc. - it will
|
||||
* be entirely under the control of the application. The window manager
|
||||
* can't see the override redirect window at all.
|
||||
* can’t see the override redirect window at all.
|
||||
*
|
||||
* Override redirect should only be used for short-lived temporary
|
||||
* windows, such as popup menus. #GtkMenu uses an override redirect
|
||||
@ -9687,7 +9687,7 @@ gdk_window_set_override_redirect (GdkWindow *window,
|
||||
* @accept_focus: %TRUE if the window should receive input focus
|
||||
*
|
||||
* Setting @accept_focus to %FALSE hints the desktop environment that the
|
||||
* window doesn't want to receive input focus.
|
||||
* window doesn’t want to receive input focus.
|
||||
*
|
||||
* On X, it is the responsibility of the window manager to interpret this
|
||||
* hint. ICCCM-compliant window manager usually respect it.
|
||||
@ -9707,8 +9707,8 @@ gdk_window_set_accept_focus (GdkWindow *window,
|
||||
* @focus_on_map: %TRUE if the window should receive input focus when mapped
|
||||
*
|
||||
* Setting @focus_on_map to %FALSE hints the desktop environment that the
|
||||
* window doesn't want to receive input focus when it is mapped.
|
||||
* focus_on_map should be turned off for windows that aren't triggered
|
||||
* window doesn’t want to receive input focus when it is mapped.
|
||||
* focus_on_map should be turned off for windows that aren’t triggered
|
||||
* interactively (such as popups from network activity).
|
||||
*
|
||||
* On X, it is the responsibility of the window manager to interpret
|
||||
@ -9857,7 +9857,7 @@ gdk_window_deiconify (GdkWindow *window)
|
||||
* On the X11 platform, this function depends on window manager
|
||||
* support, so may have no effect with many window managers. However,
|
||||
* GDK will do the best it can to convince the window manager to stick
|
||||
* the window. For window managers that don't support this operation,
|
||||
* the window. For window managers that don’t support this operation,
|
||||
* there’s nothing you can do to force it to happen.
|
||||
*
|
||||
**/
|
||||
@ -9890,8 +9890,8 @@ gdk_window_unstick (GdkWindow *window)
|
||||
*
|
||||
* On X11, asks the window manager to maximize @window, if the window
|
||||
* manager supports this operation. Not all window managers support
|
||||
* this, and some deliberately ignore it or don't have a concept of
|
||||
* “maximized”; so you can't rely on the maximization actually
|
||||
* this, and some deliberately ignore it or don’t have a concept of
|
||||
* “maximized”; so you can’t rely on the maximization actually
|
||||
* happening. But it will happen with most standard window managers,
|
||||
* and GDK makes a best effort to get it to happen.
|
||||
*
|
||||
@ -9908,13 +9908,13 @@ gdk_window_maximize (GdkWindow *window)
|
||||
* gdk_window_unmaximize:
|
||||
* @window: a toplevel #GdkWindow
|
||||
*
|
||||
* Unmaximizes the window. If the window wasn't maximized, then this
|
||||
* Unmaximizes the window. If the window wasn’t maximized, then this
|
||||
* function does nothing.
|
||||
*
|
||||
* On X11, asks the window manager to unmaximize @window, if the
|
||||
* window manager supports this operation. Not all window managers
|
||||
* support this, and some deliberately ignore it or don't have a
|
||||
* concept of “maximized”; so you can't rely on the unmaximization
|
||||
* support this, and some deliberately ignore it or don’t have a
|
||||
* concept of “maximized”; so you can’t rely on the unmaximization
|
||||
* actually happening. But it will happen with most standard window
|
||||
* managers, and GDK makes a best effort to get it to happen.
|
||||
*
|
||||
@ -9940,7 +9940,7 @@ gdk_window_unmaximize (GdkWindow *window)
|
||||
* On X11, asks the window manager to put @window in a fullscreen
|
||||
* state, if the window manager supports this operation. Not all
|
||||
* window managers support this, and some deliberately ignore it or
|
||||
* don't have a concept of “fullscreen”; so you can't rely on the
|
||||
* don’t have a concept of “fullscreen”; so you can’t rely on the
|
||||
* fullscreenification actually happening. But it will happen with
|
||||
* most standard window managers, and GDK makes a best effort to get
|
||||
* it to happen.
|
||||
@ -9972,7 +9972,7 @@ gdk_window_fullscreen (GdkWindow *window)
|
||||
* If the XINERAMA extension is not available or not usable, this function
|
||||
* has no effect.
|
||||
*
|
||||
* Not all window managers support this, so you can't rely on the fullscreen
|
||||
* Not all window managers support this, so you can’t rely on the fullscreen
|
||||
* window to span over the multiple monitors when #GDK_FULLSCREEN_ON_ALL_MONITORS
|
||||
* is specified.
|
||||
*
|
||||
@ -10024,7 +10024,7 @@ gdk_window_get_fullscreen_mode (GdkWindow *window)
|
||||
* On X11, asks the window manager to move @window out of the fullscreen
|
||||
* state, if the window manager supports this operation. Not all
|
||||
* window managers support this, and some deliberately ignore it or
|
||||
* don't have a concept of “fullscreen”; so you can't rely on the
|
||||
* don’t have a concept of “fullscreen”; so you can’t rely on the
|
||||
* unfullscreenification actually happening. But it will happen with
|
||||
* most standard window managers, and GDK makes a best effort to get
|
||||
* it to happen.
|
||||
@ -10047,8 +10047,8 @@ gdk_window_unfullscreen (GdkWindow *window)
|
||||
*
|
||||
* On X11, asks the window manager to keep @window above, if the window
|
||||
* manager supports this operation. Not all window managers support
|
||||
* this, and some deliberately ignore it or don't have a concept of
|
||||
* “keep above”; so you can't rely on the window being kept above.
|
||||
* this, and some deliberately ignore it or don’t have a concept of
|
||||
* “keep above”; so you can’t rely on the window being kept above.
|
||||
* But it will happen with most standard window managers,
|
||||
* and GDK makes a best effort to get it to happen.
|
||||
*
|
||||
@ -10071,8 +10071,8 @@ gdk_window_set_keep_above (GdkWindow *window,
|
||||
*
|
||||
* On X11, asks the window manager to keep @window below, if the window
|
||||
* manager supports this operation. Not all window managers support
|
||||
* this, and some deliberately ignore it or don't have a concept of
|
||||
* “keep below”; so you can't rely on the window being kept below.
|
||||
* this, and some deliberately ignore it or don’t have a concept of
|
||||
* “keep below”; so you can’t rely on the window being kept below.
|
||||
* But it will happen with most standard window managers,
|
||||
* and GDK makes a best effort to get it to happen.
|
||||
*
|
||||
@ -10184,7 +10184,7 @@ gdk_window_get_decorations(GdkWindow *window,
|
||||
* The @functions argument is the logical OR of values from the
|
||||
* #GdkWMFunction enumeration. If the bitmask includes #GDK_FUNC_ALL,
|
||||
* then the other bits indicate which functions to disable; if
|
||||
* it doesn't include #GDK_FUNC_ALL, it indicates which functions to
|
||||
* it doesn’t include #GDK_FUNC_ALL, it indicates which functions to
|
||||
* enable.
|
||||
*
|
||||
**/
|
||||
@ -10889,7 +10889,7 @@ gdk_window_set_opaque_region (GdkWindow *window,
|
||||
* around their frames for effects like shadows and invisible borders.
|
||||
* Window managers that want to maximize windows or snap to edges need
|
||||
* to know where the extents of the actual frame lie, so that users
|
||||
* don't feel like windows are snapping against random invisible edges.
|
||||
* don’t feel like windows are snapping against random invisible edges.
|
||||
*
|
||||
* Note that this property is automatically updated by GTK+, so this
|
||||
* function should only be used by applications which do not use GTK+
|
||||
|
@ -48,7 +48,7 @@ typedef struct _GdkWindowRedirect GdkWindowRedirect;
|
||||
* @GDK_INPUT_OUTPUT windows are the standard kind of window you might expect.
|
||||
* Such windows receive events and are also displayed on screen.
|
||||
* @GDK_INPUT_ONLY windows are invisible; they are usually placed above other
|
||||
* windows in order to trap or filter the events. You can't draw on
|
||||
* windows in order to trap or filter the events. You can’t draw on
|
||||
* @GDK_INPUT_ONLY windows.
|
||||
*/
|
||||
typedef enum
|
||||
@ -344,8 +344,8 @@ typedef enum
|
||||
* @visual: #GdkVisual for window
|
||||
* @window_type: type of window
|
||||
* @cursor: cursor for the window (see gdk_window_set_cursor())
|
||||
* @wmclass_name: don't use (see gtk_window_set_wmclass())
|
||||
* @wmclass_class: don't use (see gtk_window_set_wmclass())
|
||||
* @wmclass_name: don’t use (see gtk_window_set_wmclass())
|
||||
* @wmclass_class: don’t use (see gtk_window_set_wmclass())
|
||||
* @override_redirect: %TRUE to bypass the window manager
|
||||
* @type_hint: a hint of the function of the window
|
||||
*
|
||||
|
@ -32,7 +32,7 @@
|
||||
* stages of the GLib main loop (prepare, check, dispatch), and make the
|
||||
* appropriate calls into GLib.
|
||||
*
|
||||
* Both cases share a single problem: the OS X API’s don't allow us to
|
||||
* Both cases share a single problem: the OS X API’s don’t allow us to
|
||||
* wait simultaneously for file descriptors and for events. So when we
|
||||
* need to do a blocking wait that includes file descriptor activity, we
|
||||
* push the actual work of calling select() to a helper thread (the
|
||||
@ -53,7 +53,7 @@
|
||||
static int current_loop_level = 0;
|
||||
|
||||
/* Run loop level at which we acquired ownership of the GLib main
|
||||
* loop. See note in run_loop_entry(). -1 means that we don't have
|
||||
* loop. See note in run_loop_entry(). -1 means that we don’t have
|
||||
* ownership
|
||||
*/
|
||||
static int acquired_loop_level = -1;
|
||||
@ -96,7 +96,7 @@ static GPollFD event_poll_fd;
|
||||
/* Current NSEvents that we've gotten from Cocoa but haven't yet converted
|
||||
* to GdkEvents. We wait until our dispatch() function to do the conversion
|
||||
* since the conversion can conceivably cause signals to be emmitted
|
||||
* or other things that shouldn't happen inside a poll function.
|
||||
* or other things that shouldn’t happen inside a poll function.
|
||||
*/
|
||||
static GQueue *current_events;
|
||||
|
||||
|
@ -2275,7 +2275,7 @@ gdk_wayland_window_get_wl_surface (GdkWindow *window)
|
||||
*
|
||||
* A good example would be writing a panel or on-screen-keyboard as an
|
||||
* out-of-process helper - as opposed to having those in the compositor
|
||||
* process. In this case the underlying surface isn't an xdg_shell
|
||||
* process. In this case the underlying surface isn’t an xdg_shell
|
||||
* surface and the panel or OSK client need to identify the wl_surface
|
||||
* as a panel or OSK to the compositor. The assumption is that the
|
||||
* compositor will expose a private interface to the special client
|
||||
|
@ -48,8 +48,8 @@
|
||||
*
|
||||
* As such, the data type conversion from gdk selection targets to OLE2 CF_* data
|
||||
* type specifiers is partially hardwired. Fixing this is complicated by (a) the
|
||||
* fact that the widget’s declared selection types aren't accessible in calls here
|
||||
* that need to declare the corresponding OLE2 data types, and (b) there isn't a
|
||||
* fact that the widget’s declared selection types aren’t accessible in calls here
|
||||
* that need to declare the corresponding OLE2 data types, and (b) there isn’t a
|
||||
* 1-1 correspondence between gdk target types and OLE2 types. The former needs
|
||||
* some redesign in gtk dnd (something a gdk/gtk expert should do; I have tried
|
||||
* and failed!). As an example of the latter: gdk STRING, TEXT, COMPOUND_TEXT map
|
||||
@ -62,7 +62,7 @@
|
||||
* Note that in combination with another hack originated by Archaeopteryx
|
||||
* Software, the text conversions here may go to utf-8 unicode as the standard
|
||||
* within-gtk target or to single-byte ascii when the USE_ACP_TEXT compilation
|
||||
* flag is TRUE. This mode was added to support applications that aren't using
|
||||
* flag is TRUE. This mode was added to support applications that aren’t using
|
||||
* utf-8 across the gtk/gdk API but instead use single-byte ascii according to
|
||||
* the current Windows code page. See gdkim-win32.c for more info on that.
|
||||
*
|
||||
|
@ -26,7 +26,7 @@
|
||||
*/
|
||||
|
||||
/* Cannot use TrackMouseEvent, as the stupid WM_MOUSELEAVE message
|
||||
* doesn't tell us where the mouse has gone. Thus we cannot use it to
|
||||
* doesn’t tell us where the mouse has gone. Thus we cannot use it to
|
||||
* generate a correct GdkNotifyType. Pity, as using TrackMouseEvent
|
||||
* otherwise would make it possible to reliably generate
|
||||
* GDK_LEAVE_NOTIFY events, which would help get rid of those pesky
|
||||
@ -1014,7 +1014,7 @@ apply_event_filters (GdkWindow *window,
|
||||
* with this one. And etc, up the chain until we hit an ancestor that has no
|
||||
* transient owner.
|
||||
*
|
||||
* It would be a good idea if applications don't chain transient windows
|
||||
* It would be a good idea if applications don’t chain transient windows
|
||||
* together. There’s a limit to how much evil GTK can try to shield you
|
||||
* from.
|
||||
*/
|
||||
|
@ -157,9 +157,9 @@ _gdk_other_api_failed (const gchar *where,
|
||||
* Like g_strdup_printf, but to a static buffer. Return value does not
|
||||
* have to be g_free()d. The buffer is of bounded size and reused
|
||||
* cyclically. Thus the return value is valid only until that part of
|
||||
* the buffer happens to get reused. This doesn't matter as this
|
||||
* the buffer happens to get reused. This doesn’t matter as this
|
||||
* function’s return value is used in debugging output right after the call,
|
||||
* and the return value isn't used after that.
|
||||
* and the return value isn’t used after that.
|
||||
*/
|
||||
static gchar *
|
||||
static_printf (const gchar *format,
|
||||
|
@ -116,15 +116,15 @@ end_startup_notification (GdkDisplay *display,
|
||||
|
||||
|
||||
/* This should be fairly long, as it's confusing to users if a startup
|
||||
* ends when it shouldn't (it appears that the startup failed, and
|
||||
* ends when it shouldn’t (it appears that the startup failed, and
|
||||
* they have to relaunch the app). Also the timeout only matters when
|
||||
* there are bugs and apps don't end their own startup sequence.
|
||||
* there are bugs and apps don’t end their own startup sequence.
|
||||
*
|
||||
* This timeout is a "last resort" timeout that ignores whether the
|
||||
* startup sequence has shown activity or not. Metacity and the
|
||||
* tasklist have smarter, and correspondingly able-to-be-shorter
|
||||
* timeouts. The reason our timeout is dumb is that we don't monitor
|
||||
* the sequence (don't use an SnMonitorContext)
|
||||
* timeouts. The reason our timeout is dumb is that we don’t monitor
|
||||
* the sequence (don’t use an SnMonitorContext)
|
||||
*/
|
||||
#define STARTUP_TIMEOUT_LENGTH_SECONDS 30
|
||||
#define STARTUP_TIMEOUT_LENGTH (STARTUP_TIMEOUT_LENGTH_SECONDS * 1000)
|
||||
|
@ -85,7 +85,7 @@ _gdk_x11_device_manager_new (GdkDisplay *display)
|
||||
* Returns the #GdkDevice that wraps the given device ID.
|
||||
*
|
||||
* Returns: (transfer none) (allow-none) (type GdkX11DeviceCore): The #GdkDevice wrapping the device ID,
|
||||
* or %NULL if the given ID doesn't currently represent a device.
|
||||
* or %NULL if the given ID doesn’t currently represent a device.
|
||||
*
|
||||
* Since: 3.2
|
||||
**/
|
||||
|
@ -2474,7 +2474,7 @@ gdk_x11_register_standard_event_type (GdkDisplay *display,
|
||||
|
||||
/* look up the extension name for a given major opcode. grubs around in
|
||||
* xlib to do it since a) it’s already cached there b) XQueryExtension
|
||||
* emits protocol so we can't use it in an error handler.
|
||||
* emits protocol so we can’t use it in an error handler.
|
||||
*/
|
||||
static const char *
|
||||
_gdk_x11_decode_request_code(Display *dpy, int code)
|
||||
@ -2743,7 +2743,7 @@ gdk_x11_display_set_window_scale (GdkDisplay *display,
|
||||
* the error is known to have occurred or not occurred,
|
||||
* so the error code can be returned.
|
||||
*
|
||||
* If you don't need to use the return value,
|
||||
* If you don’t need to use the return value,
|
||||
* gdk_x11_display_error_trap_pop_ignored() would be more efficient.
|
||||
*
|
||||
* See gdk_error_trap_pop() for the all-displays-at-once
|
||||
|
@ -1470,7 +1470,7 @@ xdnd_read_actions (GdkX11DragContext *context_x11)
|
||||
|
||||
/* We have to make sure that the XdndActionList we keep internally
|
||||
* is up to date with the XdndActionList on the source window
|
||||
* because we get no notification, because Xdnd wasn't meant
|
||||
* because we get no notification, because Xdnd wasn’t meant
|
||||
* to continually send actions. So we select on PropertyChangeMask
|
||||
* and add this filter.
|
||||
*/
|
||||
|
@ -403,11 +403,11 @@ gdk_x11_get_xatom_by_name (const gchar *atom_name)
|
||||
*
|
||||
* Returns the name of an X atom for its display. This
|
||||
* function is meant mainly for debugging, so for convenience, unlike
|
||||
* XAtomName() and gdk_atom_name(), the result doesn't need to
|
||||
* XAtomName() and gdk_atom_name(), the result doesn’t need to
|
||||
* be freed.
|
||||
*
|
||||
* Return value: name of the X atom; this string is owned by GDK,
|
||||
* so it shouldn't be modifed or freed.
|
||||
* so it shouldn’t be modifed or freed.
|
||||
*
|
||||
* Since: 2.2
|
||||
**/
|
||||
@ -427,11 +427,11 @@ gdk_x11_get_xatom_name_for_display (GdkDisplay *display,
|
||||
* Returns the name of an X atom for GDK’s default display. This
|
||||
* function is meant mainly for debugging, so for convenience, unlike
|
||||
* XAtomName() and gdk_atom_name(), the result
|
||||
* doesn't need to be freed. Also, this function will never return %NULL,
|
||||
* doesn’t need to be freed. Also, this function will never return %NULL,
|
||||
* even if @xatom is invalid.
|
||||
*
|
||||
* Return value: name of the X atom; this string is owned by GTK+,
|
||||
* so it shouldn't be modifed or freed.
|
||||
* so it shouldn’t be modifed or freed.
|
||||
**/
|
||||
const gchar *
|
||||
gdk_x11_get_xatom_name (Atom xatom)
|
||||
|
@ -1546,7 +1546,7 @@ fetch_net_wm_check_window (GdkScreen *screen)
|
||||
* [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec) specification.
|
||||
*
|
||||
* When using this function, keep in mind that the window manager
|
||||
* can change over time; so you shouldn't use this function in
|
||||
* can change over time; so you shouldn’t use this function in
|
||||
* a way that impacts persistent application state. A common bug
|
||||
* is that your application can start up before the window manager
|
||||
* does when the user logs in, and before the window manager starts
|
||||
|
@ -69,7 +69,7 @@ _gdk_x11_selection_window_destroyed (GdkWindow *window)
|
||||
}
|
||||
|
||||
/* We only pass through those SelectionClear events that actually
|
||||
* reflect changes to the selection owner that we didn't make ourself.
|
||||
* reflect changes to the selection owner that we didn’t make ourself.
|
||||
*/
|
||||
gboolean
|
||||
_gdk_x11_selection_filter_clear_event (XSelectionClearEvent *event)
|
||||
|
@ -477,7 +477,7 @@ _gdk_x11_screen_list_visuals (GdkScreen *screen)
|
||||
* Looks up the #GdkVisual for a particular screen and X Visual ID.
|
||||
*
|
||||
* Returns: (transfer none) (type GdkX11Visual): the #GdkVisual (owned by the screen
|
||||
* object), or %NULL if the visual ID wasn't found.
|
||||
* object), or %NULL if the visual ID wasn’t found.
|
||||
*
|
||||
* Since: 2.2
|
||||
*/
|
||||
|
@ -1187,7 +1187,7 @@ x_event_mask_to_gdk_event_mask (long mask)
|
||||
*
|
||||
* Return value: (transfer full): a #GdkWindow wrapper for the native
|
||||
* window, or %NULL if the window has been destroyed. The wrapper
|
||||
* will be newly created, if one doesn't exist already.
|
||||
* will be newly created, if one doesn’t exist already.
|
||||
*
|
||||
* Since: 2.24
|
||||
*/
|
||||
|
@ -1171,7 +1171,7 @@ gtk_action_is_sensitive (GtkAction *action)
|
||||
* gtk_action_get_sensitive:
|
||||
* @action: the action object
|
||||
*
|
||||
* Returns whether the action itself is sensitive. Note that this doesn't
|
||||
* Returns whether the action itself is sensitive. Note that this doesn’t
|
||||
* necessarily mean effective sensitivity. See gtk_action_is_sensitive()
|
||||
* for that.
|
||||
*
|
||||
@ -1196,7 +1196,7 @@ gtk_action_get_sensitive (GtkAction *action)
|
||||
* @sensitive: %TRUE to make the action sensitive
|
||||
*
|
||||
* Sets the :sensitive property of the action to @sensitive. Note that
|
||||
* this doesn't necessarily mean effective sensitivity. See
|
||||
* this doesn’t necessarily mean effective sensitivity. See
|
||||
* gtk_action_is_sensitive()
|
||||
* for that.
|
||||
*
|
||||
@ -1251,7 +1251,7 @@ gtk_action_is_visible (GtkAction *action)
|
||||
* gtk_action_get_visible:
|
||||
* @action: the action object
|
||||
*
|
||||
* Returns whether the action itself is visible. Note that this doesn't
|
||||
* Returns whether the action itself is visible. Note that this doesn’t
|
||||
* necessarily mean effective visibility. See gtk_action_is_sensitive()
|
||||
* for that.
|
||||
*
|
||||
@ -1276,7 +1276,7 @@ gtk_action_get_visible (GtkAction *action)
|
||||
* @visible: %TRUE to make the action visible
|
||||
*
|
||||
* Sets the :visible property of the action to @visible. Note that
|
||||
* this doesn't necessarily mean effective visibility. See
|
||||
* this doesn’t necessarily mean effective visibility. See
|
||||
* gtk_action_is_visible()
|
||||
* for that.
|
||||
*
|
||||
@ -1995,7 +1995,7 @@ gtk_action_set_accel_group (GtkAction *action,
|
||||
*
|
||||
* Since multiple proxies may independently trigger the installation
|
||||
* of the accelerator, the @action counts the number of times this
|
||||
* function has been called and doesn't remove the accelerator until
|
||||
* function has been called and doesn’t remove the accelerator until
|
||||
* gtk_action_disconnect_accelerator() has been called as many times.
|
||||
*
|
||||
* Since: 2.4
|
||||
|
@ -66,7 +66,7 @@
|
||||
* a custom <accelerator> element, which has attributes named key and
|
||||
* modifiers and allows to specify accelerators. This is similar to the
|
||||
* <accelerator> element of #GtkWidget, the main difference is that
|
||||
* it doesn't allow you to specify a signal.
|
||||
* it doesn’t allow you to specify a signal.
|
||||
*
|
||||
* ## A #GtkDialog UI definition fragment. ##
|
||||
* |[
|
||||
|
@ -727,7 +727,7 @@ gtk_color_selection_unrealize (GtkWidget *widget)
|
||||
}
|
||||
|
||||
/* We override show-all since we have internal widgets that
|
||||
* shouldn't be shown when you call show_all(), like the
|
||||
* shouldn’t be shown when you call show_all(), like the
|
||||
* palette and opacity sliders.
|
||||
*/
|
||||
static void
|
||||
|
@ -1519,7 +1519,7 @@ gtk_font_selection_select_font_desc (GtkFontSelection *fontsel,
|
||||
* @fontsel is inserted in a toplevel window before you call this function.
|
||||
*
|
||||
* Return value: %TRUE if the font could be set successfully; %FALSE if no
|
||||
* such font exists or if the @fontsel doesn't belong to a particular
|
||||
* such font exists or if the @fontsel doesn’t belong to a particular
|
||||
* screen yet.
|
||||
*
|
||||
* Deprecated: 3.2: Use #GtkFontChooser
|
||||
|
@ -249,7 +249,7 @@ gtk_gradient_unref (GtkGradient *gradient)
|
||||
*
|
||||
* If @gradient is resolvable, @resolved_gradient will be filled in
|
||||
* with the resolved gradient as a cairo_pattern_t, and %TRUE will
|
||||
* be returned. Generally, if @gradient can't be resolved, it is
|
||||
* be returned. Generally, if @gradient can’t be resolved, it is
|
||||
* due to it being defined on top of a named color that doesn't
|
||||
* exist in @props.
|
||||
*
|
||||
|
@ -50,7 +50,7 @@ G_GNUC_BEGIN_IGNORE_DEPRECATIONS
|
||||
* from #GtkBox. No further changes are needed, since the default
|
||||
* value of the #GtkOrientable:orientation property is
|
||||
* %GTK_ORIENTATION_HORIZONTAL.
|
||||
* If you don't need first-child or last-child styling, and want your code
|
||||
* If you don’t need first-child or last-child styling, and want your code
|
||||
* to be future-proof, the recommendation is to switch to #GtkGrid instead
|
||||
* of nested boxes. For more information about migrating to #GtkGrid,
|
||||
* see [Migrating from other containers to GtkGrid][gtk-migrating-GtkGrid].
|
||||
|
@ -58,7 +58,7 @@
|
||||
* different sizes and widget states). Icons in an icon factory are named by a
|
||||
* stock ID, which is a simple string identifying the icon. Each #GtkStyle has a
|
||||
* list of #GtkIconFactory derived from the current theme; those icon factories
|
||||
* are consulted first when searching for an icon. If the theme doesn't set a
|
||||
* are consulted first when searching for an icon. If the theme doesn’t set a
|
||||
* particular icon, GTK+ looks for the icon in a list of default icon factories,
|
||||
* maintained by gtk_icon_factory_add_default() and
|
||||
* gtk_icon_factory_remove_default(). Applications with icons should add a default
|
||||
@ -259,7 +259,7 @@ gtk_icon_factory_finalize (GObject *object)
|
||||
* stock ID, which is a simple string identifying the icon. Each
|
||||
* #GtkStyle has a list of #GtkIconFactory<!-- -->s derived from the current
|
||||
* theme; those icon factories are consulted first when searching for
|
||||
* an icon. If the theme doesn't set a particular icon, GTK+ looks for
|
||||
* an icon. If the theme doesn’t set a particular icon, GTK+ looks for
|
||||
* the icon in a list of default icon factories, maintained by
|
||||
* gtk_icon_factory_add_default() and
|
||||
* gtk_icon_factory_remove_default(). Applications with icons should
|
||||
@ -755,7 +755,7 @@ icon_size_lookup_intern (GtkIconSize size,
|
||||
* modified by user preferences for a particular
|
||||
* #GtkSettings. Normally @size would be
|
||||
* #GTK_ICON_SIZE_MENU, #GTK_ICON_SIZE_BUTTON, etc. This function
|
||||
* isn't normally needed, gtk_widget_render_icon_pixbuf() is the usual
|
||||
* isn’t normally needed, gtk_widget_render_icon_pixbuf() is the usual
|
||||
* way to get an icon for rendering, then just look at the size of
|
||||
* the rendered pixbuf. The rendered pixbuf may not even correspond to
|
||||
* the width/height returned by gtk_icon_size_lookup(), because themes
|
||||
@ -787,7 +787,7 @@ gtk_icon_size_lookup_for_settings (GtkSettings *settings,
|
||||
*
|
||||
* Obtains the pixel size of a semantic icon size @size:
|
||||
* #GTK_ICON_SIZE_MENU, #GTK_ICON_SIZE_BUTTON, etc. This function
|
||||
* isn't normally needed, gtk_icon_theme_load_icon() is the usual
|
||||
* isn’t normally needed, gtk_icon_theme_load_icon() is the usual
|
||||
* way to get an icon for rendering, then just look at the size of
|
||||
* the rendered pixbuf. The rendered pixbuf may not even correspond to
|
||||
* the width/height returned by gtk_icon_size_lookup(), because themes
|
||||
@ -1055,7 +1055,7 @@ gtk_icon_set_new (void)
|
||||
* @pixbuf: a #GdkPixbuf
|
||||
*
|
||||
* Creates a new #GtkIconSet with @pixbuf as the default/fallback
|
||||
* source image. If you don't add any additional #GtkIconSource to the
|
||||
* source image. If you don’t add any additional #GtkIconSource to the
|
||||
* icon set, all variants of the icon will be created from @pixbuf,
|
||||
* using scaling, pixelation, etc. as required to adjust the icon size
|
||||
* or make the icon look insensitive/prelighted.
|
||||
@ -1542,12 +1542,12 @@ G_GNUC_END_IGNORE_DEPRECATIONS;
|
||||
* @icon_set: a #GtkIconSet
|
||||
* @context: a #GtkStyleContext
|
||||
* @size: (type int): icon size. A size of (GtkIconSize)-1
|
||||
* means render at the size of the source and don't scale.
|
||||
* means render at the size of the source and don’t scale.
|
||||
*
|
||||
* Renders an icon using gtk_render_icon_pixbuf(). In most cases,
|
||||
* gtk_widget_render_icon_pixbuf() is better, since it automatically provides
|
||||
* most of the arguments from the current widget settings. This
|
||||
* function never returns %NULL; if the icon can't be rendered
|
||||
* function never returns %NULL; if the icon can’t be rendered
|
||||
* (perhaps because an image file fails to load), a default "missing
|
||||
* image" icon will be returned instead.
|
||||
*
|
||||
@ -1573,14 +1573,14 @@ gtk_icon_set_render_icon_pixbuf (GtkIconSet *icon_set,
|
||||
* @icon_set: a #GtkIconSet
|
||||
* @context: a #GtkStyleContext
|
||||
* @size: (type int): icon size. A size of (GtkIconSize)-1
|
||||
* means render at the size of the source and don't scale.
|
||||
* means render at the size of the source and don’t scale.
|
||||
* @scale: the window scale to render for
|
||||
* @for_window: (allow-none): #GdkWindow to optimize drawing for, or %NULL
|
||||
*
|
||||
* Renders an icon using gtk_render_icon_pixbuf() and converts it to a
|
||||
* cairo surface.
|
||||
*
|
||||
* This function never returns %NULL; if the icon can't be rendered
|
||||
* This function never returns %NULL; if the icon can’t be rendered
|
||||
* (perhaps because an image file fails to load), a default "missing
|
||||
* image" icon will be returned instead.
|
||||
*
|
||||
@ -1615,7 +1615,7 @@ gtk_icon_set_render_icon_surface (GtkIconSet *icon_set,
|
||||
* @direction: text direction
|
||||
* @state: widget state
|
||||
* @size: (type int): icon size. A size of (GtkIconSize)-1
|
||||
* means render at the size of the source and don't scale.
|
||||
* means render at the size of the source and don’t scale.
|
||||
* @widget: (allow-none): widget that will display the icon, or %NULL.
|
||||
* The only use that is typically made of this
|
||||
* is to determine the appropriate #GdkScreen.
|
||||
@ -1626,7 +1626,7 @@ gtk_icon_set_render_icon_surface (GtkIconSet *icon_set,
|
||||
* Renders an icon using gtk_style_render_icon(). In most cases,
|
||||
* gtk_widget_render_icon() is better, since it automatically provides
|
||||
* most of the arguments from the current widget settings. This
|
||||
* function never returns %NULL; if the icon can't be rendered
|
||||
* function never returns %NULL; if the icon can’t be rendered
|
||||
* (perhaps because an image file fails to load), a default "missing
|
||||
* image" icon will be returned instead.
|
||||
*
|
||||
@ -2720,7 +2720,7 @@ _gtk_icon_set_invalidate_caches (void)
|
||||
* _gtk_icon_factory_list_ids:
|
||||
*
|
||||
* Gets all known IDs stored in an existing icon factory.
|
||||
* The strings in the returned list aren't copied.
|
||||
* The strings in the returned list aren’t copied.
|
||||
* The list itself should be freed.
|
||||
*
|
||||
* Return value: List of ids in icon factories
|
||||
|
@ -96,7 +96,7 @@ GDK_DEPRECATED_IN_3_10
|
||||
GtkIconSet* gtk_icon_factory_lookup_default (const gchar *stock_id);
|
||||
|
||||
/* Get preferred real size from registered semantic size. Note that
|
||||
* themes SHOULD use this size, but they aren't required to; for size
|
||||
* themes SHOULD use this size, but they aren’t required to; for size
|
||||
* requests and such, you should get the actual pixbuf from the icon
|
||||
* set and see what size was rendered.
|
||||
*
|
||||
|
@ -556,7 +556,7 @@
|
||||
* When selecting an icon source to use, GTK+ will consider text direction most
|
||||
* important, state second, and size third. It will select the best match based on
|
||||
* those criteria. If an attribute matches exactly (e.g. you specified
|
||||
* `PRELIGHT` or specified the size), GTK+ won't modify the image;
|
||||
* `PRELIGHT` or specified the size), GTK+ won’t modify the image;
|
||||
* if the attribute matches with a wildcard, GTK+ will scale or modify the image to
|
||||
* match the state and size the user requested.
|
||||
*
|
||||
@ -1314,7 +1314,7 @@ gtk_rc_style_real_create_style (GtkRcStyle *rc_style)
|
||||
* both redraw and recompute any cached information about its
|
||||
* appearance. As an example, it is used when the default font size
|
||||
* set by the operating system changes. Note that this function
|
||||
* doesn't affect widgets that have a style set explicitly on them
|
||||
* doesn’t affect widgets that have a style set explicitly on them
|
||||
* with gtk_widget_set_style().
|
||||
*
|
||||
* Since: 2.4
|
||||
@ -1404,7 +1404,7 @@ gtk_rc_get_style (GtkWidget *widget)
|
||||
* Creates up a #GtkStyle from styles defined in a RC file by providing
|
||||
* the raw components used in matching. This function may be useful
|
||||
* when creating pseudo-widgets that should be themed like widgets but
|
||||
* don't actually have corresponding GTK+ widgets. An example of this
|
||||
* don’t actually have corresponding GTK+ widgets. An example of this
|
||||
* would be items inside a GNOME canvas widget.
|
||||
*
|
||||
* The action of gtk_rc_get_style() is similar to:
|
||||
|
@ -159,7 +159,7 @@ gtk_stock_add (const GtkStockItem *items,
|
||||
* @items: (array length=n_items): a #GtkStockItem or array of #GtkStockItem
|
||||
* @n_items: number of items
|
||||
*
|
||||
* Same as gtk_stock_add(), but doesn't copy @items, so
|
||||
* Same as gtk_stock_add(), but doesn’t copy @items, so
|
||||
* @items must persist until application exit.
|
||||
*
|
||||
* Deprecated: 3.10
|
||||
|
@ -1282,7 +1282,7 @@ gtk_style_real_set_background (GtkStyle *style,
|
||||
* @state: a state
|
||||
* @size: (type int): the size to render the icon at. A size of
|
||||
* (GtkIconSize)-1 means render at the size of the source and
|
||||
* don't scale.
|
||||
* don’t scale.
|
||||
* @widget: (allow-none): the widget
|
||||
* @detail: (allow-none): a style detail
|
||||
*
|
||||
@ -3853,7 +3853,7 @@ gtk_paint_handle (GtkStyle *style,
|
||||
* Draws an expander as used in #GtkTreeView. @x and @y specify the
|
||||
* center the expander. The size of the expander is determined by the
|
||||
* “expander-size” style property of @widget. (If widget is not
|
||||
* specified or doesn't have an “expander-size” property, an
|
||||
* specified or doesn’t have an “expander-size” property, an
|
||||
* unspecified default size will be used, since the caller doesn't
|
||||
* have sufficient information to position the expander, this is
|
||||
* likely not useful.) The expander is expander_size pixels tall
|
||||
@ -4733,7 +4733,7 @@ gtk_widget_class_path (GtkWidget *widget,
|
||||
* @widget: a #GtkWidget
|
||||
* @stock_id: a stock ID
|
||||
* @size: (type int): a stock size. A size of (GtkIconSize)-1 means
|
||||
* render at the size of the source and don't scale (if there are
|
||||
* render at the size of the source and don’t scale (if there are
|
||||
* multiple source sizes, GTK+ picks one of the available sizes).
|
||||
* @detail: (allow-none): render detail to pass to theme engine
|
||||
*
|
||||
@ -4750,7 +4750,7 @@ gtk_widget_class_path (GtkWidget *widget,
|
||||
* freed after use with g_object_unref().
|
||||
*
|
||||
* Return value: (transfer full): a new pixbuf, or %NULL if the
|
||||
* stock ID wasn't known
|
||||
* stock ID wasn’t known
|
||||
*
|
||||
* Deprecated: 3.0: Use gtk_widget_render_icon_pixbuf() instead.
|
||||
**/
|
||||
|
@ -277,8 +277,8 @@ gtk_symbolic_color_unref (GtkSymbolicColor *color)
|
||||
*
|
||||
* If @color is resolvable, @resolved_color will be filled in
|
||||
* with the resolved color, and %TRUE will be returned. Generally,
|
||||
* if @color can't be resolved, it is due to it being defined on
|
||||
* top of a named color that doesn't exist in @props.
|
||||
* if @color can’t be resolved, it is due to it being defined on
|
||||
* top of a named color that doesn’t exist in @props.
|
||||
*
|
||||
* When @props is %NULL, resolving of named colors will fail, so if
|
||||
* your @color is or references such a color, this function will
|
||||
|
@ -1092,7 +1092,7 @@ gtk_ui_manager_get_accel_group (GtkUIManager *manager)
|
||||
*
|
||||
* Looks up a widget by following a path.
|
||||
* The path consists of the names specified in the XML description of the UI.
|
||||
* separated by '/'. Elements which don't have a name or action attribute in
|
||||
* separated by '/'. Elements which don’t have a name or action attribute in
|
||||
* the XML (e.g. <popup>) can be addressed by their XML element name
|
||||
* (e.g. "popup"). The root element ("/ui") can be omitted in the path.
|
||||
*
|
||||
|
@ -55,7 +55,7 @@ G_GNUC_BEGIN_IGNORE_DEPRECATIONS
|
||||
* gtk_orientable_set_orientation (GTK_ORIENTABLE (object),
|
||||
* GTK_ORIENTATION_VERTICAL);
|
||||
* ]|
|
||||
* If you don't need first-child or last-child styling and want your code
|
||||
* If you don’t need first-child or last-child styling and want your code
|
||||
* to be future-proof, the recommendation is to switch to #GtkGrid instead
|
||||
* of nested boxes. For more information about migrating to #GtkGrid,
|
||||
* see [Migrating from other containers to GtkGrid][gtk-migrating-GtkGrid].
|
||||
|
@ -240,7 +240,7 @@ gtk_fnmatch_intern (const char *pattern,
|
||||
* it matches, nonzero if not.
|
||||
*
|
||||
* GTK+ used to use a old version of GNU fnmatch() that was buggy
|
||||
* in various ways and didn't handle UTF-8. The following is
|
||||
* in various ways and didn’t handle UTF-8. The following is
|
||||
* converted to UTF-8. To simplify the process of making it
|
||||
* correct, this is special-cased to the combinations of flags
|
||||
* that gtkfilesel.c uses.
|
||||
|
@ -44,7 +44,7 @@
|
||||
*
|
||||
* A #GtkAccelGroup represents a group of keyboard accelerators,
|
||||
* typically attached to a toplevel #GtkWindow (with
|
||||
* gtk_window_add_accel_group()). Usually you won't need to create a
|
||||
* gtk_window_add_accel_group()). Usually you won’t need to create a
|
||||
* #GtkAccelGroup directly; instead, when using #GtkUIManager, GTK+
|
||||
* automatically sets up the accelerators for your menus in the ui
|
||||
* manager’s #GtkAccelGroup.
|
||||
|
@ -802,7 +802,7 @@ gtk_accel_map_save (const gchar *file_name)
|
||||
* map entry which is not filtered out
|
||||
*
|
||||
* Loops over the entries in the accelerator map whose accel path
|
||||
* doesn't match any of the filters added with gtk_accel_map_add_filter(),
|
||||
* doesn’t match any of the filters added with gtk_accel_map_add_filter(),
|
||||
* and execute @foreach_func on each. The signature of @foreach_func is
|
||||
* that of #GtkAccelMapForeach, the @changed parameter indicates whether
|
||||
* this accelerator was changed during runtime (thus, would need
|
||||
@ -873,7 +873,7 @@ gtk_accel_map_foreach_unfiltered (gpointer data,
|
||||
* are skipped by gtk_accel_map_foreach().
|
||||
*
|
||||
* This function is intended for GTK+ modules that create their own
|
||||
* menus, but don't want them to be saved into the applications accelerator
|
||||
* menus, but don’t want them to be saved into the applications accelerator
|
||||
* map dump.
|
||||
*/
|
||||
void
|
||||
@ -930,7 +930,7 @@ _gtk_accel_map_remove_group (const gchar *accel_path,
|
||||
* gtk_accel_map_lock_path:
|
||||
* @accel_path: a valid accelerator path
|
||||
*
|
||||
* Locks the given accelerator path. If the accelerator map doesn't yet contain
|
||||
* Locks the given accelerator path. If the accelerator map doesn’t yet contain
|
||||
* an entry for @accel_path, a new one is created.
|
||||
*
|
||||
* Locking an accelerator path prevents its accelerator from being changed
|
||||
@ -1029,7 +1029,7 @@ gtk_accel_map_init (GtkAccelMap *accel_map)
|
||||
*
|
||||
* Gets the singleton global #GtkAccelMap object. This object
|
||||
* is useful only for notification of changes to the accelerator
|
||||
* map via the ::changed signal; it isn't a parameter to the
|
||||
* map via the ::changed signal; it isn’t a parameter to the
|
||||
* other accelerator map functions.
|
||||
*
|
||||
* Return value: (transfer none): the global #GtkAccelMap object
|
||||
|
@ -32,7 +32,7 @@
|
||||
*
|
||||
* The scale settings are used to specify how much the child widget should
|
||||
* expand to fill the space allocated to the #GtkAlignment.
|
||||
* The values can range from 0 (meaning the child doesn't expand at all) to
|
||||
* The values can range from 0 (meaning the child doesn’t expand at all) to
|
||||
* 1 (meaning the child expands to fill all of the available space).
|
||||
*
|
||||
* The align settings are used to place the child widget within the available
|
||||
|
@ -37,7 +37,7 @@
|
||||
* [completion][gtk-assistant-set-page-complete]
|
||||
* and [committed][gtk-assistant-commit] status.
|
||||
*
|
||||
* If you have a case that doesn't quite fit in #GtkAssistants way of
|
||||
* If you have a case that doesn’t quite fit in #GtkAssistants way of
|
||||
* handling buttons, you can use the #GTK_ASSISTANT_PAGE_CUSTOM page
|
||||
* type and handle buttons yourself.
|
||||
*
|
||||
|
@ -64,7 +64,7 @@ G_BEGIN_DECLS
|
||||
* %GTK_ASSISTANT_PAGE_CONFIRM, %GTK_ASSISTANT_PAGE_SUMMARY or
|
||||
* %GTK_ASSISTANT_PAGE_PROGRESS to be correct.
|
||||
*
|
||||
* The Cancel button will only be shown if the page isn't “committed”.
|
||||
* The Cancel button will only be shown if the page isn’t “committed”.
|
||||
* See gtk_assistant_commit() for details.
|
||||
*/
|
||||
typedef enum
|
||||
|
@ -58,7 +58,7 @@ static inline gboolean _gtk_bitmask_intersects (const GtkBitm
|
||||
|
||||
|
||||
/* This is the actual implementation of the functions declared above.
|
||||
* We put it in a separate file so people don't get scared from looking at this
|
||||
* We put it in a separate file so people don’t get scared from looking at this
|
||||
* file when reading source code.
|
||||
*/
|
||||
#include "gtkbitmaskprivateimpl.h"
|
||||
|
@ -130,7 +130,7 @@
|
||||
* gtk_builder_expose_object().
|
||||
*
|
||||
* In general, GtkBuilder allows forward references to objects --
|
||||
* declared in the local xml; an object doesn't have to be constructed
|
||||
* declared in the local xml; an object doesn’t have to be constructed
|
||||
* before it can be referred to. The exception to this rule is that an
|
||||
* object has to be constructed before it can be used as the value of
|
||||
* a construct-only property.
|
||||
|
@ -42,19 +42,19 @@ typedef struct _GtkBuilderPrivate GtkBuilderPrivate;
|
||||
|
||||
/**
|
||||
* GtkBuilderError:
|
||||
* @GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION: A type-func attribute didn't name
|
||||
* @GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION: A type-func attribute didn’t name
|
||||
* a function that returns a #GType.
|
||||
* @GTK_BUILDER_ERROR_UNHANDLED_TAG: The input contained a tag that #GtkBuilder
|
||||
* can't handle.
|
||||
* can’t handle.
|
||||
* @GTK_BUILDER_ERROR_MISSING_ATTRIBUTE: An attribute that is required by
|
||||
* #GtkBuilder was missing.
|
||||
* @GTK_BUILDER_ERROR_INVALID_ATTRIBUTE: #GtkBuilder found an attribute that
|
||||
* it doesn't understand.
|
||||
* it doesn’t understand.
|
||||
* @GTK_BUILDER_ERROR_INVALID_TAG: #GtkBuilder found a tag that
|
||||
* it doesn't understand.
|
||||
* it doesn’t understand.
|
||||
* @GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE: A required property value was
|
||||
* missing.
|
||||
* @GTK_BUILDER_ERROR_INVALID_VALUE: #GtkBuilder couldn't parse
|
||||
* @GTK_BUILDER_ERROR_INVALID_VALUE: #GtkBuilder couldn’t parse
|
||||
* some attribute value.
|
||||
* @GTK_BUILDER_ERROR_VERSION_MISMATCH: The input file requires a newer version
|
||||
* of GTK+.
|
||||
|
@ -1317,7 +1317,7 @@ gtk_button_new_with_label (const gchar *label)
|
||||
*
|
||||
* Creates a new button containing an icon from the current icon theme.
|
||||
*
|
||||
* If the icon name isn't known, a “broken image” icon will be
|
||||
* If the icon name isn’t known, a “broken image” icon will be
|
||||
* displayed instead. If the current icon theme is changed, the icon
|
||||
* will be updated appropriately.
|
||||
*
|
||||
@ -2463,7 +2463,7 @@ gtk_button_get_use_stock (GtkButton *button)
|
||||
*
|
||||
* Sets whether the button will grab focus when it is clicked with the mouse.
|
||||
* Making mouse clicks not grab focus is useful in places like toolbars where
|
||||
* you don't want the keyboard focus removed from the main area of the
|
||||
* you don’t want the keyboard focus removed from the main area of the
|
||||
* application.
|
||||
*
|
||||
* Since: 2.4
|
||||
@ -2731,7 +2731,7 @@ gtk_button_grab_notify (GtkWidget *widget,
|
||||
*
|
||||
* Set the image of @button to the given widget. The image will be
|
||||
* displayed if the label text is %NULL or if
|
||||
* #GtkButton:always-show-image is %TRUE. You don't have to call
|
||||
* #GtkButton:always-show-image is %TRUE. You don’t have to call
|
||||
* gtk_widget_show() on @image yourself.
|
||||
*
|
||||
* Since: 2.6
|
||||
|
@ -3379,7 +3379,7 @@ gtk_calendar_drag_data_get (GtkWidget *widget,
|
||||
|
||||
/* Get/set whether drag_motion requested the drag data and
|
||||
* drag_data_received should thus not actually insert the data,
|
||||
* since the data doesn't result from a drop.
|
||||
* since the data doesn’t result from a drop.
|
||||
*/
|
||||
static void
|
||||
set_status_pending (GdkDragContext *context,
|
||||
|
@ -33,13 +33,13 @@
|
||||
*
|
||||
* The #GtkCellRenderer is a base class of a set of objects used for
|
||||
* rendering a cell to a #cairo_t. These objects are used primarily by
|
||||
* the #GtkTreeView widget, though they aren't tied to them in any
|
||||
* the #GtkTreeView widget, though they aren’t tied to them in any
|
||||
* specific way. It is worth noting that #GtkCellRenderer is not a
|
||||
* #GtkWidget and cannot be treated as such.
|
||||
*
|
||||
* The primary use of a #GtkCellRenderer is for drawing a certain graphical
|
||||
* elements on a #cairo_t. Typically, one cell renderer is used to
|
||||
* draw many cells on the screen. To this extent, it isn't expected that a
|
||||
* draw many cells on the screen. To this extent, it isn’t expected that a
|
||||
* CellRenderer keep any permanent state around. Instead, any state is set
|
||||
* just prior to use using #GObjects property system. Then, the
|
||||
* cell is measured using gtk_cell_renderer_get_size(). Finally, the cell
|
||||
|
@ -55,8 +55,8 @@ typedef enum
|
||||
/**
|
||||
* GtkCellRendererMode:
|
||||
* @GTK_CELL_RENDERER_MODE_INERT: The cell is just for display
|
||||
* and cannot be interacted with. Note that this doesn't mean that eg. the
|
||||
* row being drawn can't be selected -- just that a particular element of
|
||||
* and cannot be interacted with. Note that this doesn’t mean that eg. the
|
||||
* row being drawn can’t be selected -- just that a particular element of
|
||||
* it cannot be individually modified.
|
||||
* @GTK_CELL_RENDERER_MODE_ACTIVATABLE: The cell can be clicked.
|
||||
* @GTK_CELL_RENDERER_MODE_EDITABLE: The cell can be edited or otherwise modified.
|
||||
|
@ -390,7 +390,7 @@ gtk_check_menu_item_toggled (GtkCheckMenuItem *check_menu_item)
|
||||
* “in between” display. Normally you would turn off the inconsistent
|
||||
* state again if the user explicitly selects a setting. This has to be
|
||||
* done manually, gtk_check_menu_item_set_inconsistent() only affects
|
||||
* visual appearance, it doesn't affect the semantics of the widget.
|
||||
* visual appearance, it doesn’t affect the semantics of the widget.
|
||||
*
|
||||
**/
|
||||
void
|
||||
|
@ -128,7 +128,7 @@ static GtkClipboard *clipboard_peek (GdkDisplay *display,
|
||||
|
||||
/* pasteboardChangedOwner is not called immediately, and it's not called
|
||||
* reliably. It is somehow documented in the apple api docs, but the docs
|
||||
* suck and don't really give clear instructions. Therefore we track
|
||||
* suck and don’t really give clear instructions. Therefore we track
|
||||
* changeCount in several places below and clear the clipboard if it
|
||||
* changed.
|
||||
*/
|
||||
|
@ -93,7 +93,7 @@
|
||||
* may take some time. To avoid blocking the user interface, the call
|
||||
* to request the selection, gtk_clipboard_request_contents() takes a
|
||||
* callback that will be called when the contents are received (or
|
||||
* when the request fails.) If you don't want to deal with providing
|
||||
* when the request fails.) If you don’t want to deal with providing
|
||||
* a separate callback, you can also use gtk_clipboard_wait_for_contents().
|
||||
* What this does is run the GLib main loop recursively waiting for
|
||||
* the contents. This can simplify the code flow, but you still have
|
||||
@ -459,7 +459,7 @@ get_clipboard_widget (GdkDisplay *display)
|
||||
* but actually retrieve the actual timestamp from the server.
|
||||
* This is a little slower but allows us to make the guarantee
|
||||
* that the times used by this application will always ascend
|
||||
* and we won't get selections being rejected just because
|
||||
* and we won’t get selections being rejected just because
|
||||
* we are using a correct timestamp from an event, but used
|
||||
* CurrentTime previously.
|
||||
*/
|
||||
@ -1683,7 +1683,7 @@ gtk_clipboard_get_display (GtkClipboard *clipboard)
|
||||
* timeouts, etc, may be dispatched during the wait.
|
||||
*
|
||||
* This function is a little faster than calling
|
||||
* gtk_clipboard_wait_for_text() since it doesn't need to retrieve
|
||||
* gtk_clipboard_wait_for_text() since it doesn’t need to retrieve
|
||||
* the actual text.
|
||||
*
|
||||
* Return value: %TRUE is there is text available, %FALSE otherwise.
|
||||
@ -1716,7 +1716,7 @@ gtk_clipboard_wait_is_text_available (GtkClipboard *clipboard)
|
||||
* timeouts, etc, may be dispatched during the wait.
|
||||
*
|
||||
* This function is a little faster than calling
|
||||
* gtk_clipboard_wait_for_rich_text() since it doesn't need to retrieve
|
||||
* gtk_clipboard_wait_for_rich_text() since it doesn’t need to retrieve
|
||||
* the actual text.
|
||||
*
|
||||
* Return value: %TRUE is there is rich text available, %FALSE otherwise.
|
||||
@ -1754,7 +1754,7 @@ gtk_clipboard_wait_is_rich_text_available (GtkClipboard *clipboard,
|
||||
* timeouts, etc, may be dispatched during the wait.
|
||||
*
|
||||
* This function is a little faster than calling
|
||||
* gtk_clipboard_wait_for_image() since it doesn't need to retrieve
|
||||
* gtk_clipboard_wait_for_image() since it doesn’t need to retrieve
|
||||
* the actual image data.
|
||||
*
|
||||
* Return value: %TRUE is there is an image available, %FALSE otherwise.
|
||||
@ -1789,7 +1789,7 @@ gtk_clipboard_wait_is_image_available (GtkClipboard *clipboard)
|
||||
* timeouts, etc, may be dispatched during the wait.
|
||||
*
|
||||
* This function is a little faster than calling
|
||||
* gtk_clipboard_wait_for_uris() since it doesn't need to retrieve
|
||||
* gtk_clipboard_wait_for_uris() since it doesn’t need to retrieve
|
||||
* the actual URI data.
|
||||
*
|
||||
* Return value: %TRUE is there is an URI list available, %FALSE otherwise.
|
||||
@ -1822,7 +1822,7 @@ gtk_clipboard_wait_is_uris_available (GtkClipboard *clipboard)
|
||||
* @n_targets: (out): location to store number of items in @targets.
|
||||
*
|
||||
* Returns a list of targets that are present on the clipboard, or %NULL
|
||||
* if there aren't any targets available. The returned list must be
|
||||
* if there aren’t any targets available. The returned list must be
|
||||
* freed with g_free().
|
||||
* This function waits for the data to be received using the main
|
||||
* loop, so events, timeouts, etc, may be dispatched during the wait.
|
||||
|
@ -5398,7 +5398,7 @@ gtk_combo_box_get_entry_text_column (GtkComboBox *combo_box)
|
||||
*
|
||||
* Sets whether the combo box will grab focus when it is clicked with
|
||||
* the mouse. Making mouse clicks not grab focus is useful in places
|
||||
* like toolbars where you don't want the keyboard focus removed from
|
||||
* like toolbars where you don’t want the keyboard focus removed from
|
||||
* the main area of the application.
|
||||
*
|
||||
* Since: 2.6
|
||||
|
@ -1458,7 +1458,7 @@ gtk_container_get_property (GObject *object,
|
||||
*
|
||||
* The border width of a container is the amount of space to leave
|
||||
* around the outside of the container. The only exception to this is
|
||||
* #GtkWindow; because toplevel windows can't leave space outside,
|
||||
* #GtkWindow; because toplevel windows can’t leave space outside,
|
||||
* they leave the space inside. The border is added on all sides of
|
||||
* the container. To add space to only one side, one approach is to
|
||||
* create a #GtkAlignment widget, call gtk_widget_set_size_request()
|
||||
@ -1514,7 +1514,7 @@ gtk_container_get_border_width (GtkContainer *container)
|
||||
* consider functions such as gtk_box_pack_start() and
|
||||
* gtk_grid_attach() as an alternative to gtk_container_add() in
|
||||
* those cases. A widget may be added to only one container at a time;
|
||||
* you can't place the same widget inside two different containers.
|
||||
* you can’t place the same widget inside two different containers.
|
||||
*
|
||||
* Note that some containers, such as #GtkScrolledWindow or #GtkListBox,
|
||||
* may add intermediate children between the added widget and the
|
||||
@ -1555,7 +1555,7 @@ gtk_container_add (GtkContainer *container,
|
||||
* may be the last reference held; so removing a widget from its
|
||||
* container can destroy that widget. If you want to use @widget
|
||||
* again, you need to add a reference to it while it’s not inside
|
||||
* a container, using g_object_ref(). If you don't want to use @widget
|
||||
* a container, using g_object_ref(). If you don’t want to use @widget
|
||||
* again it’s usually more efficient to simply destroy it directly
|
||||
* using gtk_widget_destroy() since this will remove it from the
|
||||
* container and help break any circular reference count cycles.
|
||||
@ -1591,7 +1591,7 @@ _gtk_container_dequeue_resize_handler (GtkContainer *container)
|
||||
* will be passed to the container’s parent, queued for later execution
|
||||
* or executed immediately.
|
||||
*
|
||||
* Deprecated: 3.12: Resize modes are deprecated. They aren't necessary
|
||||
* Deprecated: 3.12: Resize modes are deprecated. They aren’t necessary
|
||||
* anymore since frame clocks and might introduce obscure bugs if
|
||||
* used.
|
||||
**/
|
||||
@ -1630,7 +1630,7 @@ gtk_container_set_resize_mode (GtkContainer *container,
|
||||
*
|
||||
* Return value: the current resize mode
|
||||
*
|
||||
* Deprecated: 3.12: Resize modes are deprecated. They aren't necessary
|
||||
* Deprecated: 3.12: Resize modes are deprecated. They aren’t necessary
|
||||
* anymore since frame clocks and might introduce obscure bugs if
|
||||
* used.
|
||||
**/
|
||||
@ -2113,7 +2113,7 @@ gtk_container_class_handle_border_width (GtkContainerClass *klass)
|
||||
*
|
||||
* Invokes @callback on each child of @container, including children
|
||||
* that are considered “internal” (implementation details of the
|
||||
* container). “Internal” children generally weren't added by the user
|
||||
* container). “Internal” children generally weren’t added by the user
|
||||
* of the container, but were added by the container implementation
|
||||
* itself. Most applications should use gtk_container_foreach(),
|
||||
* rather than gtk_container_forall().
|
||||
@ -2914,7 +2914,7 @@ gtk_container_focus_sort_left_right (GtkContainer *container,
|
||||
* @direction: focus direction
|
||||
* @old_focus: (allow-none): widget to use for the starting position, or %NULL
|
||||
* to determine this automatically.
|
||||
* (Note, this argument isn't used for GTK_DIR_TAB_*,
|
||||
* (Note, this argument isn’t used for GTK_DIR_TAB_*,
|
||||
* which is the only @direction we use currently,
|
||||
* so perhaps this argument should be removed)
|
||||
*
|
||||
@ -2922,7 +2922,7 @@ gtk_container_focus_sort_left_right (GtkContainer *container,
|
||||
* direction type @direction.
|
||||
*
|
||||
* Return value: a copy of @children, sorted in correct focusing order,
|
||||
* with children that aren't suitable for focusing in this direction
|
||||
* with children that aren’t suitable for focusing in this direction
|
||||
* removed.
|
||||
**/
|
||||
GList *
|
||||
@ -3043,7 +3043,7 @@ chain_widget_destroyed (GtkWidget *widget,
|
||||
* In principle each widget in the chain should be a descendant of the
|
||||
* container, but this is not enforced by this method, since it’s allowed
|
||||
* to set the focus chain before you pack the widgets, or have a widget
|
||||
* in the chain that isn't always packed. The necessary checks are done
|
||||
* in the chain that isn’t always packed. The necessary checks are done
|
||||
* when the focus chain is actually traversed.
|
||||
**/
|
||||
void
|
||||
@ -3459,7 +3459,7 @@ gtk_container_should_propagate_draw (GtkContainer *container,
|
||||
* cairo_restore() before calling this function.
|
||||
*
|
||||
* When a container receives a call to the draw function, it must send
|
||||
* synthetic #GtkWidget::draw calls to all children that don't have their
|
||||
* synthetic #GtkWidget::draw calls to all children that don’t have their
|
||||
* own #GdkWindows. This function provides a convenient way of doing this.
|
||||
* A container, when it receives a call to its #GtkWidget::draw function,
|
||||
* calls gtk_container_propagate_draw() once for each child, passing in
|
||||
|
@ -63,7 +63,7 @@ gboolean _gtk_css_parser_is_string (GtkCssParser *parser
|
||||
* signal an error. _read_foo() will modify the data pointer and position it at
|
||||
* the first token that is broken and emit an error about the failure.
|
||||
* So only call _read_foo() when you know that you are reading a foo. _try_foo()
|
||||
* however is fine to call if you don't know yet if the token is a foo or a bar,
|
||||
* however is fine to call if you don’t know yet if the token is a foo or a bar,
|
||||
* you can _try_bar() if try_foo() failed.
|
||||
*/
|
||||
gboolean _gtk_css_parser_try (GtkCssParser *parser,
|
||||
|
@ -564,7 +564,7 @@
|
||||
* be tiled to fill the area, and scaled to fit it exactly
|
||||
* a whole number of times.
|
||||
* If the value of this property is 'space', the image slice will
|
||||
* be tiled to fill the area, and if it doesn't fit it exactly a whole
|
||||
* be tiled to fill the area, and if it doesn’t fit it exactly a whole
|
||||
* number of times, the extra space is distributed as padding around
|
||||
* the slices.
|
||||
* If two options are specified, the first one affects
|
||||
@ -811,7 +811,7 @@
|
||||
* <entry>[repeat|no-repeat]</entry>
|
||||
* <entry>internal</entry>
|
||||
* <entry><literallayout>background-repeat: no-repeat;</literallayout>
|
||||
* If not specified, the style doesn't respect the CSS3
|
||||
* If not specified, the style doesn’t respect the CSS3
|
||||
* specification, since the background will be
|
||||
* stretched to fill the area.
|
||||
* </entry>
|
||||
|
@ -443,7 +443,7 @@ _gtk_css_style_property_affects_size (GtkCssStyleProperty *property)
|
||||
*
|
||||
* Queries if the given @property affects the default font. This is
|
||||
* used for optimizations inside GTK, where clearing pango
|
||||
* layouts can be avoided if the font doesn't change.
|
||||
* layouts can be avoided if the font doesn’t change.
|
||||
*
|
||||
* Returns: %TRUE if the property affects the font.
|
||||
**/
|
||||
|
@ -946,7 +946,7 @@ gtk_dialog_add_action_widget (GtkDialog *dialog,
|
||||
* clicking the button will emit the #GtkDialog::response signal with
|
||||
* the given @response_id. The button is appended to the end of the
|
||||
* dialog’s action area. The button widget is returned, but usually
|
||||
* you don't need it.
|
||||
* you don’t need it.
|
||||
*
|
||||
* Return value: (transfer none): the #GtkButton widget that was added
|
||||
**/
|
||||
@ -1216,7 +1216,7 @@ run_destroy_handler (GtkDialog *dialog, gpointer data)
|
||||
* will be modal. You can force gtk_dialog_run() to return at any time by
|
||||
* calling gtk_dialog_response() to emit the ::response signal. Destroying
|
||||
* the dialog during gtk_dialog_run() is a very bad idea, because your
|
||||
* post-run code won't know whether the dialog was destroyed or not.
|
||||
* post-run code won’t know whether the dialog was destroyed or not.
|
||||
*
|
||||
* After gtk_dialog_run() returns, you are responsible for hiding or
|
||||
* destroying the dialog if you wish to do so.
|
||||
@ -1368,7 +1368,7 @@ gtk_dialog_get_widget_for_response (GtkDialog *dialog,
|
||||
* of a dialog.
|
||||
*
|
||||
* Returns: the response id of @widget, or %GTK_RESPONSE_NONE
|
||||
* if @widget doesn't have a response id set.
|
||||
* if @widget doesn’t have a response id set.
|
||||
*
|
||||
* Since: 2.8
|
||||
*/
|
||||
|
@ -1181,7 +1181,7 @@ gtk_drag_begin_idle (gpointer arg)
|
||||
return G_SOURCE_REMOVE;
|
||||
}
|
||||
/* Fake protocol to let us call GdkNSView gdkWindow without including
|
||||
* gdk/GdkNSView.h (which we can't because it pulls in the internal-only
|
||||
* gdk/GdkNSView.h (which we can’t because it pulls in the internal-only
|
||||
* gdkwindow.h).
|
||||
*/
|
||||
@protocol GdkNSView
|
||||
@ -1740,7 +1740,7 @@ gtk_drag_source_set_icon_name (GtkWidget *widget,
|
||||
* @hot_y: the Y offset within @widget of the hotspot.
|
||||
*
|
||||
* Changes the icon for a widget to a given widget. GTK+
|
||||
* will not destroy the icon, so if you don't want
|
||||
* will not destroy the icon, so if you don’t want
|
||||
* it to persist, you should connect to the “drag-end”
|
||||
* signal and destroy it yourself.
|
||||
**/
|
||||
|
@ -3196,7 +3196,7 @@ gtk_drag_set_icon_window (GdkDragContext *context,
|
||||
* @hot_y: the Y offset within @widget of the hotspot.
|
||||
*
|
||||
* Changes the icon for a widget to a given widget. GTK+
|
||||
* will not destroy the icon, so if you don't want
|
||||
* will not destroy the icon, so if you don’t want
|
||||
* it to persist, you should connect to the “drag-end”
|
||||
* signal and destroy it yourself.
|
||||
**/
|
||||
|
@ -341,7 +341,7 @@ gtk_editable_get_selection_bounds (GtkEditable *editable,
|
||||
* @editable: a #GtkEditable
|
||||
*
|
||||
* Deletes the currently selected text of the editable.
|
||||
* This call doesn't do anything if there is no selected text.
|
||||
* This call doesn’t do anything if there is no selected text.
|
||||
*/
|
||||
void
|
||||
gtk_editable_delete_selection (GtkEditable *editable)
|
||||
|
@ -8333,7 +8333,7 @@ gtk_entry_set_icon_from_stock (GtkEntry *entry,
|
||||
* Sets the icon shown in the entry at the specified position
|
||||
* from the current icon theme.
|
||||
*
|
||||
* If the icon name isn't known, a “broken image” icon will be displayed
|
||||
* If the icon name isn’t known, a “broken image” icon will be displayed
|
||||
* instead.
|
||||
*
|
||||
* If @icon_name is %NULL, no icon will be shown in the specified position.
|
||||
@ -8399,7 +8399,7 @@ gtk_entry_set_icon_from_icon_name (GtkEntry *entry,
|
||||
*
|
||||
* Sets the icon shown in the entry at the specified position
|
||||
* from the current icon theme.
|
||||
* If the icon isn't known, a “broken image” icon will be displayed
|
||||
* If the icon isn’t known, a “broken image” icon will be displayed
|
||||
* instead.
|
||||
*
|
||||
* If @icon is %NULL, no icon will be shown in the specified position.
|
||||
@ -8611,7 +8611,7 @@ gtk_entry_get_icon_gicon (GtkEntry *entry,
|
||||
* pixbuf, icon name or gicon).
|
||||
*
|
||||
* Returns: A stock id, or %NULL if no icon is set or if the icon
|
||||
* wasn't set from a stock id
|
||||
* wasn’t set from a stock id
|
||||
*
|
||||
* Since: 2.16
|
||||
*
|
||||
@ -8646,7 +8646,7 @@ gtk_entry_get_icon_stock (GtkEntry *entry,
|
||||
* pixbuf, stock or gicon).
|
||||
*
|
||||
* Returns: An icon name, or %NULL if no icon is set or if the icon
|
||||
* wasn't set from an icon name
|
||||
* wasn’t set from an icon name
|
||||
*
|
||||
* Since: 2.16
|
||||
*/
|
||||
@ -8783,7 +8783,7 @@ gtk_entry_get_icon_storage_type (GtkEntry *entry,
|
||||
*
|
||||
* Finds the icon at the given position and return its index. The
|
||||
* position’s coordinates are relative to the @entry’s top left corner.
|
||||
* If @x, @y doesn't lie inside an icon, -1 is returned.
|
||||
* If @x, @y doesn’t lie inside an icon, -1 is returned.
|
||||
* This function is intended for use in a #GtkWidget::query-tooltip
|
||||
* signal handler.
|
||||
*
|
||||
@ -10311,7 +10311,7 @@ gtk_entry_get_progress_pulse_step (GtkEntry *entry)
|
||||
* gtk_entry_progress_pulse:
|
||||
* @entry: a #GtkEntry
|
||||
*
|
||||
* Indicates that some progress is made, but you don't know how much.
|
||||
* Indicates that some progress is made, but you don’t know how much.
|
||||
* Causes the entry’s progress indicator to enter “activity mode,”
|
||||
* where a block bounces back and forth. Each call to
|
||||
* gtk_entry_progress_pulse() causes the block to move by a little bit
|
||||
|
@ -57,7 +57,7 @@
|
||||
* will generally take the filter model as argument. As long as you are
|
||||
* only calling gtk_tree_model_get(), this will make no difference to
|
||||
* you. If for some reason, you need the original model, use
|
||||
* gtk_tree_model_filter_get_model(). Don't forget to use
|
||||
* gtk_tree_model_filter_get_model(). Don’t forget to use
|
||||
* gtk_tree_model_filter_convert_iter_to_child_iter() to obtain a
|
||||
* matching iter.
|
||||
*/
|
||||
|
@ -347,7 +347,7 @@ typedef enum
|
||||
* @GTK_MESSAGE_WARNING: Non-fatal warning message
|
||||
* @GTK_MESSAGE_QUESTION: Question requiring a choice
|
||||
* @GTK_MESSAGE_ERROR: Fatal error message
|
||||
* @GTK_MESSAGE_OTHER: None of the above, doesn't get an icon
|
||||
* @GTK_MESSAGE_OTHER: None of the above, doesn’t get an icon
|
||||
*
|
||||
* The type of message being displayed in the dialog.
|
||||
*/
|
||||
@ -612,7 +612,7 @@ typedef enum
|
||||
* In some circumstances, such as initially or during a search
|
||||
* operation, it’s possible for no element to be selected with
|
||||
* %GTK_SELECTION_BROWSE. What is really enforced is that the user
|
||||
* can't deselect a currently selected element except by selecting
|
||||
* can’t deselect a currently selected element except by selecting
|
||||
* another element.
|
||||
* @GTK_SELECTION_MULTIPLE: Any number of elements may be selected.
|
||||
* The Ctrl key may be used to enlarge the selection, and Shift
|
||||
@ -660,7 +660,7 @@ typedef enum
|
||||
* @GTK_STATE_INSENSITIVE: State indicating that the widget is
|
||||
* unresponsive to user actions.
|
||||
* @GTK_STATE_INCONSISTENT: The widget is inconsistent, such as checkbuttons
|
||||
* or radiobuttons that aren't either set to %TRUE nor %FALSE,
|
||||
* or radiobuttons that aren’t either set to %TRUE nor %FALSE,
|
||||
* or buttons requiring the user attention.
|
||||
* @GTK_STATE_FOCUSED: The widget has the keyboard focus.
|
||||
*
|
||||
@ -713,7 +713,7 @@ typedef enum
|
||||
*
|
||||
* Window placement can be influenced using this enumeration. Note that
|
||||
* using #GTK_WIN_POS_CENTER_ALWAYS is almost always a bad idea.
|
||||
* It won't necessarily work well with all window managers or on all windowing systems.
|
||||
* It won’t necessarily work well with all window managers or on all windowing systems.
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
@ -734,11 +734,11 @@ typedef enum
|
||||
* are managed by the window manager and have a frame by default (call
|
||||
* gtk_window_set_decorated() to toggle the frame). Windows with type
|
||||
* #GTK_WINDOW_POPUP are ignored by the window manager; window manager
|
||||
* keybindings won't work on them, the window manager won't decorate the
|
||||
* keybindings won’t work on them, the window manager won’t decorate the
|
||||
* window with a frame, many GTK+ features that rely on the window
|
||||
* manager will not work (e.g. resize grips and
|
||||
* maximization/minimization). #GTK_WINDOW_POPUP is used to implement
|
||||
* widgets such as #GtkMenu or tooltips that you normally don't think of
|
||||
* widgets such as #GtkMenu or tooltips that you normally don’t think of
|
||||
* as windows per se. Nearly all windows should be #GTK_WINDOW_TOPLEVEL.
|
||||
* In particular, do not use #GTK_WINDOW_POPUP just to turn off
|
||||
* the window borders; use gtk_window_set_decorated() for that.
|
||||
@ -1027,7 +1027,7 @@ typedef enum {
|
||||
* GtkSizeRequestMode:
|
||||
* @GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH: Prefer height-for-width geometry management
|
||||
* @GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT: Prefer width-for-height geometry management
|
||||
* @GTK_SIZE_REQUEST_CONSTANT_SIZE: Don't trade height-for-width or width-for-height
|
||||
* @GTK_SIZE_REQUEST_CONSTANT_SIZE: Don’t trade height-for-width or width-for-height
|
||||
*
|
||||
* Specifies a preference for height-for-width or
|
||||
* width-for-height geometry management.
|
||||
|
@ -247,12 +247,12 @@ gtk_event_box_get_visible_window (GtkEventBox *event_box)
|
||||
* window below the child. (See gtk_event_box_set_above_child().)
|
||||
* Since the input-only window is not an ancestor window of any windows
|
||||
* that descendent widgets of the event box create, events on these
|
||||
* windows aren't propagated up by the windowing system, but only by GTK+.
|
||||
* The practical effect of this is if an event isn't in the event
|
||||
* windows aren’t propagated up by the windowing system, but only by GTK+.
|
||||
* The practical effect of this is if an event isn’t in the event
|
||||
* mask for the descendant window (see gtk_widget_add_events()),
|
||||
* it won't be received by the event box.
|
||||
* it won’t be received by the event box.
|
||||
*
|
||||
* This problem doesn't occur for visible event boxes, because in
|
||||
* This problem doesn’t occur for visible event boxes, because in
|
||||
* that case, the event box window is actually the ancestor of the
|
||||
* descendant windows, not just at the same place on the screen.
|
||||
*
|
||||
|
@ -716,7 +716,7 @@ gtk_file_chooser_get_filename (GtkFileChooser *chooser)
|
||||
* dialog for which you already have a file name to which
|
||||
* the user may save. For example, when the user opens an existing file and
|
||||
* then does Save As... to save a copy or
|
||||
* a modified version. If you don't have a file name already — for
|
||||
* a modified version. If you don’t have a file name already — for
|
||||
* example, if the user just created a new file and is saving it for the first
|
||||
* time, do not call this function. Instead, use something similar to this:
|
||||
* |[<!-- language="C" -->
|
||||
@ -755,7 +755,7 @@ gtk_file_chooser_set_filename (GtkFileChooser *chooser,
|
||||
* @chooser: a #GtkFileChooser
|
||||
* @filename: (type filename): the filename to select
|
||||
*
|
||||
* Selects a filename. If the file name isn't in the current
|
||||
* Selects a filename. If the file name isn’t in the current
|
||||
* folder of @chooser, then the current folder of @chooser will
|
||||
* be changed to the folder containing @filename.
|
||||
*
|
||||
@ -1068,7 +1068,7 @@ gtk_file_chooser_get_uri (GtkFileChooser *chooser)
|
||||
* dialog for which you already have a file name to which
|
||||
* the user may save. For example, when the user opens an existing file and then
|
||||
* does Save As... to save a copy or a
|
||||
* modified version. If you don't have a file name already — for example,
|
||||
* modified version. If you don’t have a file name already — for example,
|
||||
* if the user just created a new file and is saving it for the first time, do
|
||||
* not call this function. Instead, use something similar to this:
|
||||
* |[<!-- language="C" -->
|
||||
@ -1108,7 +1108,7 @@ gtk_file_chooser_set_uri (GtkFileChooser *chooser,
|
||||
* @chooser: a #GtkFileChooser
|
||||
* @uri: the URI to select
|
||||
*
|
||||
* Selects the file to by @uri. If the URI doesn't refer to a
|
||||
* Selects the file to by @uri. If the URI doesn’t refer to a
|
||||
* file in the current folder of @chooser, then the current folder of
|
||||
* @chooser will be changed to the folder containing @filename.
|
||||
*
|
||||
@ -1422,7 +1422,7 @@ gtk_file_chooser_get_files (GtkFileChooser *chooser)
|
||||
* the @chooser is in %GTK_FILE_CHOOSER_ACTION_SAVE mode, the file’s base name
|
||||
* will also appear in the dialog’s file name entry.
|
||||
*
|
||||
* If the file name isn't in the current folder of @chooser, then the current
|
||||
* If the file name isn’t in the current folder of @chooser, then the current
|
||||
* folder of @chooser will be changed to the folder containing @filename. This
|
||||
* is equivalent to a sequence of gtk_file_chooser_unselect_all() followed by
|
||||
* gtk_file_chooser_select_filename().
|
||||
@ -1433,7 +1433,7 @@ gtk_file_chooser_get_files (GtkFileChooser *chooser)
|
||||
* If you are implementing a save dialog,
|
||||
* you should use this function if you already have a file name to which the
|
||||
* user may save; for example, when the user opens an existing file and then
|
||||
* does Save As... If you don't have
|
||||
* does Save As... If you don’t have
|
||||
* a file name already — for example, if the user just created a new
|
||||
* file and is saving it for the first time, do not call this function.
|
||||
* Instead, use something similar to this:
|
||||
|
@ -2773,7 +2773,7 @@ combo_box_changed_cb (GtkComboBox *combo_box,
|
||||
}
|
||||
|
||||
/* Calback for the "notify::popup-shown" signal on the combo box.
|
||||
* When the combo is popped up, we don't want the ROW_TYPE_EMPTY_SELECTION to be visible
|
||||
* When the combo is popped up, we don’t want the ROW_TYPE_EMPTY_SELECTION to be visible
|
||||
* at all; otherwise we would be showing a “(None)” item in the combo box’s popup.
|
||||
*
|
||||
* However, when the combo box is *not* popped up, we want the empty-selection row
|
||||
@ -3063,7 +3063,7 @@ gtk_file_chooser_button_set_width_chars (GtkFileChooserButton *button,
|
||||
*
|
||||
* Sets whether the button will grab focus when it is clicked with the mouse.
|
||||
* Making mouse clicks not grab focus is useful in places like toolbars where
|
||||
* you don't want the keyboard focus removed from the main area of the
|
||||
* you don’t want the keyboard focus removed from the main area of the
|
||||
* application.
|
||||
*
|
||||
* Since: 2.10
|
||||
|
@ -77,7 +77,7 @@ static GtkFileChooserConfirmation delegate_confirm_overwrite (GtkFileChooser
|
||||
* #GtkFileChooser. A #GtkParamSpecOverride property is installed
|
||||
* for each property, using the values from the #GtkFileChooserProp
|
||||
* enumeration. The caller must make sure itself that the enumeration
|
||||
* values don't collide with some other property values they
|
||||
* values don’t collide with some other property values they
|
||||
* are using.
|
||||
**/
|
||||
void
|
||||
|
@ -2983,7 +2983,7 @@ gtk_file_chooser_widget_dispose (GObject *object)
|
||||
}
|
||||
|
||||
/* We override show-all since we have internal widgets that
|
||||
* shouldn't be shown when you call show_all(), like the filter
|
||||
* shouldn’t be shown when you call show_all(), like the filter
|
||||
* combo box.
|
||||
*/
|
||||
static void
|
||||
@ -6172,7 +6172,7 @@ search_engine_finished_cb (GtkSearchEngine *engine,
|
||||
|
||||
/* Displays a generic error when we cannot create a GtkSearchEngine.
|
||||
* It would be better if _gtk_search_engine_new() gave us a GError
|
||||
* with a better message, but it doesn't do that right now.
|
||||
* with a better message, but it doesn’t do that right now.
|
||||
*/
|
||||
static void
|
||||
search_error_could_not_create_client (GtkFileChooserWidget *impl)
|
||||
|
@ -343,7 +343,7 @@ gtk_file_filter_buildable_custom_tag_end (GtkBuildable *buildable,
|
||||
* gtk_file_filter_new:
|
||||
*
|
||||
* Creates a new #GtkFileFilter with no rules added to it.
|
||||
* Such a filter doesn't accept any files, so is not
|
||||
* Such a filter doesn’t accept any files, so is not
|
||||
* particularly useful until you add rules with
|
||||
* gtk_file_filter_add_mime_type(), gtk_file_filter_add_pattern(),
|
||||
* or gtk_file_filter_add_custom(). To create a filter
|
||||
@ -504,7 +504,7 @@ gtk_file_filter_add_pixbuf_formats (GtkFileFilter *filter)
|
||||
* function. The bitfield @needed which is passed in provides information
|
||||
* about what sorts of information that the filter function needs;
|
||||
* this allows GTK+ to avoid retrieving expensive information when
|
||||
* it isn't needed by the filter.
|
||||
* it isn’t needed by the filter.
|
||||
*
|
||||
* Since: 2.4
|
||||
**/
|
||||
|
@ -50,10 +50,10 @@
|
||||
* display of non-English text will use a different font in many
|
||||
* cases.
|
||||
*
|
||||
* In addition, the fixed widget can't properly be mirrored in
|
||||
* In addition, the fixed widget can’t properly be mirrored in
|
||||
* right-to-left languages such as Hebrew and Arabic. i.e. normally
|
||||
* GTK+ will flip the interface to put labels to the right of the
|
||||
* thing they label, but it can't do that with #GtkFixed. So your
|
||||
* thing they label, but it can’t do that with #GtkFixed. So your
|
||||
* application will not be usable in right-to-left languages.
|
||||
*
|
||||
* Finally, fixed positioning makes it kind of annoying to add/remove
|
||||
|
@ -698,7 +698,7 @@ gtk_flow_box_child_is_selected (GtkFlowBoxChild *child)
|
||||
* must only read the new data for the first of the two changed
|
||||
* children, otherwise the resorting of the children will be wrong.
|
||||
*
|
||||
* This generally means that if you don't fully control the data
|
||||
* This generally means that if you don’t fully control the data
|
||||
* model, you have to duplicate the data that affects the sorting
|
||||
* and filtering functions into the widgets themselves. Another
|
||||
* alternative is to call gtk_flow_box_invalidate_sort() on any
|
||||
|
@ -103,7 +103,7 @@ _gtk_font_chooser_delegate_get_quark (void)
|
||||
* #GtkFontChooser. A #GtkParamSpecOverride property is installed
|
||||
* for each property, using the values from the #GtkFontChooserProp
|
||||
* enumeration. The caller must make sure itself that the enumeration
|
||||
* values don't collide with some other property values they
|
||||
* values don’t collide with some other property values they
|
||||
* are using.
|
||||
*/
|
||||
void
|
||||
|
@ -520,7 +520,7 @@ gtk_frame_get_label_widget (GtkFrame *frame)
|
||||
* 1.0 represents right alignment.
|
||||
* @yalign: The y alignment of the label. A value of 0.0 aligns under
|
||||
* the frame; 1.0 aligns above the frame. If the values are exactly
|
||||
* 0.0 or 1.0 the gap in the frame won't be painted because the label
|
||||
* 0.0 or 1.0 the gap in the frame won’t be painted because the label
|
||||
* will be completely above or below the frame.
|
||||
*
|
||||
* Sets the alignment of the frame widget’s label. The
|
||||
|
@ -126,7 +126,7 @@
|
||||
* &error);
|
||||
* if (!pixbuf)
|
||||
* {
|
||||
* g_warning ("Couldn't load icon: %s", error->message);
|
||||
* g_warning ("Couldn’t load icon: %s", error->message);
|
||||
* g_error_free (error);
|
||||
* }
|
||||
* else
|
||||
@ -893,7 +893,7 @@ gtk_icon_theme_finalize (GObject *object)
|
||||
* are combined to allow themes to be extended by adding icons
|
||||
* in the user’s home directory.)
|
||||
*
|
||||
* In addition if an icon found isn't found either in the current
|
||||
* In addition if an icon found isn’t found either in the current
|
||||
* icon theme or the default icon theme, and an image file with
|
||||
* the right name is found directly in one of the elements of
|
||||
* @path, then that image will be used for the icon name.
|
||||
@ -1813,7 +1813,7 @@ choose_icon (GtkIconTheme *icon_theme,
|
||||
* combines these two steps if all you need is the pixbuf.)
|
||||
*
|
||||
* Return value: (transfer full): a #GtkIconInfo object containing information
|
||||
* about the icon, or %NULL if the icon wasn't found.
|
||||
* about the icon, or %NULL if the icon wasn’t found.
|
||||
*
|
||||
* Since: 2.4
|
||||
*/
|
||||
@ -1850,7 +1850,7 @@ gtk_icon_theme_lookup_icon (GtkIconTheme *icon_theme,
|
||||
* these two steps if all you need is the pixbuf.)
|
||||
*
|
||||
* Return value: (transfer full): a #GtkIconInfo object containing
|
||||
* information about the icon, or %NULL if the icon wasn't found.
|
||||
* information about the icon, or %NULL if the icon wasn’t found.
|
||||
*
|
||||
* Since: 3.10
|
||||
*/
|
||||
@ -1954,7 +1954,7 @@ gtk_icon_theme_lookup_icon_for_scale (GtkIconTheme *icon_theme,
|
||||
* inherited icon themes.
|
||||
*
|
||||
* Return value: (transfer full): a #GtkIconInfo object containing information
|
||||
* about the icon, or %NULL if the icon wasn't found.
|
||||
* about the icon, or %NULL if the icon wasn’t found.
|
||||
*
|
||||
* Since: 2.12
|
||||
*/
|
||||
@ -1992,7 +1992,7 @@ gtk_icon_theme_choose_icon (GtkIconTheme *icon_theme,
|
||||
* inherited icon themes.
|
||||
*
|
||||
* Return value: (transfer full): a #GtkIconInfo object containing information
|
||||
* about the icon, or %NULL if the icon wasn't found.
|
||||
* about the icon, or %NULL if the icon wasn’t found.
|
||||
*
|
||||
* Since: 3.10
|
||||
*/
|
||||
@ -2046,7 +2046,7 @@ gtk_icon_theme_error_quark (void)
|
||||
* Return value: (transfer full): the rendered icon; this may be a
|
||||
* newly created icon or a new reference to an internal icon, so
|
||||
* you must not modify the icon. Use g_object_unref() to release
|
||||
* your reference to the icon. %NULL if the icon isn't found.
|
||||
* your reference to the icon. %NULL if the icon isn’t found.
|
||||
*
|
||||
* Since: 2.4
|
||||
**/
|
||||
@ -2095,7 +2095,7 @@ gtk_icon_theme_load_icon (GtkIconTheme *icon_theme,
|
||||
* Return value: (transfer full): the rendered icon; this may be a
|
||||
* newly created icon or a new reference to an internal icon, so
|
||||
* you must not modify the icon. Use g_object_unref() to release
|
||||
* your reference to the icon. %NULL if the icon isn't found.
|
||||
* your reference to the icon. %NULL if the icon isn’t found.
|
||||
*
|
||||
* Since: 3.10
|
||||
**/
|
||||
@ -2157,7 +2157,7 @@ gtk_icon_theme_load_icon_for_scale (GtkIconTheme *icon_theme,
|
||||
* Return value: (transfer full): the rendered icon; this may be a
|
||||
* newly created icon or a new reference to an internal icon, so
|
||||
* you must not modify the icon. Use cairo_surface_destroy() to release
|
||||
* your reference to the icon. %NULL if the icon isn't found.
|
||||
* your reference to the icon. %NULL if the icon isn’t found.
|
||||
*
|
||||
* Since: 3.10
|
||||
**/
|
||||
@ -5009,7 +5009,7 @@ gtk_icon_info_get_attach_points (GtkIconInfo *icon_info,
|
||||
* visible context like a list of icons.
|
||||
*
|
||||
* Return value: the display name for the icon or %NULL, if
|
||||
* the icon doesn't have a specified display name. This value
|
||||
* the icon doesn’t have a specified display name. This value
|
||||
* is owned @icon_info and must not be modified or free.
|
||||
*
|
||||
* Since: 2.4
|
||||
@ -5173,7 +5173,7 @@ find_builtin_icon (const gchar *icon_name,
|
||||
*
|
||||
* Return value: (transfer full): a #GtkIconInfo containing
|
||||
* information about the icon, or %NULL if the icon
|
||||
* wasn't found. Unref with g_object_unref()
|
||||
* wasn’t found. Unref with g_object_unref()
|
||||
*
|
||||
* Since: 2.14
|
||||
*/
|
||||
@ -5203,7 +5203,7 @@ gtk_icon_theme_lookup_by_gicon (GtkIconTheme *icon_theme,
|
||||
*
|
||||
* Return value: (transfer full): a #GtkIconInfo containing
|
||||
* information about the icon, or %NULL if the icon
|
||||
* wasn't found. Unref with g_object_unref()
|
||||
* wasn’t found. Unref with g_object_unref()
|
||||
*
|
||||
* Since: 3.10
|
||||
*/
|
||||
|
@ -102,7 +102,7 @@ struct _GtkIconThemeClass
|
||||
* @GTK_ICON_LOOKUP_NO_SVG: Never get SVG icons, even if gdk-pixbuf
|
||||
* supports them. Cannot be used together with %GTK_ICON_LOOKUP_FORCE_SVG.
|
||||
* @GTK_ICON_LOOKUP_FORCE_SVG: Get SVG icons, even if gdk-pixbuf
|
||||
* doesn't support them.
|
||||
* doesn’t support them.
|
||||
* Cannot be used together with %GTK_ICON_LOOKUP_NO_SVG.
|
||||
* @GTK_ICON_LOOKUP_USE_BUILTIN: When passed to
|
||||
* gtk_icon_theme_lookup_icon() includes builtin icons
|
||||
|
@ -2240,7 +2240,7 @@ gtk_icon_view_set_cursor (GtkIconView *icon_view,
|
||||
* focus cell, or %NULL
|
||||
*
|
||||
* Fills in @path and @cell with the current cursor path and cell.
|
||||
* If the cursor isn't currently set, then *@path will be %NULL.
|
||||
* If the cursor isn’t currently set, then *@path will be %NULL.
|
||||
* If no cell currently has focus, then *@cell will be %NULL.
|
||||
*
|
||||
* The returned #GtkTreePath must be freed with gtk_tree_path_free().
|
||||
@ -6056,7 +6056,7 @@ gtk_icon_view_get_item_padding (GtkIconView *icon_view)
|
||||
|
||||
/* Get/set whether drag_motion requested the drag data and
|
||||
* drag_data_received should thus not actually insert the data,
|
||||
* since the data doesn't result from a drop.
|
||||
* since the data doesn’t result from a drop.
|
||||
*/
|
||||
static void
|
||||
set_status_pending (GdkDragContext *context,
|
||||
|
@ -56,7 +56,7 @@
|
||||
* GtkWidget *image;
|
||||
* image = gtk_image_new_from_file ("myfile.png");
|
||||
* ]|
|
||||
* If the file isn't loaded successfully, the image will contain a
|
||||
* If the file isn’t loaded successfully, the image will contain a
|
||||
* “broken image” icon similar to that used in many web browsers.
|
||||
* If you want to handle errors in loading the file yourself,
|
||||
* for example by displaying an error message, then load the image with
|
||||
@ -87,7 +87,7 @@
|
||||
* event->x, event->y);
|
||||
*
|
||||
* /<!---->* Returning TRUE means we handled the event, so the signal
|
||||
* * emission should be stopped (don't call any further
|
||||
* * emission should be stopped (don’t call any further
|
||||
* * callbacks that may be connected). Return FALSE
|
||||
* * to continue invoking callbacks.
|
||||
* *<!---->/
|
||||
@ -550,7 +550,7 @@ gtk_image_get_property (GObject *object,
|
||||
* @filename: (type filename): a filename
|
||||
*
|
||||
* Creates a new #GtkImage displaying the file @filename. If the file
|
||||
* isn't found or can't be loaded, the resulting #GtkImage will
|
||||
* isn’t found or can’t be loaded, the resulting #GtkImage will
|
||||
* display a “broken image” icon. This function never returns %NULL,
|
||||
* it always returns a valid #GtkImage widget.
|
||||
*
|
||||
@ -585,7 +585,7 @@ gtk_image_new_from_file (const gchar *filename)
|
||||
* @resource_path: a resource path
|
||||
*
|
||||
* Creates a new #GtkImage displaying the resource file @resource_path. If the file
|
||||
* isn't found or can't be loaded, the resulting #GtkImage will
|
||||
* isn’t found or can’t be loaded, the resulting #GtkImage will
|
||||
* display a “broken image” icon. This function never returns %NULL,
|
||||
* it always returns a valid #GtkImage widget.
|
||||
*
|
||||
@ -675,7 +675,7 @@ gtk_image_new_from_surface (cairo_surface_t *surface)
|
||||
* Creates a #GtkImage displaying a stock icon. Sample stock icon
|
||||
* names are #GTK_STOCK_OPEN, #GTK_STOCK_QUIT. Sample stock sizes
|
||||
* are #GTK_ICON_SIZE_MENU, #GTK_ICON_SIZE_SMALL_TOOLBAR. If the stock
|
||||
* icon name isn't known, the image will be empty.
|
||||
* icon name isn’t known, the image will be empty.
|
||||
* You can register your own stock icon names, see
|
||||
* gtk_icon_factory_add_default() and gtk_icon_factory_add().
|
||||
*
|
||||
@ -772,7 +772,7 @@ gtk_image_new_from_animation (GdkPixbufAnimation *animation)
|
||||
* @size: (type int): a stock icon size
|
||||
*
|
||||
* Creates a #GtkImage displaying an icon from the current icon theme.
|
||||
* If the icon name isn't known, a “broken image” icon will be
|
||||
* If the icon name isn’t known, a “broken image” icon will be
|
||||
* displayed instead. If the current icon theme is changed, the icon
|
||||
* will be updated appropriately.
|
||||
*
|
||||
@ -799,7 +799,7 @@ gtk_image_new_from_icon_name (const gchar *icon_name,
|
||||
* @size: (type int): a stock icon size
|
||||
*
|
||||
* Creates a #GtkImage displaying an icon from the current icon theme.
|
||||
* If the icon name isn't known, a “broken image” icon will be
|
||||
* If the icon name isn’t known, a “broken image” icon will be
|
||||
* displayed instead. If the current icon theme is changed, the icon
|
||||
* will be updated appropriately.
|
||||
*
|
||||
|
@ -175,7 +175,7 @@ G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GtkIMContext, gtk_im_context, G_TYPE_OBJECT
|
||||
* consumed by the input method. In that case, the #GtkIMContext::commit
|
||||
* signal should be emitted upon completion of a key sequence to pass the
|
||||
* resulting text back to the input widget. Alternatively, %FALSE may be
|
||||
* returned to indicate that the event wasn't handled by the input method.
|
||||
* returned to indicate that the event wasn’t handled by the input method.
|
||||
* If a builtin mapping exists for the key, it is used to produce a
|
||||
* character.
|
||||
* @focus_in: Called via gtk_im_context_focus_in() when the input widget
|
||||
|
@ -676,7 +676,7 @@ check_algorithmically (GtkIMContextSimple *context_simple,
|
||||
/* In addition to the table-driven sequences, we allow Unicode hex
|
||||
* codes to be entered. The method chosen here is similar to the
|
||||
* one recommended in ISO 14755, but not exactly the same, since we
|
||||
* don't want to steal 16 valuable key combinations.
|
||||
* don’t want to steal 16 valuable key combinations.
|
||||
*
|
||||
* A hex Unicode sequence must be started with Ctrl-Shift-U, followed
|
||||
* by a sequence of hex digits entered with Ctrl-Shift still held.
|
||||
|
@ -370,7 +370,7 @@ keyval_in_group (GdkKeymap *keymap,
|
||||
* does not). As long there are any exact matches, only exact matches
|
||||
* are returned. If there are no exact matches, fuzzy matches will be
|
||||
* returned, as long as they are not shadowing a possible exact match.
|
||||
* This means that fuzzy matches won't be considered if their keyval is
|
||||
* This means that fuzzy matches won’t be considered if their keyval is
|
||||
* present in the current group.
|
||||
*
|
||||
* Return value: A newly-allocated #GSList of matching entries.
|
||||
|
@ -2989,7 +2989,7 @@ gtk_label_get_max_width_chars (GtkLabel *label)
|
||||
*
|
||||
* Note that setting line wrapping to %TRUE does not make the label
|
||||
* wrap at its parent container’s width, because GTK+ widgets
|
||||
* conceptually can't make their requisition depend on the parent
|
||||
* conceptually can’t make their requisition depend on the parent
|
||||
* container’s size. For a label that wraps at a specific position,
|
||||
* set the label’s width using gtk_widget_set_size_request().
|
||||
**/
|
||||
@ -6551,7 +6551,7 @@ _gtk_label_get_selection_bound (GtkLabel *label)
|
||||
*
|
||||
* Sets the number of lines to which an ellipsized, wrapping label
|
||||
* should be limited. This has no effect if the label is not wrapping
|
||||
* or ellipsized. Set this to -1 if you don't want to limit the
|
||||
* or ellipsized. Set this to -1 if you don’t want to limit the
|
||||
* number of lines.
|
||||
*
|
||||
* Since: 3.10
|
||||
|
@ -47,7 +47,7 @@
|
||||
* @See_also: #GtkDrawingArea, #GtkScrolledWindow
|
||||
*
|
||||
* #GtkLayout is similar to #GtkDrawingArea in that it’s a “blank slate”
|
||||
* and doesn't do anything but paint a blank background by default. It's
|
||||
* and doesn’t do anything but paint a blank background by default. It's
|
||||
* different in that it supports scrolling natively (you can add it to a
|
||||
* #GtkScrolledWindow), and it can contain child widgets, since it’s a
|
||||
* #GtkContainer. However if you're just going to draw, a #GtkDrawingArea
|
||||
|
@ -587,7 +587,7 @@ gtk_list_box_select_row (GtkListBox *list_box,
|
||||
* @placeholder: (allow-none): a #GtkWidget or %NULL
|
||||
*
|
||||
* Sets the placeholder widget that is shown in the list when
|
||||
* it doesn't display any visible children.
|
||||
* it doesn’t display any visible children.
|
||||
*
|
||||
* Since: 3.10
|
||||
*/
|
||||
@ -805,7 +805,7 @@ gtk_list_box_set_filter_func (GtkListBox *list_box,
|
||||
* gtk_list_box_row_set_header(). If no header is needed, set the header to %NULL.
|
||||
*
|
||||
* Note that you may get many calls @update_header to this for a particular row when e.g.
|
||||
* changing things that don't affect the header. In this case it is important for performance
|
||||
* changing things that don’t affect the header. In this case it is important for performance
|
||||
* to not blindly replace an exisiting header widh an identical one.
|
||||
*
|
||||
* The @update_header function will be called for each row after the call, and it will
|
||||
@ -2715,7 +2715,7 @@ gtk_list_box_row_size_allocate (GtkWidget *widget,
|
||||
* for the first of the two changed rows, otherwise the resorting
|
||||
* of the rows will be wrong.
|
||||
*
|
||||
* This generally means that if you don't fully control the data
|
||||
* This generally means that if you don’t fully control the data
|
||||
* model you have to duplicate the data that affects the listbox
|
||||
* row functions into the row widgets themselves. Another alternative
|
||||
* is to call gtk_list_box_invalidate_sort() on any model change,
|
||||
|
@ -44,7 +44,7 @@
|
||||
* interfaces.
|
||||
*
|
||||
* The #GtkListStore can accept most GObject types as a column type, though
|
||||
* it can't accept all custom types. Internally, it will keep a copy of
|
||||
* it can’t accept all custom types. Internally, it will keep a copy of
|
||||
* data passed in (such as a string or a boxed pointer). Columns that
|
||||
* accept #GObjects are handled a little differently. The
|
||||
* #GtkListStore will keep a reference to the object instead of copying the
|
||||
|
@ -298,9 +298,9 @@ gtk_get_interface_age (void)
|
||||
* (same major version.)
|
||||
*
|
||||
* This function is primarily for GTK+ modules; the module
|
||||
* can call this function to check that it wasn't loaded
|
||||
* can call this function to check that it wasn’t loaded
|
||||
* into an incompatible version of GTK+. However, such a
|
||||
* check isn't completely reliable, since the module may be
|
||||
* check isn’t completely reliable, since the module may be
|
||||
* linked against an old version of GTK+ and calling the
|
||||
* old version of gtk_check_version(), but still get loaded
|
||||
* into an application using a newer version of GTK+.
|
||||
@ -330,11 +330,11 @@ gtk_check_version (guint required_major,
|
||||
}
|
||||
|
||||
/* This checks to see if the process is running suid or sgid
|
||||
* at the current time. If so, we don't allow GTK+ to be initialized.
|
||||
* at the current time. If so, we don’t allow GTK+ to be initialized.
|
||||
* This is meant to be a mild check - we only error out if we
|
||||
* can prove the programmer is doing something wrong, not if
|
||||
* they could be doing something wrong. For this reason, we
|
||||
* don't use issetugid() on BSD or prctl (PR_GET_DUMPABLE).
|
||||
* don’t use issetugid() on BSD or prctl (PR_GET_DUMPABLE).
|
||||
*/
|
||||
static gboolean
|
||||
check_setugid (void)
|
||||
@ -961,7 +961,7 @@ gtk_parse_args (int *argc,
|
||||
*
|
||||
* This function does the same work as gtk_init() with only a single
|
||||
* change: It does not terminate the program if the windowing system
|
||||
* can't be initialized. Instead it returns %FALSE on failure.
|
||||
* can’t be initialized. Instead it returns %FALSE on failure.
|
||||
*
|
||||
* This way the application can fall back to some other means of
|
||||
* communication with the user - for example a curses or command line
|
||||
@ -1008,7 +1008,7 @@ gtk_init_check (int *argc,
|
||||
* if you are calling gtk_parse_args(), gtk_init_check(),
|
||||
* gtk_init_with_args() or g_option_context_parse() with
|
||||
* the option group returned by gtk_get_option_group(),
|
||||
* you don't have to call gtk_init().
|
||||
* you don’t have to call gtk_init().
|
||||
*
|
||||
* This function will terminate your program if it was unable to
|
||||
* initialize the windowing system for some reason. If you want
|
||||
@ -1058,7 +1058,7 @@ check_sizeof_GtkWindow (size_t sizeof_GtkWindow)
|
||||
|
||||
/* In GTK+ 2.0 the GtkWindow struct actually is the same size in
|
||||
* gcc-compiled code on Win32 whether compiled with -fnative-struct or
|
||||
* not. Unfortunately this wan't noticed until after GTK+ 2.0.1. So,
|
||||
* not. Unfortunately this wan’t noticed until after GTK+ 2.0.1. So,
|
||||
* from GTK+ 2.0.2 on, check some other struct, too, where the use of
|
||||
* -fnative-struct still matters. GtkBox is one such.
|
||||
*/
|
||||
@ -1277,7 +1277,7 @@ gtk_events_pending (void)
|
||||
* Runs a single iteration of the mainloop.
|
||||
*
|
||||
* If no events are waiting to be processed GTK+ will block
|
||||
* until the next event is noticed. If you don't want to block
|
||||
* until the next event is noticed. If you don’t want to block
|
||||
* look at gtk_main_iteration_do() or check if any events are
|
||||
* pending with gtk_events_pending() first.
|
||||
*
|
||||
@ -1466,7 +1466,7 @@ rewrite_event_for_grabs (GdkEvent *event)
|
||||
* events are thrown away. This is to avoid a backlog of (de-)highlighting
|
||||
* widgets crossed by the pointer.
|
||||
*
|
||||
* 2. Find the widget which got the event. If the widget can't be determined
|
||||
* 2. Find the widget which got the event. If the widget can’t be determined
|
||||
* the event is thrown away unless it belongs to a INCR transaction.
|
||||
*
|
||||
* 3. Then the event is pushed onto a stack so you can query the currently
|
||||
@ -2536,7 +2536,7 @@ propagate_event (GtkWidget *widget,
|
||||
* event-specific signal on a widget. gtk_propagate_event() is a bit
|
||||
* higher-level, and gtk_main_do_event() is the highest level.
|
||||
*
|
||||
* All that said, you most likely don't want to use any of these
|
||||
* All that said, you most likely don’t want to use any of these
|
||||
* functions; synthesizing events is rarely needed. There are almost
|
||||
* certainly better ways to achieve your goals. For example, use
|
||||
* gdk_window_invalidate_rect() or gtk_widget_queue_draw() instead
|
||||
|
@ -5473,7 +5473,7 @@ gtk_menu_real_move_scroll (GtkMenu *menu,
|
||||
*
|
||||
* This function should be called from a #GtkMenuPositionFunc
|
||||
* if the menu should not appear on the same monitor as the pointer.
|
||||
* This information can't be reliably inferred from the coordinates
|
||||
* This information can’t be reliably inferred from the coordinates
|
||||
* returned by a #GtkMenuPositionFunc, since, for very long menus,
|
||||
* these coordinates may extend beyond the monitor boundaries or even
|
||||
* the screen boundaries.
|
||||
|
@ -828,7 +828,7 @@ gtk_menu_button_get_align_widget (GtkMenuButton *menu_button)
|
||||
* we will do our best to keep it inside the screen and fully visible.
|
||||
*
|
||||
* If you pass %GTK_ARROW_NONE for a @direction, the menu will behave
|
||||
* as if you passed %GTK_ARROW_DOWN (although you won't see any arrows).
|
||||
* as if you passed %GTK_ARROW_DOWN (although you won’t see any arrows).
|
||||
*
|
||||
* Since: 3.6
|
||||
*/
|
||||
|
@ -1440,12 +1440,12 @@ gtk_menu_shell_move_selected (GtkMenuShell *menu_shell,
|
||||
* @menu_shell: a #GtkMenuShell
|
||||
* @search_sensitive: if %TRUE, search for the first selectable
|
||||
* menu item, otherwise select nothing if
|
||||
* the first item isn't sensitive. This
|
||||
* the first item isn’t sensitive. This
|
||||
* should be %FALSE if the menu is being
|
||||
* popped up initially.
|
||||
*
|
||||
* Select the first visible or selectable child of the menu shell;
|
||||
* don't select tearoff items unless the only item is a tearoff
|
||||
* don’t select tearoff items unless the only item is a tearoff
|
||||
* item.
|
||||
*
|
||||
* Since: 2.2
|
||||
@ -1905,7 +1905,7 @@ gtk_menu_shell_get_take_focus (GtkMenuShell *menu_shell)
|
||||
*
|
||||
* The @take_focus state of a menu or menu bar is automatically
|
||||
* propagated to submenus whenever a submenu is popped up, so you
|
||||
* don't have to worry about recursively setting it for your entire
|
||||
* don’t have to worry about recursively setting it for your entire
|
||||
* menu hierarchy. Only when programmatically picking a submenu and
|
||||
* popping it up manually, the @take_focus property of the submenu
|
||||
* needs to be set explicitly.
|
||||
@ -1913,7 +1913,7 @@ gtk_menu_shell_get_take_focus (GtkMenuShell *menu_shell)
|
||||
* Note that setting it to %FALSE has side-effects:
|
||||
*
|
||||
* If the focus is in some other app, it keeps the focus and keynav in
|
||||
* the menu doesn't work. Consequently, keynav on the menu will only
|
||||
* the menu doesn’t work. Consequently, keynav on the menu will only
|
||||
* work if the focus is on some toplevel owned by the onscreen keyboard.
|
||||
*
|
||||
* To avoid confusing the user, menus with @take_focus set to %FALSE
|
||||
@ -2132,7 +2132,7 @@ gtk_menu_shell_tracker_insert_func (GtkMenuTrackerItem *item,
|
||||
*
|
||||
* @with_separators determines if toplevel items (eg: sections) have
|
||||
* separators inserted between them. This is typically desired for
|
||||
* menus but doesn't make sense for menubars.
|
||||
* menus but doesn’t make sense for menubars.
|
||||
*
|
||||
* If @action_namespace is non-%NULL then the effect is as if all
|
||||
* actions mentioned in the @model have their names prefixed with the
|
||||
|
@ -603,7 +603,7 @@ gtk_message_dialog_new (GtkWindow *parent,
|
||||
* Usually this is what you want, but if you have an existing
|
||||
* Pango markup string that you want to use literally as the
|
||||
* label, then you need to use gtk_message_dialog_set_markup()
|
||||
* instead, since you can't pass the markup string either
|
||||
* instead, since you can’t pass the markup string either
|
||||
* as the format (it might contain “%” characters) or as a string
|
||||
* argument.
|
||||
* |[<!-- language="C" -->
|
||||
|
@ -165,7 +165,7 @@ module_build_la_path (const gchar *directory,
|
||||
* Looks for a dynamically module named @name of type @type in the standard GTK+
|
||||
* module search path.
|
||||
*
|
||||
* Return value: the pathname to the found module, or %NULL if it wasn't found.
|
||||
* Return value: the pathname to the found module, or %NULL if it wasn’t found.
|
||||
* Free with g_free().
|
||||
**/
|
||||
gchar *
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user