lolengine
/
binaries
1
0
Çatalla 0
Kod Konular 0 Değişiklik İstekleri 0 Sürümler 0 Wiki Aktivite
25'ten fazla konu seçemezsiniz Konular bir harf veya rakamla başlamalı, kısa çizgiler ('-') içerebilir ve en fazla 35 karakter uzunluğunda olabilir.
2 İşleme
1 Dal
7.3 MiB
 
 
 
 
 
 
Ağaç: 617c493e11
Dallar Biçim İmleri
${ item.name }
${ searchTerm } dalı oluştur
'617c493e11'den
${ noResults }
binaries/gtk-2.22.1/include/gtk-2.0/gtk/gtkentry.h

335 satır
15 KiB
Ham Suçlama Geçmiş 

  1. /* GTK - The GIMP Toolkit

  2.  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald

  3.  *

  4.  * Copyright (C) 2004-2006 Christian Hammond

  5.  * Copyright (C) 2008 Cody Russell

  6.  * Copyright (C) 2008 Red Hat, Inc.

  7.  *

  8.  * This library is free software; you can redistribute it and/or

  9.  * modify it under the terms of the GNU Lesser General Public

  10.  * License as published by the Free Software Foundation; either

  11.  * version 2 of the License, or (at your option) any later version.

  12.  *

  13.  * This library is distributed in the hope that it will be useful,

  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  16.  * Lesser General Public License for more details.

  17.  *

  18.  * You should have received a copy of the GNU Lesser General Public

  19.  * License along with this library; if not, write to the

  20.  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

  21.  * Boston, MA 02111-1307, USA.

  22.  */

  23. 

  24. /*

  25.  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS

  26.  * file for a list of people on the GTK+ Team.  See the ChangeLog

  27.  * files for a list of changes.  These files are distributed with

  28.  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.

  29.  */

  30. 

  31. #if defined(GTK_DISABLE_SINGLE_INCLUDES) && !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)

  32. #error "Only <gtk/gtk.h> can be included directly."

  33. #endif

  34. 

  35. #ifndef __GTK_ENTRY_H__

  36. #define __GTK_ENTRY_H__

  37. 

  38. 

  39. #include <gtk/gtkeditable.h>

  40. #include <gtk/gtkimcontext.h>

  41. #include <gtk/gtkmenu.h>

  42. #include <gtk/gtkentrybuffer.h>

  43. #include <gtk/gtkentrycompletion.h>

  44. #include <gtk/gtkimage.h>

  45. #include <gtk/gtkselection.h>

  46. 

  47. 

  48. G_BEGIN_DECLS

  49. 

  50. #define GTK_TYPE_ENTRY                  (gtk_entry_get_type ())

  51. #define GTK_ENTRY(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ENTRY, GtkEntry))

  52. #define GTK_ENTRY_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ENTRY, GtkEntryClass))

  53. #define GTK_IS_ENTRY(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ENTRY))

  54. #define GTK_IS_ENTRY_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ENTRY))

  55. #define GTK_ENTRY_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ENTRY, GtkEntryClass))

  56. 

  57. typedef enum

  58. {

  59.   GTK_ENTRY_ICON_PRIMARY,

  60.   GTK_ENTRY_ICON_SECONDARY

  61. } GtkEntryIconPosition;

  62. 

  63. typedef struct _GtkEntry       GtkEntry;

  64. typedef struct _GtkEntryClass  GtkEntryClass;

  65. 

  66. struct _GtkEntry

  67. {

  68.   GtkWidget  widget;

  69. 

  70.   gchar       *GSEAL (text);                        /* COMPAT: Deprecated, not used. Remove in GTK+ 3.x */

  71. 

  72.   guint        GSEAL (editable) : 1;

  73.   guint        GSEAL (visible)  : 1;

  74.   guint        GSEAL (overwrite_mode) : 1;

  75.   guint        GSEAL (in_drag) : 1;	            /* FIXME: Should be private?

  76.                                                        Dragging within the selection */

  77. 

  78.   guint16      GSEAL (text_length);                 /* COMPAT: Deprecated, not used. Remove in GTK+ 3.x */

  79.   guint16      GSEAL (text_max_length);             /* COMPAT: Deprecated, not used. Remove in GTK+ 3.x */

  80. 

  81.   /*< private >*/

  82.   GdkWindow    *GSEAL (text_area);

  83.   GtkIMContext *GSEAL (im_context);

  84.   GtkWidget    *GSEAL (popup_menu);

  85. 

  86.   gint          GSEAL (current_pos);

  87.   gint          GSEAL (selection_bound);

  88. 

  89.   PangoLayout  *GSEAL (cached_layout);

  90. 

  91.   guint         GSEAL (cache_includes_preedit) : 1;

  92.   guint         GSEAL (need_im_reset)          : 1;

  93.   guint         GSEAL (has_frame)              : 1;

  94.   guint         GSEAL (activates_default)      : 1;

  95.   guint         GSEAL (cursor_visible)         : 1;

  96.   guint         GSEAL (in_click)               : 1; /* Flag so we don't select all when clicking in entry to focus in */

  97.   guint         GSEAL (is_cell_renderer)       : 1;

  98.   guint         GSEAL (editing_canceled)       : 1; /* Only used by GtkCellRendererText */ 

  99.   guint         GSEAL (mouse_cursor_obscured)  : 1;

  100.   guint         GSEAL (select_words)           : 1;

  101.   guint         GSEAL (select_lines)           : 1;

  102.   guint         GSEAL (resolved_dir)           : 4; /* PangoDirection */

  103.   guint         GSEAL (truncate_multiline)     : 1;

  104. 

  105.   guint         GSEAL (button);

  106.   guint         GSEAL (blink_timeout);

  107.   guint         GSEAL (recompute_idle);

  108.   gint          GSEAL (scroll_offset);

  109.   gint          GSEAL (ascent);	                    /* font ascent in pango units  */

  110.   gint          GSEAL (descent);	            /* font descent in pango units */

  111. 

  112.   guint16       GSEAL (x_text_size);	            /* allocated size, in bytes */

  113.   guint16       GSEAL (x_n_bytes);	            /* length in use, in bytes */

  114. 

  115.   guint16       GSEAL (preedit_length);	            /* length of preedit string, in bytes */

  116.   guint16       GSEAL (preedit_cursor);	            /* offset of cursor within preedit string, in chars */

  117. 

  118.   gint          GSEAL (dnd_position);		    /* In chars, -1 == no DND cursor */

  119. 

  120.   gint          GSEAL (drag_start_x);

  121.   gint          GSEAL (drag_start_y);

  122. 

  123.   gunichar      GSEAL (invisible_char);

  124. 

  125.   gint          GSEAL (width_chars);

  126. };

  127. 

  128. struct _GtkEntryClass

  129. {

  130.   GtkWidgetClass parent_class;

  131. 

  132.   /* Hook to customize right-click popup */

  133.   void (* populate_popup)   (GtkEntry       *entry,

  134.                              GtkMenu        *menu);

  135. 

  136.   /* Action signals

  137.    */

  138.   void (* activate)           (GtkEntry             *entry);

  139.   void (* move_cursor)        (GtkEntry             *entry,

  140. 			       GtkMovementStep       step,

  141. 			       gint                  count,

  142. 			       gboolean              extend_selection);

  143.   void (* insert_at_cursor)   (GtkEntry             *entry,

  144. 			       const gchar          *str);

  145.   void (* delete_from_cursor) (GtkEntry             *entry,

  146. 			       GtkDeleteType         type,

  147. 			       gint                  count);

  148.   void (* backspace)          (GtkEntry             *entry);

  149.   void (* cut_clipboard)      (GtkEntry             *entry);

  150.   void (* copy_clipboard)     (GtkEntry             *entry);

  151.   void (* paste_clipboard)    (GtkEntry             *entry);

  152.   void (* toggle_overwrite)   (GtkEntry             *entry);

  153. 

  154.   /* hook to add other objects beside the entry (like in GtkSpinButton) */

  155.   void (* get_text_area_size) (GtkEntry       *entry,

  156. 			       gint           *x,

  157. 			       gint           *y,

  158. 			       gint           *width,

  159. 			       gint           *height);

  160. 

  161.   /* Padding for future expansion */

  162.   void (*_gtk_reserved1)      (void);

  163.   void (*_gtk_reserved2)      (void);

  164. };

  165. 

  166. GType      gtk_entry_get_type       		(void) G_GNUC_CONST;

  167. GtkWidget* gtk_entry_new            		(void);

  168. GtkWidget* gtk_entry_new_with_buffer            (GtkEntryBuffer *buffer);

  169. 

  170. GtkEntryBuffer* gtk_entry_get_buffer            (GtkEntry       *entry);

  171. void       gtk_entry_set_buffer                 (GtkEntry       *entry,

  172.                                                  GtkEntryBuffer *buffer);

  173. 

  174. GdkWindow *gtk_entry_get_text_window            (GtkEntry      *entry);

  175. 

  176. void       gtk_entry_set_visibility 		(GtkEntry      *entry,

  177. 						 gboolean       visible);

  178. gboolean   gtk_entry_get_visibility             (GtkEntry      *entry);

  179. 

  180. void       gtk_entry_set_invisible_char         (GtkEntry      *entry,

  181.                                                  gunichar       ch);

  182. gunichar   gtk_entry_get_invisible_char         (GtkEntry      *entry);

  183. void       gtk_entry_unset_invisible_char       (GtkEntry      *entry);

  184. 

  185. void       gtk_entry_set_has_frame              (GtkEntry      *entry,

  186.                                                  gboolean       setting);

  187. gboolean   gtk_entry_get_has_frame              (GtkEntry      *entry);

  188. 

  189. void       gtk_entry_set_inner_border                (GtkEntry        *entry,

  190.                                                       const GtkBorder *border);

  191. G_CONST_RETURN GtkBorder* gtk_entry_get_inner_border (GtkEntry        *entry);

  192. 

  193. void       gtk_entry_set_overwrite_mode         (GtkEntry      *entry,

  194.                                                  gboolean       overwrite);

  195. gboolean   gtk_entry_get_overwrite_mode         (GtkEntry      *entry);

  196. 

  197. /* text is truncated if needed */

  198. void       gtk_entry_set_max_length 		(GtkEntry      *entry,

  199. 						 gint           max);

  200. gint       gtk_entry_get_max_length             (GtkEntry      *entry);

  201. guint16    gtk_entry_get_text_length            (GtkEntry      *entry);

  202. 

  203. void       gtk_entry_set_activates_default      (GtkEntry      *entry,

  204.                                                  gboolean       setting);

  205. gboolean   gtk_entry_get_activates_default      (GtkEntry      *entry);

  206. 

  207. void       gtk_entry_set_width_chars            (GtkEntry      *entry,

  208.                                                  gint           n_chars);

  209. gint       gtk_entry_get_width_chars            (GtkEntry      *entry);

  210. 

  211. /* Somewhat more convenient than the GtkEditable generic functions

  212.  */

  213. void       gtk_entry_set_text                   (GtkEntry      *entry,

  214.                                                  const gchar   *text);

  215. /* returns a reference to the text */

  216. G_CONST_RETURN gchar* gtk_entry_get_text        (GtkEntry      *entry);

  217. 

  218. PangoLayout* gtk_entry_get_layout               (GtkEntry      *entry);

  219. void         gtk_entry_get_layout_offsets       (GtkEntry      *entry,

  220.                                                  gint          *x,

  221.                                                  gint          *y);

  222. void       gtk_entry_set_alignment              (GtkEntry      *entry,

  223.                                                  gfloat         xalign);

  224. gfloat     gtk_entry_get_alignment              (GtkEntry      *entry);

  225. 

  226. void                gtk_entry_set_completion (GtkEntry           *entry,

  227.                                               GtkEntryCompletion *completion);

  228. GtkEntryCompletion *gtk_entry_get_completion (GtkEntry           *entry);

  229. 

  230. gint       gtk_entry_layout_index_to_text_index (GtkEntry      *entry,

  231.                                                  gint           layout_index);

  232. gint       gtk_entry_text_index_to_layout_index (GtkEntry      *entry,

  233.                                                  gint           text_index);

  234. 

  235. /* For scrolling cursor appropriately

  236.  */

  237. void           gtk_entry_set_cursor_hadjustment (GtkEntry      *entry,

  238.                                                  GtkAdjustment *adjustment);

  239. GtkAdjustment* gtk_entry_get_cursor_hadjustment (GtkEntry      *entry);

  240. 

  241. /* Progress API

  242.  */

  243. void           gtk_entry_set_progress_fraction   (GtkEntry     *entry,

  244.                                                   gdouble       fraction);

  245. gdouble        gtk_entry_get_progress_fraction   (GtkEntry     *entry);

  246. 

  247. void           gtk_entry_set_progress_pulse_step (GtkEntry     *entry,

  248.                                                   gdouble       fraction);

  249. gdouble        gtk_entry_get_progress_pulse_step (GtkEntry     *entry);

  250. 

  251. void           gtk_entry_progress_pulse          (GtkEntry     *entry);

  252. 

  253. /* Setting and managing icons

  254.  */

  255. void           gtk_entry_set_icon_from_pixbuf            (GtkEntry             *entry,

  256. 							  GtkEntryIconPosition  icon_pos,

  257. 							  GdkPixbuf            *pixbuf);

  258. void           gtk_entry_set_icon_from_stock             (GtkEntry             *entry,

  259. 							  GtkEntryIconPosition  icon_pos,

  260. 							  const gchar          *stock_id);

  261. void           gtk_entry_set_icon_from_icon_name         (GtkEntry             *entry,

  262. 							  GtkEntryIconPosition  icon_pos,

  263. 							  const gchar          *icon_name);

  264. void           gtk_entry_set_icon_from_gicon             (GtkEntry             *entry,

  265. 							  GtkEntryIconPosition  icon_pos,

  266. 							  GIcon                *icon);

  267. GtkImageType gtk_entry_get_icon_storage_type             (GtkEntry             *entry,

  268. 							  GtkEntryIconPosition  icon_pos);

  269. GdkPixbuf*   gtk_entry_get_icon_pixbuf                   (GtkEntry             *entry,

  270. 							  GtkEntryIconPosition  icon_pos);

  271. const gchar* gtk_entry_get_icon_stock                    (GtkEntry             *entry,

  272. 							  GtkEntryIconPosition  icon_pos);

  273. const gchar* gtk_entry_get_icon_name                     (GtkEntry             *entry,

  274. 							  GtkEntryIconPosition  icon_pos);

  275. GIcon*       gtk_entry_get_icon_gicon                    (GtkEntry             *entry,

  276. 							  GtkEntryIconPosition  icon_pos);

  277. void         gtk_entry_set_icon_activatable              (GtkEntry             *entry,

  278. 							  GtkEntryIconPosition  icon_pos,

  279. 							  gboolean              activatable);

  280. gboolean     gtk_entry_get_icon_activatable              (GtkEntry             *entry,

  281. 							  GtkEntryIconPosition  icon_pos);

  282. void         gtk_entry_set_icon_sensitive                (GtkEntry             *entry,

  283. 							  GtkEntryIconPosition  icon_pos,

  284. 							  gboolean              sensitive);

  285. gboolean     gtk_entry_get_icon_sensitive                (GtkEntry             *entry,

  286. 							  GtkEntryIconPosition  icon_pos);

  287. gint         gtk_entry_get_icon_at_pos                   (GtkEntry             *entry,

  288. 							  gint                  x,

  289. 							  gint                  y);

  290. void         gtk_entry_set_icon_tooltip_text             (GtkEntry             *entry,

  291. 							  GtkEntryIconPosition  icon_pos,

  292. 							  const gchar          *tooltip);

  293. gchar *      gtk_entry_get_icon_tooltip_text             (GtkEntry             *entry,

  294.                                                           GtkEntryIconPosition  icon_pos);

  295. void         gtk_entry_set_icon_tooltip_markup           (GtkEntry             *entry,

  296. 							  GtkEntryIconPosition  icon_pos,

  297. 							  const gchar          *tooltip);

  298. gchar *      gtk_entry_get_icon_tooltip_markup           (GtkEntry             *entry,

  299.                                                           GtkEntryIconPosition  icon_pos);

  300. void         gtk_entry_set_icon_drag_source              (GtkEntry             *entry,

  301. 							  GtkEntryIconPosition  icon_pos,

  302. 							  GtkTargetList        *target_list,

  303. 							  GdkDragAction         actions);

  304. gint         gtk_entry_get_current_icon_drag_source      (GtkEntry             *entry);

  305. 

  306. GdkWindow  * gtk_entry_get_icon_window                   (GtkEntry             *entry,

  307.                                                           GtkEntryIconPosition  icon_pos);

  308. 

  309. gboolean    gtk_entry_im_context_filter_keypress         (GtkEntry             *entry,

  310.                                                           GdkEventKey          *event);

  311. void        gtk_entry_reset_im_context                   (GtkEntry             *entry);

  312. 

  313. 

  314. /* Deprecated compatibility functions

  315.  */

  316. 

  317. #ifndef GTK_DISABLE_DEPRECATED

  318. GtkWidget* gtk_entry_new_with_max_length	(gint           max);

  319. void       gtk_entry_append_text    		(GtkEntry      *entry,

  320. 						 const gchar   *text);

  321. void       gtk_entry_prepend_text   		(GtkEntry      *entry,

  322. 						 const gchar   *text);

  323. void       gtk_entry_set_position   		(GtkEntry      *entry,

  324. 						 gint           position);

  325. void       gtk_entry_select_region  		(GtkEntry      *entry,

  326. 						 gint           start,

  327. 						 gint           end);

  328. void       gtk_entry_set_editable   		(GtkEntry      *entry,

  329. 						 gboolean       editable);

  330. #endif /* GTK_DISABLE_DEPRECATED */

  331. 

  332. G_END_DECLS

  333. 

  334. #endif /* __GTK_ENTRY_H__ */